_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 31 13.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q257100 | sklearn2pmml | validation | def sklearn2pmml(pipeline, pmml, user_classpath = [], with_repr = False, debug = False, java_encoding = "UTF-8"):
"""Converts a fitted Scikit-Learn pipeline to PMML.
Parameters:
----------
pipeline: PMMLPipeline
The pipeline.
pmml: string
The path to where the PMML document should be stored.
user_classpath: list of strings, optional
The paths to JAR files that provide custom Transformer, Selector and/or Estimator converter classes.
The JPMML-SkLearn classpath is constructed by appending user JAR files to package JAR files.
with_repr: boolean, optional
If true, insert the string representation of pipeline into the PMML document.
debug: boolean, optional
If true, print information about the conversion process.
java_encoding: string, optional
The character encoding to use for decoding Java output and error byte streams.
"""
if debug:
java_version = _java_version(java_encoding)
if java_version is None:
java_version = ("java", "N/A")
print("python: {0}".format(platform.python_version()))
print("sklearn: {0}".format(sklearn.__version__))
print("sklearn.externals.joblib: {0}".format(joblib.__version__))
print("pandas: {0}".format(pandas.__version__))
print("sklearn_pandas: {0}".format(sklearn_pandas.__version__))
print("sklearn2pmml: {0}".format(__version__))
print("{0}: {1}".format(java_version[0], java_version[1]))
if not isinstance(pipeline, PMMLPipeline):
raise TypeError("The pipeline object is not an instance of " + PMMLPipeline.__name__ + ". Use the 'sklearn2pmml.make_pmml_pipeline(obj)' utility function to translate a regular Scikit-Learn estimator or pipeline to a PMML pipeline")
estimator = pipeline._final_estimator
cmd = ["java", "-cp", os.pathsep.join(_classpath(user_classpath)), "org.jpmml.sklearn.Main"]
dumps = []
try:
if with_repr:
pipeline.repr_ = repr(pipeline)
| python | {
"resource": ""
} |
q257101 | make_tpot_pmml_config | validation | def make_tpot_pmml_config(config, user_classpath = []):
"""Translates a regular TPOT configuration to a PMML-compatible TPOT configuration.
Parameters:
----------
obj: config
The configuration dictionary.
user_classpath: list of strings, optional
The paths to JAR files that provide | python | {
"resource": ""
} |
q257102 | BaseFormSetFactory.construct_formset | validation | def construct_formset(self):
"""
Returns an instance of the formset
"""
formset_class = self.get_formset()
if hasattr(self, 'get_extra_form_kwargs'):
klass = type(self).__name__
raise DeprecationWarning(
'Calling {0}.get_extra_form_kwargs is no longer supported. | python | {
"resource": ""
} |
q257103 | FormSetMixin.get_success_url | validation | def get_success_url(self):
"""
Returns the supplied URL.
"""
if self.success_url:
url = self.success_url
else:
| python | {
"resource": ""
} |
q257104 | ModelFormSetMixin.formset_valid | validation | def formset_valid(self, formset):
"""
If the formset is valid, save the associated models.
"""
| python | {
"resource": ""
} |
q257105 | ProcessFormSetView.get | validation | def get(self, request, *args, **kwargs):
"""
Handles GET requests and instantiates a blank version of the formset.
"""
| python | {
"resource": ""
} |
q257106 | ProcessFormSetView.post | validation | def post(self, request, *args, **kwargs):
"""
Handles POST requests, instantiating a formset instance with the passed
POST variables and then | python | {
"resource": ""
} |
q257107 | InlineFormSetFactory.construct_formset | validation | def construct_formset(self):
"""
Overrides construct_formset to attach the model class as
an attribute of the returned formset instance.
"""
| python | {
"resource": ""
} |
q257108 | ModelFormWithInlinesMixin.forms_valid | validation | def forms_valid(self, form, inlines):
"""
If the form and formsets are valid, save the associated models.
"""
| python | {
"resource": ""
} |
q257109 | ModelFormWithInlinesMixin.forms_invalid | validation | def forms_invalid(self, form, inlines):
"""
If the form or formsets are invalid, re-render the context data with the
data-filled form and formsets and errors.
| python | {
"resource": ""
} |
q257110 | ModelFormWithInlinesMixin.construct_inlines | validation | def construct_inlines(self):
"""
Returns the inline formset instances
"""
inline_formsets = []
for inline_class in self.get_inlines():
| python | {
"resource": ""
} |
q257111 | ProcessFormWithInlinesView.get | validation | def get(self, request, *args, **kwargs):
"""
Handles GET requests and instantiates a blank version of the form and formsets.
"""
| python | {
"resource": ""
} |
q257112 | ProcessFormWithInlinesView.post | validation | def post(self, request, *args, **kwargs):
"""
Handles POST requests, instantiating a form and formset instances with the passed
POST variables and then checked for validity.
"""
form_class = self.get_form_class()
form = self.get_form(form_class)
| python | {
"resource": ""
} |
q257113 | NamedFormsetsMixin.get_context_data | validation | def get_context_data(self, **kwargs):
"""
If `inlines_names` has been defined, add each formset to the context under
its corresponding entry in `inlines_names`
"""
context = {}
inlines_names = self.get_inlines_names()
if inlines_names:
# We have formset or inlines in context, but never both
| python | {
"resource": ""
} |
q257114 | SortHelper.get_params_for_field | validation | def get_params_for_field(self, field_name, sort_type=None):
"""
If sort_type is None - inverse current sort for field, if no sorted - use asc
"""
if not sort_type:
if self.initial_sort == field_name:
| python | {
"resource": ""
} |
q257115 | BaseCalendarMonthView.get_start_date | validation | def get_start_date(self, obj):
"""
Returns the start date for a model instance
"""
obj_date = getattr(obj, self.get_date_field())
try:
obj_date = obj_date.date()
except AttributeError:
| python | {
"resource": ""
} |
q257116 | BaseCalendarMonthView.get_end_date | validation | def get_end_date(self, obj):
"""
Returns the end date for a model instance
"""
obj_date = getattr(obj, self.get_end_date_field())
try:
obj_date = obj_date.date()
except AttributeError:
| python | {
"resource": ""
} |
q257117 | BaseCalendarMonthView.get_first_of_week | validation | def get_first_of_week(self):
"""
Returns an integer representing the first day of the week.
0 represents Monday, 6 represents Sunday.
"""
if self.first_of_week is None:
| python | {
"resource": ""
} |
q257118 | BaseCalendarMonthView.get_queryset | validation | def get_queryset(self):
"""
Returns a queryset of models for the month requested
"""
qs = super(BaseCalendarMonthView, self).get_queryset()
year = self.get_year()
month = self.get_month()
date_field = self.get_date_field()
end_date_field = self.get_end_date_field()
date = _date_from_string(year, self.get_year_format(),
month, self.get_month_format())
since = date
until = self.get_next_month(date)
# Adjust our start and end dates to allow for next and previous
# month edges
if since.weekday() != self.get_first_of_week():
diff = math.fabs(since.weekday() - self.get_first_of_week())
since = since - datetime.timedelta(days=diff)
if until.weekday() != ((self.get_first_of_week() + 6) % 7):
diff = math.fabs(((self.get_first_of_week() + 6) % 7) - until.weekday())
until = until + datetime.timedelta(days=diff)
if end_date_field:
| python | {
"resource": ""
} |
q257119 | BaseCalendarMonthView.get_context_data | validation | def get_context_data(self, **kwargs):
"""
Injects variables necessary for rendering the calendar into the context.
Variables added are: `calendar`, `weekdays`, `month`, `next_month` and `previous_month`.
"""
data = super(BaseCalendarMonthView, self).get_context_data(**kwargs)
year = self.get_year()
month = self.get_month()
date = _date_from_string(year, self.get_year_format(),
month, self.get_month_format())
cal = Calendar(self.get_first_of_week())
month_calendar = []
now = datetime.datetime.utcnow()
date_lists = defaultdict(list)
multidate_objs = []
for obj in data['object_list']:
obj_date = self.get_start_date(obj)
end_date_field = self.get_end_date_field()
if end_date_field:
end_date = self.get_end_date(obj)
if end_date and end_date != obj_date:
multidate_objs.append({
'obj': obj,
'range': [x for x in daterange(obj_date, end_date)]
})
continue # We don't put multi-day events in date_lists
date_lists[obj_date].append(obj)
for week in cal.monthdatescalendar(date.year, date.month):
week_range = set(daterange(week[0], week[6]))
week_events = []
for val in multidate_objs:
intersect_length = len(week_range.intersection(val['range']))
if intersect_length:
# Event happens during this week
slot = 1
width = intersect_length # How many days is the event during this week?
nowrap_previous = True # Does the event continue from the previous week?
nowrap_next = True # Does the event continue to the next week?
if val['range'][0] >= week[0]:
slot = 1 + (val['range'][0] - week[0]).days | python | {
"resource": ""
} |
q257120 | ColorfulModule.with_setup | validation | def with_setup(self, colormode=None, colorpalette=None, extend_colors=False):
"""
Return a new Colorful object with the given color config.
"""
colorful = Colorful(
colormode=self.colorful.colormode,
colorpalette=copy.copy(self.colorful.colorpalette)
| python | {
"resource": ""
} |
q257121 | parse_colors | validation | def parse_colors(path):
"""Parse the given color files.
Supported are:
* .txt for X11 colors
* .json for colornames
"""
if path.endswith(".txt"):
return parse_rgb_txt_file(path)
| python | {
"resource": ""
} |
q257122 | parse_rgb_txt_file | validation | def parse_rgb_txt_file(path):
"""
Parse the given rgb.txt file into a Python dict.
See https://en.wikipedia.org/wiki/X11_color_names for more information
:param str path: the path to the X11 rgb.txt file
"""
#: Holds the generated color dict
| python | {
"resource": ""
} |
q257123 | parse_json_color_file | validation | def parse_json_color_file(path):
"""Parse a JSON color file.
The JSON has to be in the following format:
.. code:: json
[{"name": "COLOR_NAME", "hex": "#HEX"}, ...]
:param str path: the path to the JSON color file
"""
with open(path, "r") as color_file:
| python | {
"resource": ""
} |
q257124 | sanitize_color_palette | validation | def sanitize_color_palette(colorpalette):
"""
Sanitze the given color palette so it can
be safely used by Colorful.
It will convert colors specified in hex RGB to
a RGB channel triplet.
"""
new_palette = {}
def __make_valid_color_name(name):
"""
Convert the given name into a valid colorname
"""
if len(name) == 1:
name = name[0]
return name[:1].lower() + name[1:]
return name[0].lower() + ''.join(word.capitalize() for word in name[1:]) | python | {
"resource": ""
} |
q257125 | detect_color_support | validation | def detect_color_support(env): # noqa
"""
Detect what color palettes are supported.
It'll return a valid color mode to use
with colorful.
:param dict env: the environment dict like returned by ``os.envion``
"""
if env.get('COLORFUL_DISABLE', '0') == '1':
return NO_COLORS
if env.get('COLORFUL_FORCE_8_COLORS', '0') == '1':
return ANSI_8_COLORS
if env.get('COLORFUL_FORCE_16_COLORS', '0') == '1':
return ANSI_16_COLORS
if env.get('COLORFUL_FORCE_256_COLORS', '0') == '1':
return ANSI_256_COLORS
if env.get('COLORFUL_FORCE_TRUE_COLORS', '0') == '1':
return TRUE_COLORS
# if we are not a tty
if not sys.stdout.isatty():
return NO_COLORS
colorterm_env = env.get('COLORTERM')
if colorterm_env:
if colorterm_env in {'truecolor', '24bit'}:
return TRUE_COLORS
if colorterm_env in {'8bit'}:
return ANSI_256_COLORS
termprog_env = env.get('TERM_PROGRAM')
if termprog_env:
if termprog_env in {'iTerm.app', 'Hyper'}:
return TRUE_COLORS
if termprog_env in {'Apple_Terminal'}:
| python | {
"resource": ""
} |
q257126 | rgb_to_ansi256 | validation | def rgb_to_ansi256(r, g, b):
"""
Convert RGB to ANSI 256 color
"""
if r == g and g == b:
if r < 8:
return 16
if r > 248:
return 231
return round(((r - 8) / 247.0) * 24) + 232
| python | {
"resource": ""
} |
q257127 | rgb_to_ansi16 | validation | def rgb_to_ansi16(r, g, b, use_bright=False):
"""
Convert RGB to ANSI 16 color
"""
ansi_b = round(b / 255.0) << 2
ansi_g = round(g / 255.0) << 1
| python | {
"resource": ""
} |
q257128 | hex_to_rgb | validation | def hex_to_rgb(value):
"""
Convert the given hex string to a
valid RGB channel triplet.
"""
value = value.lstrip('#')
check_hex(value)
length = len(value)
| python | {
"resource": ""
} |
q257129 | check_hex | validation | def check_hex(value):
"""
Check if the given hex value is a valid RGB color
It should match the format: [0-9a-fA-F]
and be of length 3 or 6.
"""
length = len(value)
| python | {
"resource": ""
} |
q257130 | translate_rgb_to_ansi_code | validation | def translate_rgb_to_ansi_code(red, green, blue, offset, colormode):
"""
Translate the given RGB color into the appropriate ANSI escape code
for the given color mode.
The offset is used for the base color which is used.
The ``colormode`` has to be one of:
* 0: no colors / disabled
* 8: use ANSI 8 colors
* 16: use ANSI 16 colors (same as 8 but with brightness)
* 256: use ANSI 256 colors
* 0xFFFFFF / 16777215: use 16 Million true colors
:param int red: the red channel value
:param int green: the green channel value
:param int blue: the blue channel value
:param int offset: the offset to use for the base color
:param int colormode: the color mode to use. See explanation above
"""
if colormode == terminal.NO_COLORS: # colors are disabled, thus return empty | python | {
"resource": ""
} |
q257131 | translate_colorname_to_ansi_code | validation | def translate_colorname_to_ansi_code(colorname, offset, colormode, colorpalette):
"""
Translate the given color name to a valid
ANSI escape code.
:parma str colorname: the name of the color to resolve
:parma str offset: the offset for the color code
:param int colormode: the color mode to use. See ``translate_rgb_to_ansi_code``
| python | {
"resource": ""
} |
q257132 | resolve_modifier_to_ansi_code | validation | def resolve_modifier_to_ansi_code(modifiername, colormode):
"""
Resolve the given modifier name to a valid
ANSI escape code.
:param str modifiername: the name of the modifier to resolve
:param int colormode: the color mode to use. See ``translate_rgb_to_ansi_code``
:returns str: the ANSI escape code for the modifier
:raises ColorfulError: if the given modifier | python | {
"resource": ""
} |
q257133 | translate_style | validation | def translate_style(style, colormode, colorpalette):
"""
Translate the given style to an ANSI escape code
sequence.
``style`` examples are:
* green
* bold
* red_on_black
* bold_green
* italic_yellow_on_cyan
:param str style: the style to translate
:param int colormode: the color mode to use. See ``translate_rgb_to_ansi_code``
:parma dict colorpalette: the color palette to use for the color name mapping
"""
style_parts = iter(style.split('_'))
ansi_start_sequence = []
ansi_end_sequence = []
try:
# consume all modifiers
part = None
for mod_part in style_parts:
part = mod_part
if part not in ansi.MODIFIERS:
break # all modifiers have been consumed
mod_start_code, mod_end_code = resolve_modifier_to_ansi_code(part, colormode)
ansi_start_sequence.append(mod_start_code)
ansi_end_sequence.append(mod_end_code)
else: # we've consumed all parts, thus we can exit
raise StopIteration()
# next part has to be a foreground color or the 'on' keyword
# which means we have to consume background colors
if part != 'on':
ansi_start_code, ansi_end_code = translate_colorname_to_ansi_code(
part, ansi.FOREGROUND_COLOR_OFFSET, colormode, | python | {
"resource": ""
} |
q257134 | style_string | validation | def style_string(string, ansi_style, colormode, nested=False):
"""
Style the given string according to the given
ANSI style string.
:param str string: the string to style
:param tuple ansi_style: the styling string returned by ``translate_style``
:param int colormode: the color mode to use. See ``translate_rgb_to_ansi_code``
:returns: a string containing proper ANSI sequence | python | {
"resource": ""
} |
q257135 | Colorful.colorpalette | validation | def colorpalette(self, colorpalette):
"""
Set the colorpalette which should be used
"""
if isinstance(colorpalette, str): # we assume it's a path to a color file
| python | {
"resource": ""
} |
q257136 | Colorful.setup | validation | def setup(self, colormode=None, colorpalette=None, extend_colors=False):
"""
Setup this colorful object by setting a ``colormode`` and
the ``colorpalette`. The ``extend_colors`` flag is used
to extend the currently active color palette instead of
replacing it.
:param int colormode: the color mode to use. See ``translate_rgb_to_ansi_code``
:parma dict colorpalette: the colorpalette to use. This ``dict`` should map
color names to it's corresponding RGB value
:param bool extend_colors: extend | python | {
"resource": ""
} |
q257137 | Colorful.use_style | validation | def use_style(self, style_name):
"""
Use a predefined style as color palette
:param str style_name: the name of the style
"""
try:
style = getattr(styles, style_name.upper())
except AttributeError:
| python | {
"resource": ""
} |
q257138 | Colorful.format | validation | def format(self, string, *args, **kwargs):
"""
Format the given string with the given ``args`` and ``kwargs``.
The string can contain references to ``c`` which is provided by
| python | {
"resource": ""
} |
q257139 | readattr | validation | def readattr(path, name):
"""
Read attribute from sysfs and return as string
"""
try:
f = open(USB_SYS_PREFIX + path + "/" | python | {
"resource": ""
} |
q257140 | find_ports | validation | def find_ports(device):
"""
Find the port chain a device is plugged on.
This is done by searching sysfs for a device that matches the device
bus/address combination.
Useful when the underlying usb lib does not return device.port_number for
whatever reason.
"""
bus_id = device.bus
dev_id = device.address
for dirent in os.listdir(USB_SYS_PREFIX):
matches = re.match(USB_PORTS_STR + '$', dirent)
if matches:
bus_str = readattr(dirent, 'busnum')
if bus_str:
busnum | python | {
"resource": ""
} |
q257141 | TemperDevice.get_data | validation | def get_data(self, reset_device=False):
"""
Get data from the USB device.
"""
try:
if reset_device:
self._device.reset()
# detach kernel driver from both interfaces if attached, so we can set_configuration()
for interface in [0,1]:
if self._device.is_kernel_driver_active(interface):
LOGGER.debug('Detaching kernel driver for interface %d '
'of %r on ports %r', interface, self._device, self._ports)
self._device.detach_kernel_driver(interface)
self._device.set_configuration()
# Prevent kernel message:
# "usbfs: process <PID> (python) did not claim interface x before use"
# This will become unnecessary once pull-request #124 for
# PyUSB has been accepted and we depend on a fixed release
# of PyUSB. Until then, and even with the fix applied, it
# does not hurt to explicitly claim the interface.
usb.util.claim_interface(self._device, INTERFACE)
# Turns out we don't actually need that ctrl_transfer.
# Disabling this reduces number of USBErrors from ~7/30 to 0!
#self._device.ctrl_transfer(bmRequestType=0x21, bRequest=0x09,
# wValue=0x0201, wIndex=0x00, data_or_wLength='\x01\x01',
# timeout=TIMEOUT)
# Magic: Our TEMPerV1.4 likes to be asked twice. When
# only asked once, it get's stuck on the next access and
# requires a reset.
self._control_transfer(COMMANDS['temp'])
self._interrupt_read()
# Turns out a whole lot of that magic seems unnecessary.
#self._control_transfer(COMMANDS['ini1'])
#self._interrupt_read()
#self._control_transfer(COMMANDS['ini2'])
#self._interrupt_read()
#self._interrupt_read()
# Get temperature
self._control_transfer(COMMANDS['temp'])
temp_data = self._interrupt_read()
# Get humidity
| python | {
"resource": ""
} |
q257142 | TemperDevice.get_humidity | validation | def get_humidity(self, sensors=None):
"""
Get device humidity reading.
Params:
- sensors: optional list of sensors to get a reading for, examples:
[0,] - get reading for sensor 0
[0, 1,] - get reading for sensors 0 and 1
None - get readings for all sensors
"""
_sensors = sensors
if _sensors is None:
_sensors = list(range(0, self._sensor_count))
if not set(_sensors).issubset(list(range(0, self._sensor_count))):
raise ValueError(
'Some or all of the sensors in the list %s are out of range '
'given a sensor_count of %d. Valid range: %s' % (
_sensors,
self._sensor_count,
list(range(0, self._sensor_count)),
)
)
data = self.get_data() | python | {
"resource": ""
} |
q257143 | TemperDevice._interrupt_read | validation | def _interrupt_read(self):
"""
Read data from device.
"""
data = | python | {
"resource": ""
} |
q257144 | Github.read_file_from_uri | validation | def read_file_from_uri(self, uri):
"""Reads the file from Github
:param uri: URI of the Github raw File
:returns: UTF-8 text with the content
"""
logger.debug("Reading %s" % (uri))
self.__check_looks_like_uri(uri)
try:
| python | {
"resource": ""
} |
q257145 | TaskRawDataArthurCollection.measure_memory | validation | def measure_memory(cls, obj, seen=None):
"""Recursively finds size of objects"""
size = sys.getsizeof(obj)
if seen is None:
seen = set()
obj_id = id(obj)
if obj_id in seen:
return 0
# Important mark as seen *before* entering recursion to gracefully handle
# self-referential objects
| python | {
"resource": ""
} |
q257146 | TaskRawDataArthurCollection.__create_arthur_json | validation | def __create_arthur_json(self, repo, backend_args):
""" Create the JSON for configuring arthur to collect data
https://github.com/grimoirelab/arthur#adding-tasks
Sample for git:
{
"tasks": [
{
"task_id": "arthur.git",
"backend": "git",
"backend_args": {
"gitpath": "/tmp/arthur_git/",
"uri": "https://github.com/grimoirelab/arthur.git"
},
"category": "commit",
"archive_args": {
"archive_path": '/tmp/test_archives',
"fetch_from_archive": false,
"archive_after": None
},
"scheduler_args": {
"delay": 10
}
}
]
}
"""
backend_args = self._compose_arthur_params(self.backend_section, repo)
if self.backend_section == 'git':
backend_args['gitpath'] = os.path.join(self.REPOSITORY_DIR, repo)
backend_args['tag'] = self.backend_tag(repo)
ajson = {"tasks": [{}]}
# This is the perceval tag
ajson["tasks"][0]['task_id'] = self.backend_tag(repo)
ajson["tasks"][0]['backend'] = self.backend_section.split(":")[0]
ajson["tasks"][0]['backend_args'] = backend_args
ajson["tasks"][0]['category'] = backend_args['category']
ajson["tasks"][0]['archive'] = {}
ajson["tasks"][0]['scheduler'] = {"delay": self.ARTHUR_TASK_DELAY}
# from-date or offset param must be added
es_col_url = self._get_collection_url()
es_index = self.conf[self.backend_section]['raw_index']
# Get the last | python | {
"resource": ""
} |
q257147 | TaskIdentitiesExport.sha_github_file | validation | def sha_github_file(cls, config, repo_file, repository_api, repository_branch):
""" Return the GitHub SHA for a file in the repository """
repo_file_sha = None
cfg = config.get_conf()
github_token = cfg['sortinghat']['identities_api_token']
headers = {"Authorization": "token " + github_token}
url_dir = repository_api + "/git/trees/" + repository_branch
logger.debug("Gettting sha data from tree: %s", url_dir)
| python | {
"resource": ""
} |
q257148 | TaskIdentitiesMerge.__get_uuids_from_profile_name | validation | def __get_uuids_from_profile_name(self, profile_name):
""" Get the uuid for a profile name """
uuids = []
with self.db.connect() as session:
query = session.query(Profile).\
filter(Profile.name == profile_name)
| python | {
"resource": ""
} |
q257149 | get_raw | validation | def get_raw(config, backend_section, arthur):
"""Execute the raw phase for a given backend section, optionally using Arthur
:param config: a Mordred config object
:param backend_section: the backend section where the raw phase is executed
:param arthur: if true, it enables Arthur to collect the raw data
"""
if arthur:
task = TaskRawDataArthurCollection(config, backend_section=backend_section)
else:
| python | {
"resource": ""
} |
q257150 | get_identities | validation | def get_identities(config):
"""Execute the merge identities phase
:param config: a Mordred config object
"""
TaskProjects(config).execute()
task = | python | {
"resource": ""
} |
q257151 | get_enrich | validation | def get_enrich(config, backend_section):
"""Execute the enrich phase for a given backend section
:param config: a Mordred config object
:param backend_section: the backend section where the enrich phase | python | {
"resource": ""
} |
q257152 | get_panels | validation | def get_panels(config):
"""Execute the panels phase
:param config: a Mordred config object
"""
task = TaskPanels(config)
task.execute()
| python | {
"resource": ""
} |
q257153 | config_logging | validation | def config_logging(debug):
"""Config logging level output output"""
if debug:
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(message)s')
| python | {
"resource": ""
} |
q257154 | get_params_parser | validation | def get_params_parser():
"""Parse command line arguments"""
parser = argparse.ArgumentParser(add_help=False)
parser.add_argument('-g', '--debug', dest='debug',
action='store_true',
help=argparse.SUPPRESS)
parser.add_argument("--arthur", action='store_true', dest='arthur',
help="Enable arthur to collect raw data")
parser.add_argument("--raw", action='store_true', dest='raw',
help="Activate raw task")
parser.add_argument("--enrich", action='store_true', dest='enrich',
help="Activate enrich task")
parser.add_argument("--identities", action='store_true', dest='identities',
help="Activate merge identities task")
| python | {
"resource": ""
} |
q257155 | get_params | validation | def get_params():
"""Get params to execute the micro-mordred"""
parser = get_params_parser()
args = parser.parse_args()
| python | {
"resource": ""
} |
q257156 | TaskPanels.__kibiter_version | validation | def __kibiter_version(self):
""" Get the kibiter vesion.
:param major: major Elasticsearch version
"""
version = None
es_url = self.conf['es_enrichment']['url']
config_url = '.kibana/config/_search'
url = urijoin(es_url, config_url)
| python | {
"resource": ""
} |
q257157 | TaskPanels.create_dashboard | validation | def create_dashboard(self, panel_file, data_sources=None, strict=True):
"""Upload a panel to Elasticsearch if it does not exist yet.
If a list of data sources is specified, upload only those
elements (visualizations, searches) that match that data source.
:param panel_file: file name of panel (dashobard) to upload
:param data_sources: list of data sources
:param strict: only upload a dashboard if it is newer than the one already existing
"""
es_enrich = self.conf['es_enrichment']['url']
kibana_url = self.conf['panels']['kibiter_url']
mboxes_sources = set(['pipermail', 'hyperkitty', 'groupsio', 'nntp'])
if data_sources and any(x in data_sources for x in mboxes_sources):
data_sources = list(data_sources)
data_sources.append('mbox')
if data_sources and ('supybot' in data_sources):
data_sources = list(data_sources)
data_sources.append('irc')
if data_sources and 'google_hits' in data_sources:
data_sources = list(data_sources)
data_sources.append('googlehits')
if data_sources and 'stackexchange' in data_sources:
# stackexchange is called | python | {
"resource": ""
} |
q257158 | TaskPanelsMenu.__upload_title | validation | def __upload_title(self, kibiter_major):
"""Upload to Kibiter the title for the dashboard.
The title is shown on top of the dashboard menu, and is Usually
the name of the project being dashboarded.
This is done only for Kibiter 6.x.
:param kibiter_major: major version of kibiter
"""
if kibiter_major == "6":
resource = ".kibana/doc/projectname"
data = {"projectname": {"name": self.project_name}}
mapping_resource = ".kibana/_mapping/doc"
mapping = {"dynamic": "true"}
url = urijoin(self.conf['es_enrichment']['url'], resource)
mapping_url = urijoin(self.conf['es_enrichment']['url'],
mapping_resource)
logger.debug("Adding mapping for dashboard title")
res = self.grimoire_con.put(mapping_url, data=json.dumps(mapping),
headers=ES6_HEADER)
try:
| python | {
"resource": ""
} |
q257159 | TaskPanelsMenu.__create_dashboard_menu | validation | def __create_dashboard_menu(self, dash_menu, kibiter_major):
"""Create the menu definition to access the panels in a dashboard.
:param menu: dashboard menu to upload
:param kibiter_major: major version of kibiter
"""
logger.info("Adding dashboard menu")
if kibiter_major == "6":
menu_resource = ".kibana/doc/metadashboard"
mapping_resource = ".kibana/_mapping/doc"
mapping = {"dynamic": "true"}
menu = {'metadashboard': dash_menu}
else:
menu_resource = ".kibana/metadashboard/main"
mapping_resource = ".kibana/_mapping/metadashboard"
mapping = {"dynamic": "true"}
menu = dash_menu
menu_url = urijoin(self.conf['es_enrichment']['url'],
menu_resource)
mapping_url = urijoin(self.conf['es_enrichment']['url'],
mapping_resource)
logger.debug("Adding mapping for metadashboard")
res = self.grimoire_con.put(mapping_url, data=json.dumps(mapping),
| python | {
"resource": ""
} |
q257160 | TaskPanelsMenu.__remove_dashboard_menu | validation | def __remove_dashboard_menu(self, kibiter_major):
"""Remove existing menu for dashboard, if any.
Usually, we remove the menu before creating a new one.
:param kibiter_major: major version of kibiter
"""
logger.info("Removing old dashboard menu, if any")
if kibiter_major == "6":
| python | {
"resource": ""
} |
q257161 | TaskPanelsMenu.__get_menu_entries | validation | def __get_menu_entries(self, kibiter_major):
""" Get the menu entries from the panel definition """
menu_entries = []
for entry in self.panels_menu:
if entry['source'] not in self.data_sources:
continue
parent_menu_item = {
'name': entry['name'],
'title': entry['name'],
'description': "",
'type': "menu",
'dashboards': []
}
for subentry in entry['menu']:
try:
dash_name = get_dashboard_name(subentry['panel'])
except FileNotFoundError:
logging.error("Can't open dashboard file %s", subentry['panel'])
continue
# The name for the entry is in self.panels_menu
| python | {
"resource": ""
} |
q257162 | TaskPanelsMenu.__get_dash_menu | validation | def __get_dash_menu(self, kibiter_major):
"""Order the dashboard menu"""
# omenu = OrderedDict()
omenu = []
# Start with Overview
omenu.append(self.menu_panels_common['Overview'])
# Now the data _getsources
ds_menu = self.__get_menu_entries(kibiter_major)
# Remove the kafka and community menus, they will be included at the end
kafka_menu = None
community_menu = None
found_kafka = [pos for pos, menu in enumerate(ds_menu) if menu['name'] == KAFKA_NAME]
if found_kafka:
kafka_menu = ds_menu.pop(found_kafka[0])
found_community = [pos for pos, menu in enumerate(ds_menu) if menu['name'] == COMMUNITY_NAME]
if found_community:
community_menu = ds_menu.pop(found_community[0])
| python | {
"resource": ""
} |
q257163 | compose_mbox | validation | def compose_mbox(projects):
""" Compose projects.json only for mbox, but using the mailing_lists lists
change: 'https://dev.eclipse.org/mailman/listinfo/emft-dev'
to: 'emfg-dev /home/bitergia/mboxes/emft-dev.mbox/emft-dev.mbox
:param projects: projects.json
:return: projects.json with mbox
"""
mbox_archives = '/home/bitergia/mboxes'
mailing_lists_projects = [project for project in projects if 'mailing_lists' in projects[project]]
for mailing_lists in mailing_lists_projects:
projects[mailing_lists]['mbox'] = []
for mailing_list in projects[mailing_lists]['mailing_lists']:
if 'listinfo' in mailing_list:
name = mailing_list.split('listinfo/')[1]
| python | {
"resource": ""
} |
q257164 | compose_gerrit | validation | def compose_gerrit(projects):
""" Compose projects.json for gerrit, but using the git lists
change: 'http://git.eclipse.org/gitroot/xwt/org.eclipse.xwt.git'
to: 'git.eclipse.org_xwt/org.eclipse.xwt
:param projects: projects.json
:return: projects.json with gerrit
"""
git_projects = [project for project in projects if 'git' in | python | {
"resource": ""
} |
q257165 | compose_git | validation | def compose_git(projects, data):
""" Compose projects.json for git
We need to replace '/c/' by '/gitroot/' for instance
change: 'http://git.eclipse.org/c/xwt/org.eclipse.xwt.git'
to: 'http://git.eclipse.org/gitroot/xwt/org.eclipse.xwt.git'
:param projects: projects.json
:param data: eclipse JSON
:return: projects.json with git
"""
for p in [project for project in data if len(data[project]['source_repo']) > 0]:
repos = []
for url in data[p]['source_repo']:
if len(url['url'].split()) > 1: # Error at upstream the project 'tools.corrosion'
| python | {
"resource": ""
} |
q257166 | compose_mailing_lists | validation | def compose_mailing_lists(projects, data):
""" Compose projects.json for mailing lists
At upstream has two different key for mailing list: 'mailings_lists' and 'dev_list'
The key 'mailing_lists' is an array with mailing lists
The key 'dev_list' is a dict with only one mailing list
:param projects: projects.json
:param data: eclipse JSON
:return: projects.json with mailing_lists
"""
for p in [project for project in data if len(data[project]['mailing_lists']) > 0]:
if 'mailing_lists' not in projects[p]:
projects[p]['mailing_lists'] = []
urls = [url['url'].replace('mailto:', '') for url in data[p]['mailing_lists'] if
url['url'] not in projects[p]['mailing_lists']]
| python | {
"resource": ""
} |
q257167 | compose_github | validation | def compose_github(projects, data):
""" Compose projects.json for github
:param projects: projects.json
:param data: eclipse JSON
:return: projects.json with github
"""
for p in [project for project in data if len(data[project]['github_repos']) > 0]:
if 'github' not in projects[p]:
projects[p]['github'] = []
| python | {
"resource": ""
} |
q257168 | compose_bugzilla | validation | def compose_bugzilla(projects, data):
""" Compose projects.json for bugzilla
:param projects: projects.json
:param data: eclipse JSON
:return: projects.json with bugzilla
"""
for p in [project for project in data if len(data[project]['bugzilla']) > 0]:
if 'bugzilla' not in projects[p]:
projects[p]['bugzilla'] = []
| python | {
"resource": ""
} |
q257169 | compose_title | validation | def compose_title(projects, data):
""" Compose the projects JSON file only with the projects name
:param projects: projects.json
:param data: eclipse JSON with | python | {
"resource": ""
} |
q257170 | compose_projects_json | validation | def compose_projects_json(projects, data):
""" Compose projects.json with all data sources
:param projects: projects.json
:param data: eclipse JSON
:return: projects.json with all data sources
"""
projects = compose_git(projects, data)
projects | python | {
"resource": ""
} |
q257171 | TaskEnrich.__autorefresh_studies | validation | def __autorefresh_studies(self, cfg):
"""Execute autorefresh for areas of code study if configured"""
if 'studies' not in self.conf[self.backend_section] or \
'enrich_areas_of_code:git' not in self.conf[self.backend_section]['studies']:
logger.debug("Not doing autorefresh for studies, Areas of Code study is not active.")
return
aoc_index = self.conf['enrich_areas_of_code:git'].get('out_index', GitEnrich.GIT_AOC_ENRICHED)
# if `out_index` exists but has no value, use default
if not aoc_index:
aoc_index = GitEnrich.GIT_AOC_ENRICHED
logger.debug("Autorefresh for Areas of Code study index: %s", aoc_index)
| python | {
"resource": ""
} |
q257172 | TaskEnrich.__studies | validation | def __studies(self, retention_time):
""" Execute the studies configured for the current backend """
cfg = self.config.get_conf()
if 'studies' not in cfg[self.backend_section] or not \
cfg[self.backend_section]['studies']:
logger.debug('No studies for %s' % self.backend_section)
return
studies = [study for study in cfg[self.backend_section]['studies'] if study.strip() != ""]
if not studies:
logger.debug('No studies for %s' % self.backend_section)
return
logger.debug("Executing studies for %s: %s" % (self.backend_section, studies))
time.sleep(2) # Wait so enrichment has finished in ES
enrich_backend = self._get_enrich_backend()
ocean_backend = self._get_ocean_backend(enrich_backend)
| python | {
"resource": ""
} |
q257173 | TaskEnrich.retain_identities | validation | def retain_identities(self, retention_time):
"""Retain the identities in SortingHat based on the `retention_time`
value declared in the setup.cfg.
:param retention_time: maximum number of minutes wrt the current date to retain the SortingHat data
"""
enrich_es = self.conf['es_enrichment']['url']
sortinghat_db = self.db
current_data_source = self.get_backend(self.backend_section)
active_data_sources = self.config.get_active_data_sources()
if retention_time is None:
| python | {
"resource": ""
} |
q257174 | TaskProjects.get_repos_by_backend_section | validation | def get_repos_by_backend_section(cls, backend_section, raw=True):
""" return list with the repositories for a backend_section """
repos = []
projects = TaskProjects.get_projects()
for pro in projects:
if backend_section in projects[pro]:
# if the projects.json doesn't contain the `unknown` project, add the repos in the bck section
if cls.GLOBAL_PROJECT not in projects:
repos += projects[pro][backend_section]
else:
# if the projects.json contains the `unknown` project
# in the case of the collection phase
if raw:
# if the current project is not `unknown`
if pro != cls.GLOBAL_PROJECT:
# if the bck section is not in the `unknown` project, add the repos in the bck section
if backend_section not in projects[cls.GLOBAL_PROJECT]:
repos += projects[pro][backend_section]
# if the backend section is in the `unknown` project,
# add the repo in the bck section under `unknown`
elif backend_section in projects[pro] and backend_section in projects[cls.GLOBAL_PROJECT]:
repos += projects[cls.GLOBAL_PROJECT][backend_section]
# if the current project is `unknown`
else:
# if the backend section is only in the `unknown` project,
# add the repo in the bck section under `unknown`
not_in_unknown = [projects[pro] for pro in projects if pro != cls.GLOBAL_PROJECT][0]
if backend_section not in not_in_unknown:
repos += projects[cls.GLOBAL_PROJECT][backend_section]
# in the case of the enrichment phase
else:
| python | {
"resource": ""
} |
q257175 | TaskProjects.convert_from_eclipse | validation | def convert_from_eclipse(self, eclipse_projects):
""" Convert from eclipse projects format to grimoire projects json format """
projects = {}
# We need the global project for downloading the full Bugzilla and Gerrit
projects['unknown'] = {
"gerrit": ["git.eclipse.org"],
| python | {
"resource": ""
} |
q257176 | Config.set_param | validation | def set_param(self, section, param, value):
""" Change a param in the config """
if section not in self.conf or param not in self.conf[section]:
logger.error('Config | python | {
"resource": ""
} |
q257177 | Config._add_to_conf | validation | def _add_to_conf(self, new_conf):
"""Add new configuration to self.conf.
Adds configuration parameters in new_con to self.conf.
If they already existed in conf, overwrite them.
:param new_conf: new configuration, to add
"""
for section in new_conf:
| python | {
"resource": ""
} |
q257178 | Task.es_version | validation | def es_version(self, url):
"""Get Elasticsearch version.
Get the version of Elasticsearch. This is useful because
Elasticsearch and Kibiter are paired (same major version for 5, 6).
:param url: Elasticseearch url hosting Kibiter indices
:returns: major version, as string
"""
try:
res = self.grimoire_con.get(url)
res.raise_for_status()
| python | {
"resource": ""
} |
q257179 | SirMordred.execute_nonstop_tasks | validation | def execute_nonstop_tasks(self, tasks_cls):
"""
Just a wrapper to the execute_batch_tasks method
"""
self.execute_batch_tasks(tasks_cls,
| python | {
"resource": ""
} |
q257180 | SirMordred.execute_batch_tasks | validation | def execute_batch_tasks(self, tasks_cls, big_delay=0, small_delay=0, wait_for_threads=True):
"""
Start a task manager per backend to complete the tasks.
:param task_cls: list of tasks classes to be executed
:param big_delay: seconds before global tasks are executed, should be days usually
:param small_delay: seconds before backend tasks are executed, should be minutes
:param wait_for_threads: boolean to set when threads are infinite or
should be synchronized in a meeting point
"""
def _split_tasks(tasks_cls):
"""
we internally distinguish between tasks executed by backend
and tasks executed with no specific backend. """
backend_t = []
global_t = []
for t in tasks_cls:
if t.is_backend_task(t):
backend_t.append(t)
else:
global_t.append(t)
return backend_t, global_t
backend_tasks, global_tasks = _split_tasks(tasks_cls)
logger.debug('backend_tasks = %s' % (backend_tasks))
logger.debug('global_tasks = %s' % (global_tasks)) | python | {
"resource": ""
} |
q257181 | SirMordred.__execute_initial_load | validation | def __execute_initial_load(self):
"""
Tasks that should be done just one time
"""
if self.conf['phases']['panels']:
tasks_cls = [TaskPanels, TaskPanelsMenu]
self.execute_tasks(tasks_cls)
if self.conf['phases']['identities']:
tasks_cls = [TaskInitSortingHat]
| python | {
"resource": ""
} |
q257182 | Config.validate_config | validation | def validate_config(self):
'''
Validates the provided config to make sure all the required fields are
there.
'''
# first ensure that all the required fields are there
for key, key_config in self.params_map.items():
if key_config['required']:
if key not in self.config:
raise ValueError("Invalid Configuration! Required parameter '%s' was not provided to Sultan.")
# second ensure that the fields that were pased were | python | {
"resource": ""
} |
q257183 | Result.stdout | validation | def stdout(self):
"""
Converts stdout string to a list.
"""
if self._streaming:
stdout = []
while not self.__stdout.empty():
try:
| python | {
"resource": ""
} |
q257184 | Result.stderr | validation | def stderr(self):
"""
Converts stderr string to a list.
"""
if self._streaming:
stderr = []
while not self.__stderr.empty():
try:
| python | {
"resource": ""
} |
q257185 | LevelFormatter.format | validation | def format(self, record):
"""Customize the message format based on the log level."""
if isinstance(self.fmt, dict):
self._fmt = self.fmt[record.levelname]
if sys.version_info > (3, 2):
# Update self._style because we've changed self._fmt
# (code based on stdlib's logging.Formatter.__init__())
if self.style not in logging._STYLES:
raise ValueError('Style must be one of: %s' % ','.join(
| python | {
"resource": ""
} |
q257186 | replace_print | validation | def replace_print(fileobj=sys.stderr):
"""Sys.out replacer, by default with stderr.
Use it like this:
with replace_print_with(fileobj):
print "hello" # writes to the file
print "done" # prints to stdout
Args:
fileobj: a file object to replace stdout.
Yields:
The printer.
"""
| python | {
"resource": ""
} |
q257187 | compact_interval_string | validation | def compact_interval_string(value_list):
"""Compact a list of integers into a comma-separated string of intervals.
Args:
value_list: A list of sortable integers such as a list of numbers
Returns:
A compact string representation, such as "1-5,8,12-15"
"""
if not value_list:
return ''
value_list.sort()
# Start by simply building up a list of separate contiguous intervals
interval_list = []
curr = []
for val in value_list:
if curr and (val > curr[-1] + 1):
interval_list.append((curr[0], curr[-1]))
curr = [val]
else:
curr.append(val)
if curr:
| python | {
"resource": ""
} |
q257188 | _get_storage_service | validation | def _get_storage_service(credentials):
"""Get a storage client using the provided credentials or defaults."""
if credentials is None:
credentials = | python | {
"resource": ""
} |
q257189 | _retry_storage_check | validation | def _retry_storage_check(exception):
"""Return True if we should retry, False otherwise."""
now = datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f') | python | {
"resource": ""
} |
q257190 | _load_file_from_gcs | validation | def _load_file_from_gcs(gcs_file_path, credentials=None):
"""Load context from a text file in gcs.
Args:
gcs_file_path: The target file path; should have the 'gs://' prefix.
credentials: Optional credential to be used to load the file from gcs.
Returns:
The content of the text file as a string.
"""
gcs_service = _get_storage_service(credentials)
| python | {
"resource": ""
} |
q257191 | load_file | validation | def load_file(file_path, credentials=None):
"""Load a file from either local or gcs.
Args:
file_path: The target file path, which should have the prefix 'gs://' if
to be loaded from gcs.
| python | {
"resource": ""
} |
q257192 | _file_exists_in_gcs | validation | def _file_exists_in_gcs(gcs_file_path, credentials=None):
"""Check whether the file exists, in GCS.
Args:
gcs_file_path: The target file path; should have the 'gs://' prefix.
credentials: Optional credential to be used to load the file from gcs.
| python | {
"resource": ""
} |
q257193 | file_exists | validation | def file_exists(file_path, credentials=None):
"""Check whether the file exists, on local disk or GCS.
Args:
file_path: The target file path; should have the 'gs://' prefix if in gcs.
credentials: Optional credential to be used to load the file from gcs.
Returns:
True if the file's there.
"""
| python | {
"resource": ""
} |
q257194 | _prefix_exists_in_gcs | validation | def _prefix_exists_in_gcs(gcs_prefix, credentials=None):
"""Check whether there is a GCS object whose name starts with the prefix.
Since GCS doesn't actually have folders, this is how we check instead.
Args:
gcs_prefix: The path; should start with 'gs://'.
credentials: Optional credential to be used to load the file from gcs.
Returns:
True if the prefix matches at least one object in GCS.
Raises:
errors.HttpError: if it can't talk to the server
| python | {
"resource": ""
} |
q257195 | simple_pattern_exists_in_gcs | validation | def simple_pattern_exists_in_gcs(file_pattern, credentials=None):
"""True iff an object exists matching the input GCS pattern.
The GCS pattern must be a full object reference or a "simple pattern" that
conforms to the dsub input and output parameter restrictions:
* No support for **, ? wildcards or [] character ranges
* Wildcards may only appear in the file name
Args:
file_pattern: eg. 'gs://foo/ba*'
credentials: Optional credential to be used to load the file from gcs.
Raises:
ValueError: if file_pattern breaks the rules.
Returns:
True iff a file exists that matches that pattern.
"""
if '*' not in file_pattern:
return _file_exists_in_gcs(file_pattern, credentials)
if not file_pattern.startswith('gs://'):
raise ValueError('file name must start with gs://')
gcs_service = _get_storage_service(credentials)
bucket_name, prefix = file_pattern[len('gs://'):].split('/', 1)
if '*' in bucket_name:
raise ValueError('Wildcards may not appear in the bucket name')
# There is a '*' | python | {
"resource": ""
} |
q257196 | outputs_are_present | validation | def outputs_are_present(outputs):
"""True if each output contains at least one file or no output specified."""
# outputs are OutputFileParam (see param_util.py)
# If outputs contain a pattern, then there is no way for `dsub` to verify
# that *all* output is present. The best that `dsub` can do is to verify
# that *some* output was created for each such parameter.
for o in outputs:
| python | {
"resource": ""
} |
q257197 | _Pipelines._build_pipeline_input_file_param | validation | def _build_pipeline_input_file_param(cls, var_name, docker_path):
"""Return a dict object representing a pipeline input argument."""
# If the filename contains a wildcard, then the target Docker path must
# be a directory in order to ensure consistency whether the source pattern
# contains 1 or multiple files.
#
# In that case, we set the docker_path to explicitly have a trailing slash
# (for the Pipelines API "gsutil cp" | python | {
"resource": ""
} |
q257198 | _Pipelines._build_pipeline_docker_command | validation | def _build_pipeline_docker_command(cls, script_name, inputs, outputs, envs):
"""Return a multi-line string of the full pipeline docker command."""
# We upload the user script as an environment argument
# and write it to SCRIPT_DIR (preserving its local file name).
#
# The docker_command:
# * writes the script body to a file
# * installs gcloud if there are recursive copies to do
# * sets environment variables for inputs with wildcards
# * sets environment variables for recursive input directories
# * recursively copies input directories
# * creates output directories
# * sets environment variables for recursive output directories
# * sets the DATA_ROOT environment variable to /mnt/data
# * sets the working directory to ${DATA_ROOT}
# * executes the user script
# * recursively copies output directories
recursive_input_dirs = [
var for var in inputs if var.recursive and var.value
]
recursive_output_dirs = [
var for var in outputs if var.recursive and var.value
]
install_cloud_sdk = ''
if recursive_input_dirs or recursive_output_dirs:
install_cloud_sdk = INSTALL_CLOUD_SDK
export_input_dirs = ''
copy_input_dirs = ''
if recursive_input_dirs:
export_input_dirs = providers_util.build_recursive_localize_env(
providers_util.DATA_MOUNT_POINT, inputs)
copy_input_dirs = providers_util.build_recursive_localize_command(
providers_util.DATA_MOUNT_POINT, inputs, job_model.P_GCS)
export_output_dirs = ''
copy_output_dirs = ''
if recursive_output_dirs:
export_output_dirs = providers_util.build_recursive_gcs_delocalize_env(
providers_util.DATA_MOUNT_POINT, outputs)
copy_output_dirs = providers_util.build_recursive_delocalize_command(
providers_util.DATA_MOUNT_POINT, outputs, job_model.P_GCS)
docker_paths = [
var.docker_path if var.recursive else os.path.dirname(var.docker_path)
for var in outputs
if var.value
] | python | {
"resource": ""
} |
q257199 | _Pipelines.build_pipeline | validation | def build_pipeline(cls, project, zones, min_cores, min_ram, disk_size,
boot_disk_size, preemptible, accelerator_type,
accelerator_count, image, script_name, envs, inputs,
outputs, pipeline_name):
"""Builds a pipeline configuration for execution.
Args:
project: string name of project.
zones: list of zone names for jobs to be run at.
min_cores: int number of CPU cores required per job.
min_ram: int GB of RAM required per job.
disk_size: int GB of disk to attach under /mnt/data.
boot_disk_size: int GB of disk for boot.
preemptible: use a preemptible VM for the job
accelerator_type: string GCE defined accelerator type.
accelerator_count: int number of accelerators of the specified type to
attach.
image: string Docker image name in which to run.
script_name: file name of the script to run.
envs: list of EnvParam objects specifying environment variables to set
within each job.
inputs: list of FileParam objects specifying input variables to set
within each job.
outputs: list of FileParam objects specifying output variables to set
within each job.
pipeline_name: string name of pipeline.
Returns:
A nested dictionary with one entry under the key ephemeralPipeline
containing the pipeline configuration.
"""
if min_cores is None:
min_cores = job_model.DEFAULT_MIN_CORES
if min_ram is None:
min_ram = job_model.DEFAULT_MIN_RAM
if disk_size is None:
disk_size = job_model.DEFAULT_DISK_SIZE
if boot_disk_size is None:
boot_disk_size = job_model.DEFAULT_BOOT_DISK_SIZE
if preemptible is None:
preemptible = job_model.DEFAULT_PREEMPTIBLE
# Format the docker command
docker_command = cls._build_pipeline_docker_command(script_name, inputs,
outputs, envs)
# Pipelines inputParameters can be both simple name/value pairs which get
# set as environment variables, as well as input file paths which the
# Pipelines controller will automatically localize to the Pipeline VM.
# In the ephemeralPipeline object, the inputParameters are only defined;
# the values are passed in the pipelineArgs.
# Pipelines outputParameters are only output file paths, which the
# Pipelines controller can automatically de-localize after the docker
# command completes.
# The Pipelines API does not support recursive copy of file parameters,
# so it is implemented within the dsub-generated pipeline.
# Any inputs or outputs marked as "recursive" are completely omitted here;
# their environment variables will be set in the docker command, and
# recursive copy code will be generated there as well.
# The Pipelines API does not accept empty environment variables. Set them to
# empty in DOCKER_COMMAND instead.
input_envs = [{
'name': SCRIPT_VARNAME
| python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.