[ { "code": "def _buildItem(self, elem, cls=None, initpath=None):\n initpath = initpath or self._initpath\n if cls is not None:\n return cls(self._server, elem, initpath)\n etype = elem.attrib.get('type', elem.attrib.get('streamType'))\n ehash = '%s.%s' % (elem.tag, etype) if etype else elem.tag\n ecls = utils.PLEXOBJECTS.get(ehash, utils.PLEXOBJECTS.get(elem.tag))\n if ecls is not None:\n return ecls(self._server, elem, initpath)\n raise UnknownType(\"Unknown library type <%s type='%s'../>\" % (elem.tag, etype))", "docstring": "Factory function to build objects based on registered PLEXOBJECTS." }, { "code": "def connectMSExchange(server):\n if not sspi:\n return False, 'No sspi module found.'\n code, response = server.ehlo()\n if code != SMTP_EHLO_OKAY:\n return False, 'Server did not respond to EHLO command.'\n sspi_client = sspi.ClientAuth('NTLM')\n sec_buffer = None\n err, sec_buffer = sspi_client.authorize(sec_buffer)\n buffer = sec_buffer[0].Buffer\n ntlm_message = base64.encodestring(buffer).replace('\\n', '')\n code, response = server.docmd('AUTH', 'NTLM ' + ntlm_message)\n if code != SMTP_AUTH_CHALLENGE:\n msg = 'Server did not respond as expected to NTLM negotiate message'\n return False, msg\n err, sec_buffer = sspi_client.authorize(base64.decodestring(response))\n buffer = sec_buffer[0].Buffer\n ntlm_message = base64.encodestring(buffer).replace('\\n', '')\n code, response = server.docmd('', ntlm_message)\n if code != SMTP_AUTH_OKAY:\n return False, response\n return True, ''", "docstring": "Creates a connection for the inputted server to a Microsoft Exchange server.\n\n :param server | \n \n :usage |>>> import smtplib\n |>>> import projex.notify\n |>>> smtp = smtplib.SMTP('mail.server.com')\n |>>> projex.notify.connectMSExchange(smtp)\n \n :return ( success, reason)" }, { "code": "def load_from_cache(path=user_path):\n if not path:\n return\n try:\n with open(path, 'rb') as f:\n dversion, mversion, data = pickle.load(f)\n if dversion == data_version and mversion == module_version:\n return data\n except (FileNotFoundError, ValueError, EOFError):\n pass", "docstring": "Try to load category ranges from userlevel cache file.\n\n :param path: path to userlevel cache file\n :type path: str\n :returns: category ranges dict or None\n :rtype: None or dict of RangeGroup" }, { "code": "def convex_conj(self):\n conj_exp = conj_exponent(self.pointwise_norm.exponent)\n return IndicatorGroupL1UnitBall(self.domain, exponent=conj_exp)", "docstring": "The convex conjugate functional of the group L1-norm." }, { "code": "def extract(self, item):\n article_candidates = []\n for extractor in self.extractor_list:\n article_candidates.append(extractor.extract(item))\n article_candidates = self.cleaner.clean(article_candidates)\n article = self.comparer.compare(item, article_candidates)\n item['article_title'] = article.title\n item['article_description'] = article.description\n item['article_text'] = article.text\n item['article_image'] = article.topimage\n item['article_author'] = article.author\n item['article_publish_date'] = article.publish_date\n item['article_language'] = article.language\n return item", "docstring": "Runs the HTML-response trough a list of initialized extractors, a cleaner and compares the results.\n\n :param item: NewscrawlerItem to be processed.\n :return: An updated NewscrawlerItem including the results of the extraction" }, { "code": "def _get_ca_certs_paths():\n ca_certs = []\n embedded_root = os.path.dirname(os.path.abspath(__file__))\n for _ in range(10):\n if os.path.basename(embedded_root) == 'embedded':\n ca_certs.append(os.path.join(embedded_root, 'ssl', 'certs', 'cacert.pem'))\n break\n embedded_root = os.path.dirname(embedded_root)\n else:\n raise OSError(\n 'Unable to locate `embedded` directory. Please specify ca_certs in your http yaml configuration file.'\n )\n try:\n import tornado\n except ImportError:\n pass\n else:\n ca_certs.append(os.path.join(os.path.dirname(tornado.__file__), 'ca-certificates.crt'))\n ca_certs.append('/etc/ssl/certs/ca-certificates.crt')\n return ca_certs", "docstring": "Get a list of possible paths containing certificates\n\n Check is installed via pip to:\n * Windows: embedded/lib/site-packages/datadog_checks/http_check\n * Linux: embedded/lib/python2.7/site-packages/datadog_checks/http_check\n\n Certificate is installed to:\n * embedded/ssl/certs/cacert.pem\n\n walk up to `embedded`, and back down to ssl/certs to find the certificate file" }, { "code": "def trigger_all_callbacks(self, callbacks=None):\n return [ret\n for key in self\n for ret in self.trigger_callbacks(key, callbacks=None)]", "docstring": "Trigger callbacks for all keys on all or a subset of subscribers.\n\n :param Iterable callbacks: list of callbacks or none for all subscribed\n :rtype: Iterable[tornado.concurrent.Future]" }, { "code": "def _parse_log_entry(entry_pb):\n try:\n return MessageToDict(entry_pb)\n except TypeError:\n if entry_pb.HasField(\"proto_payload\"):\n proto_payload = entry_pb.proto_payload\n entry_pb.ClearField(\"proto_payload\")\n entry_mapping = MessageToDict(entry_pb)\n entry_mapping[\"protoPayload\"] = proto_payload\n return entry_mapping\n else:\n raise", "docstring": "Special helper to parse ``LogEntry`` protobuf into a dictionary.\n\n The ``proto_payload`` field in ``LogEntry`` is of type ``Any``. This\n can be problematic if the type URL in the payload isn't in the\n ``google.protobuf`` registry. To help with parsing unregistered types,\n this function will remove ``proto_payload`` before parsing.\n\n :type entry_pb: :class:`.log_entry_pb2.LogEntry`\n :param entry_pb: Log entry protobuf.\n\n :rtype: dict\n :returns: The parsed log entry. The ``protoPayload`` key may contain\n the raw ``Any`` protobuf from ``entry_pb.proto_payload`` if\n it could not be parsed." }, { "code": "def ssl_context(self, verify=True, cert_reqs=None,\n check_hostname=False, certfile=None, keyfile=None,\n cafile=None, capath=None, cadata=None, **kw):\n assert ssl, 'SSL not supported'\n cafile = cafile or DEFAULT_CA_BUNDLE_PATH\n if verify is True:\n cert_reqs = ssl.CERT_REQUIRED\n check_hostname = True\n if isinstance(verify, str):\n cert_reqs = ssl.CERT_REQUIRED\n if os.path.isfile(verify):\n cafile = verify\n elif os.path.isdir(verify):\n capath = verify\n return ssl._create_unverified_context(cert_reqs=cert_reqs,\n check_hostname=check_hostname,\n certfile=certfile,\n keyfile=keyfile,\n cafile=cafile,\n capath=capath,\n cadata=cadata)", "docstring": "Create a SSL context object.\n\n This method should not be called by from user code" }, { "code": "def empty_wav(wav_path: Union[Path, str]) -> bool:\n with wave.open(str(wav_path), 'rb') as wav_f:\n return wav_f.getnframes() == 0", "docstring": "Check if a wav contains data" }, { "code": "def set_general_setting(key, value, qsettings=None):\n if not qsettings:\n qsettings = QSettings()\n qsettings.setValue(key, deep_convert_dict(value))", "docstring": "Set value to QSettings based on key.\n\n :param key: Unique key for setting.\n :type key: basestring\n\n :param value: Value to be saved.\n :type value: QVariant\n\n :param qsettings: A custom QSettings to use. If it's not defined, it will\n use the default one.\n :type qsettings: qgis.PyQt.QtCore.QSettings" }, { "code": "def range_to_numeric(ranges):\n values, units = zip(*(r.split() for r in ranges))\n unit = os.path.commonprefix([u[::-1] for u in units])\n prefixes = (u[:-len(unit)] for u in units)\n values = [float(v) * SI_PREFIX[p] for v, p in zip(values, prefixes)]\n return values", "docstring": "Converts a sequence of string ranges to a sequence of floats.\n\n E.g.::\n\n >>> range_to_numeric(['1 uV', '2 mV', '1 V'])\n [1E-6, 0.002, 1.0]" }, { "code": "def photparse(tab):\n if 'source_id' not in tab[0].keys():\n raise KeyError('phot=TRUE requires the source_id columb be included')\n uniqueid = []\n for i in range(len(tab)):\n tmpid = tab[i]['source_id']\n if tmpid not in uniqueid:\n uniqueid.append(tmpid)\n newtab = []\n for sourceid in uniqueid:\n tmpdict = photaddline(tab, sourceid)\n newtab.append(tmpdict)\n return newtab", "docstring": "Parse through a photometry table to group by source_id\n\n Parameters\n ----------\n tab: list\n SQL query dictionary list from running query_dict.execute()\n\n Returns\n -------\n newtab: list\n Dictionary list after parsing to group together sources" }, { "code": "def get_unique_scan_parameter_combinations(meta_data_array, scan_parameters=None, scan_parameter_columns_only=False):\n try:\n last_not_parameter_column = meta_data_array.dtype.names.index('error_code')\n except ValueError:\n last_not_parameter_column = meta_data_array.dtype.names.index('error')\n if last_not_parameter_column == len(meta_data_array.dtype.names) - 1:\n return\n if scan_parameters is None:\n return unique_row(meta_data_array, use_columns=range(4, len(meta_data_array.dtype.names)), selected_columns_only=scan_parameter_columns_only)\n else:\n use_columns = []\n for scan_parameter in scan_parameters:\n try:\n use_columns.append(meta_data_array.dtype.names.index(scan_parameter))\n except ValueError:\n logging.error('No scan parameter ' + scan_parameter + ' found')\n raise RuntimeError('Scan parameter not found')\n return unique_row(meta_data_array, use_columns=use_columns, selected_columns_only=scan_parameter_columns_only)", "docstring": "Takes the numpy meta data array and returns the first rows with unique combinations of different scan parameter values for selected scan parameters.\n If selected columns only is true, the returned histogram only contains the selected columns.\n\n Parameters\n ----------\n meta_data_array : numpy.ndarray\n scan_parameters : list of string, None\n Scan parameter names taken. If None all are used.\n selected_columns_only : bool\n\n Returns\n -------\n numpy.Histogram" }, { "code": "def command(command):\n with cd(env.remote_path):\n sudo(env.python + ' manage.py %s' % command, user=env.remote_user)", "docstring": "Run custom Django management command" }, { "code": "def are_budget_data_package_fields_filled_in(self, resource):\n fields = ['country', 'currency', 'year', 'status']\n return all([self.in_resource(f, resource) for f in fields])", "docstring": "Check if the budget data package fields are all filled in because\n if not then this can't be a budget data package" }, { "code": "def load_data(self, filename, ext):\n from spyder_kernels.utils.iofuncs import iofunctions\n from spyder_kernels.utils.misc import fix_reference_name\n glbs = self._mglobals()\n load_func = iofunctions.load_funcs[ext]\n data, error_message = load_func(filename)\n if error_message:\n return error_message\n for key in list(data.keys()):\n new_key = fix_reference_name(key, blacklist=list(glbs.keys()))\n if new_key != key:\n data[new_key] = data.pop(key)\n try:\n glbs.update(data)\n except Exception as error:\n return str(error)\n return None", "docstring": "Load data from filename" }, { "code": "def src_paths(self):\n return {src for src, summary in self._diff_violations().items()\n if len(summary.measured_lines) > 0}", "docstring": "Return a list of source files in the diff\n for which we have coverage information." }, { "code": "def explain(self, expr, params=None):\n if isinstance(expr, ir.Expr):\n context = self.dialect.make_context(params=params)\n query_ast = self._build_ast(expr, context)\n if len(query_ast.queries) > 1:\n raise Exception('Multi-query expression')\n query = query_ast.queries[0].compile()\n else:\n query = expr\n statement = 'EXPLAIN {0}'.format(query)\n with self._execute(statement, results=True) as cur:\n result = self._get_list(cur)\n return 'Query:\\n{0}\\n\\n{1}'.format(\n util.indent(query, 2), '\\n'.join(result)\n )", "docstring": "Query for and return the query plan associated with the indicated\n expression or SQL query.\n\n Returns\n -------\n plan : string" }, { "code": "def DEFINE_boolean(\n name, default, help, flag_values=_flagvalues.FLAGS, module_name=None,\n **args):\n DEFINE_flag(_flag.BooleanFlag(name, default, help, **args),\n flag_values, module_name)", "docstring": "Registers a boolean flag.\n\n Such a boolean flag does not take an argument. If a user wants to\n specify a false value explicitly, the long option beginning with 'no'\n must be used: i.e. --noflag\n\n This flag will have a value of None, True or False. None is possible\n if default=None and the user does not specify the flag on the command\n line.\n\n Args:\n name: str, the flag name.\n default: bool|str|None, the default value of the flag.\n help: str, the help message.\n flag_values: FlagValues, the FlagValues instance with which the flag will\n be registered. This should almost never need to be overridden.\n module_name: str, the name of the Python module declaring this flag.\n If not provided, it will be computed using the stack trace of this call.\n **args: dict, the extra keyword args that are passed to Flag __init__." }, { "code": "def upload_file(self, abspath, cloud_filename):\n if not self.test_run:\n content = open(abspath, \"rb\")\n content_type = get_content_type(cloud_filename, content)\n headers = get_headers(cloud_filename, content_type)\n if headers.get(\"Content-Encoding\") == \"gzip\":\n content = get_gzipped_contents(content)\n size = content.size\n else:\n size = os.stat(abspath).st_size\n self.container.create(\n obj_name=cloud_filename,\n data=content,\n content_type=content_type,\n content_length=size,\n content_encoding=headers.get(\"Content-Encoding\", None),\n headers=headers,\n ttl=CUMULUS[\"FILE_TTL\"],\n etag=None,\n )\n self.upload_count += 1\n if not self.quiet or self.verbosity > 1:\n print(\"Uploaded: {0}\".format(cloud_filename))", "docstring": "Uploads a file to the container." }, { "code": "def GetIndex(self):\n if self.index is None:\n return None\n if self.index:\n res, ui = chmlib.chm_resolve_object(self.file, self.index)\n if (res != chmlib.CHM_RESOLVE_SUCCESS):\n return None\n size, text = chmlib.chm_retrieve_object(self.file, ui, 0l, ui.length)\n if (size == 0):\n sys.stderr.write('GetIndex: file size = 0\\n')\n return None\n return text", "docstring": "Reads and returns the index tree.\n This auxiliary function reads and returns the index tree file\n contents for the CHM archive." }, { "code": "def info(ctx):\n controller = ctx.obj['controller']\n version = controller.version\n click.echo(\n 'OATH version: {}.{}.{}'.format(version[0], version[1], version[2]))\n click.echo('Password protection ' +\n ('enabled' if controller.locked else 'disabled'))\n keys = ctx.obj['settings'].get('keys', {})\n if controller.locked and controller.id in keys:\n click.echo('The password for this YubiKey is remembered by ykman.')\n if ctx.obj['dev'].is_fips:\n click.echo('FIPS Approved Mode: {}'.format(\n 'Yes' if controller.is_in_fips_mode else 'No'))", "docstring": "Display status of OATH application." }, { "code": "def export_for_training(self, file_path='./export.json'):\n import json\n export = {'conversations': self._generate_export_data()}\n with open(file_path, 'w+') as jsonfile:\n json.dump(export, jsonfile, ensure_ascii=False)", "docstring": "Create a file from the database that can be used to\n train other chat bots." }, { "code": "def subtract(self,range2):\n outranges = []\n if self.chr != range2.chr:\n outranges.append(self.copy())\n return outranges\n if not self.overlaps(range2):\n outranges.append(self.copy())\n return outranges\n if range2.start <= self.start and range2.end >= self.end:\n return outranges\n if range2.start > self.start:\n nrng = type(self)(self.chr,self.start+self._start_offset,range2.start-1,self.payload,self.dir)\n outranges.append(nrng)\n if range2.end < self.end:\n nrng = type(self)(self.chr,range2.end+1+self._start_offset,self.end,self.payload,self.dir)\n outranges.append(nrng)\n return outranges", "docstring": "Take another range, and list of ranges after removing range2, keep options from self\n\n :param range2:\n :type range2: GenomicRange\n :return: List of Genomic Ranges\n :rtype: GenomicRange[]" }, { "code": "async def close(self, *, force_after=30):\n if self.transport:\n self.transport.close()\n try:\n async with timeout_after(force_after):\n await self.closed_event.wait()\n except TaskTimeout:\n self.abort()\n await self.closed_event.wait()", "docstring": "Close the connection and return when closed." }, { "code": "def validate_contents(file_contents):\n for name, contents in file_contents.items():\n if os.path.splitext(name)[1] != '.ipynb':\n continue\n if not contents:\n return False\n try:\n json_object = json.loads(contents)\n except ValueError:\n return False\n return True", "docstring": "Ensures that all ipynb files in FILE_CONTENTS\n are valid JSON files." }, { "code": "def stop_actions(self):\n self._stop_actions, value = self.get_attr_set(self._stop_actions, 'stop_actions')\n return value", "docstring": "Gets a list of stop actions. Valid values are `coast`\n and `brake`." }, { "code": "def _gap(src_interval, tar_interval):\n assert src_interval.bits == tar_interval.bits, \"Number of bits should be same for operands\"\n s = src_interval\n t = tar_interval\n (_, b) = (s.lower_bound, s.upper_bound)\n (c, _) = (t.lower_bound, t.upper_bound)\n w = s.bits\n if (not t._surrounds_member(b)) and (not s._surrounds_member(c)):\n return StridedInterval(lower_bound=c, upper_bound=b, bits=w, stride=1).complement\n return StridedInterval.empty(w)", "docstring": "Refer section 3.1; gap function.\n\n :param src_interval: first argument or interval 1\n :param tar_interval: second argument or interval 2\n :return: Interval representing gap between two intervals" }, { "code": "def calc_across_paths_textnodes(paths_nodes, dbg=False):\r\n for path_nodes in paths_nodes:\r\n cnt = len(path_nodes[1][0])\r\n ttl = sum([len(s) for s in paths_nodes[1][0]])\n path_nodes[1][1] = cnt\n path_nodes[1][2] = ttl\n path_nodes[1][3] = ttl/ cnt\n if dbg:\r\n print(path_nodes[1])", "docstring": "Given a list of parent paths tupled with children textnodes, plus\r\n initialized feature values, we calculate the total and average string\r\n length of the parent's children textnodes." }, { "code": "def group(text, size):\n if size <= 0:\n raise ValueError(\"n must be a positive integer\")\n return [text[i:i + size] for i in range(0, len(text), size)]", "docstring": "Group ``text`` into blocks of ``size``.\n\n Example:\n >>> group(\"test\", 2)\n ['te', 'st']\n\n Args:\n text (str): text to separate\n size (int): size of groups to split the text into\n\n Returns:\n List of n-sized groups of text\n\n Raises:\n ValueError: If n is non positive" }, { "code": "def destroy(self):\n if self._running is False:\n return\n self._running = False\n if hasattr(self, 'schedule'):\n del self.schedule\n if hasattr(self, 'pub_channel') and self.pub_channel is not None:\n self.pub_channel.on_recv(None)\n if hasattr(self.pub_channel, 'close'):\n self.pub_channel.close()\n del self.pub_channel\n if hasattr(self, 'periodic_callbacks'):\n for cb in six.itervalues(self.periodic_callbacks):\n cb.stop()", "docstring": "Tear down the minion" }, { "code": "def pint_multiply(da, q, out_units=None):\n a = 1 * units2pint(da)\n f = a * q.to_base_units()\n if out_units:\n f = f.to(out_units)\n out = da * f.magnitude\n out.attrs['units'] = pint2cfunits(f.units)\n return out", "docstring": "Multiply xarray.DataArray by pint.Quantity.\n\n Parameters\n ----------\n da : xr.DataArray\n Input array.\n q : pint.Quantity\n Multiplicating factor.\n out_units : str\n Units the output array should be converted into." }, { "code": "def _to_dict(self):\n physical_prop_names = find_PhysicalProperty(self)\n physical_prop_vals = [getattr(self, prop) for prop in physical_prop_names]\n return dict(zip(physical_prop_names, physical_prop_vals))", "docstring": "Return a dictionary representation of the current object." }, { "code": "def category(**kwargs):\n if 'series' in kwargs:\n kwargs.pop('series')\n path = 'series'\n else:\n path = None\n return Fred().category(path, **kwargs)", "docstring": "Get a category." }, { "code": "def add_dicts(*args):\n counters = [Counter(arg) for arg in args]\n return dict(reduce(operator.add, counters))", "docstring": "Adds two or more dicts together. Common keys will have their values added.\n\n For example::\n\n >>> t1 = {'a':1, 'b':2}\n >>> t2 = {'b':1, 'c':3}\n >>> t3 = {'d':4}\n\n >>> add_dicts(t1, t2, t3)\n {'a': 1, 'c': 3, 'b': 3, 'd': 4}" }, { "code": "def rename_dimension(self, old_name, new_name):\n if old_name not in self.dimension_names:\n raise ValueError(\"Shape %s does not have dimension named %s\"\n % (self, old_name))\n return Shape(\n [Dimension(new_name, d.size) if d.name == old_name else d\n for d in self.dims])", "docstring": "Returns a copy where one dimension is renamed." }, { "code": "def _get_dst_resolution(self, dst_res=None):\n if dst_res is None:\n dst_res = min(self._res_indices.keys())\n return dst_res", "docstring": "Get default resolution, i.e. the highest resolution or smallest cell size." }, { "code": "def get_instance(self, payload):\n return EventInstance(self._version, payload, workspace_sid=self._solution['workspace_sid'], )", "docstring": "Build an instance of EventInstance\n\n :param dict payload: Payload response from the API\n\n :returns: twilio.rest.taskrouter.v1.workspace.event.EventInstance\n :rtype: twilio.rest.taskrouter.v1.workspace.event.EventInstance" }, { "code": "def _find_unchanged(old, new):\n edges = []\n old_edges = [set(edge) for edge in old.edges()]\n new_edges = [set(edge) for edge in new.edges()]\n for old_edge in old_edges:\n if old_edge in new_edges:\n edges.append(set(old_edge))\n return edges", "docstring": "returns edges that are in both old and new" }, { "code": "def hazard_extra_keyword(keyword, feature, parent):\n _ = feature, parent\n hazard_layer_path = QgsExpressionContextUtils. \\\n projectScope(QgsProject.instance()).variable(\n 'hazard_layer')\n hazard_layer = load_layer(hazard_layer_path)[0]\n keywords = KeywordIO.read_keywords(hazard_layer)\n extra_keywords = keywords.get('extra_keywords')\n if extra_keywords:\n value = extra_keywords.get(keyword)\n if value:\n value_definition = definition(value)\n if value_definition:\n return value_definition['name']\n return value\n else:\n return tr('Keyword %s is not found' % keyword)\n return tr('No extra keywords found')", "docstring": "Given a keyword, it will return the value of the keyword\n from the hazard layer's extra keywords.\n\n For instance:\n * hazard_extra_keyword( 'depth' ) -> will return the value of 'depth'\n in current hazard layer's extra keywords." }, { "code": "def parse(text, showToc=True):\n\tp = Parser(show_toc=showToc)\n\treturn p.parse(text)", "docstring": "Returns HTML from MediaWiki markup" }, { "code": "def handle_request(self, environ, start_response):\n urls = self.url_map.bind_to_environ(environ)\n try:\n endpoint, args = urls.match()\n environ['pywb.app_prefix'] = environ.get('SCRIPT_NAME')\n response = endpoint(environ, **args)\n return response(environ, start_response)\n except HTTPException as e:\n redir = self._check_refer_redirect(environ)\n if redir:\n return redir(environ, start_response)\n return e(environ, start_response)\n except Exception as e:\n if self.debug:\n traceback.print_exc()\n response = self.rewriterapp._error_response(environ, 'Internal Error: ' + str(e), '500 Server Error')\n return response(environ, start_response)", "docstring": "Retrieves the route handler and calls the handler returning its the response\n\n :param dict environ: The WSGI environment dictionary for the request\n :param start_response:\n :return: The WbResponse for the request\n :rtype: WbResponse" }, { "code": "def getLiteral(self):\n chars = u''\n c = self.current()\n while True:\n if c and c == u\"\\\\\":\n c = self.next()\n if c:\n chars += c\n continue\n elif not c or (c in self.meta_chars):\n break\n else:\n chars += c\n if self.lookahead() and self.lookahead() in self.meta_chars:\n break\n c = self.next()\n return StringGenerator.Literal(chars)", "docstring": "Get a sequence of non-special characters." }, { "code": "def dump(self, name: str, inst):\n \"Save the object instance to the stash.\"\n self.stash.dump(name, inst)", "docstring": "Save the object instance to the stash." }, { "code": "def u8(self, name, value=None, align=None):\n self.uint(1, name, value, align)", "docstring": "Add an unsigned 1 byte integer field to template.\n\n This is an convenience method that simply calls `Uint` keyword with predefined length." }, { "code": "def filter_thumbnail_files(chan_path, filenames, metadata_provider):\n thumbnail_files_to_skip = metadata_provider.get_thumbnail_paths()\n filenames_cleaned = []\n for filename in filenames:\n keep = True\n chan_filepath = os.path.join(chan_path, filename)\n chan_filepath_tuple = path_to_tuple(chan_filepath)\n if chan_filepath_tuple in thumbnail_files_to_skip:\n keep = False\n if keep:\n filenames_cleaned.append(filename)\n return filenames_cleaned", "docstring": "We don't want to create `ContentNode` from thumbnail files." }, { "code": "def deprecated_attr(namespace, attr, replacement):\n _deprecated_attrs.setdefault(namespace, []).append((attr, replacement))", "docstring": "Marks a module level attribute as deprecated. Accessing it will emit\n a PyGIDeprecationWarning warning.\n\n e.g. for ``deprecated_attr(\"GObject\", \"STATUS_FOO\", \"GLib.Status.FOO\")``\n accessing GObject.STATUS_FOO will emit:\n\n \"GObject.STATUS_FOO is deprecated; use GLib.Status.FOO instead\"\n\n :param str namespace:\n The namespace of the override this is called in.\n :param str namespace:\n The attribute name (which gets added to __all__).\n :param str replacement:\n The replacement text which will be included in the warning." }, { "code": "def debug_sql(sql: str, *args: Any) -> None:\n log.debug(\"SQL: %s\" % sql)\n if args:\n log.debug(\"Args: %r\" % args)", "docstring": "Writes SQL and arguments to the log." }, { "code": "def imagenet50(display=False, resolution=224):\n prefix = github_data_url + \"imagenet50_\"\n X = np.load(cache(prefix + \"%sx%s.npy\" % (resolution, resolution))).astype(np.float32)\n y = np.loadtxt(cache(prefix + \"labels.csv\"))\n return X, y", "docstring": "This is a set of 50 images representative of ImageNet images.\n\n This dataset was collected by randomly finding a working ImageNet link and then pasting the\n original ImageNet image into Google image search restricted to images licensed for reuse. A\n similar image (now with rights to reuse) was downloaded as a rough replacment for the original\n ImageNet image. The point is to have a random sample of ImageNet for use as a background\n distribution for explaining models trained on ImageNet data.\n\n Note that because the images are only rough replacements the labels might no longer be correct." }, { "code": "def GetFormatterObject(cls, data_type):\n data_type = data_type.lower()\n if data_type not in cls._formatter_objects:\n formatter_object = None\n if data_type in cls._formatter_classes:\n formatter_class = cls._formatter_classes[data_type]\n formatter_object = formatter_class()\n if not formatter_object:\n logger.warning(\n 'Using default formatter for data type: {0:s}'.format(data_type))\n formatter_object = default.DefaultFormatter()\n cls._formatter_objects[data_type] = formatter_object\n return cls._formatter_objects[data_type]", "docstring": "Retrieves the formatter object for a specific data type.\n\n Args:\n data_type (str): data type.\n\n Returns:\n EventFormatter: corresponding formatter or the default formatter if\n not available." }, { "code": "def jenkins_rao(target, throat_perimeter='throat.perimeter',\n throat_area='throat.area',\n throat_diameter='throat.indiameter'):\n r\n P = target[throat_perimeter]\n A = target[throat_area]\n r = target[throat_diameter]/2\n value = (P/A)/(2/r)\n return value", "docstring": "r\"\"\"\n Jenkins and Rao relate the capillary pressure in an eliptical throat to\n the aspect ratio\n\n References\n ----------\n Jenkins, R.G. and Rao, M.B., The effect of elliptical pores on\n mercury porosimetry results. Powder technology, 38(2), pp.177-180. (1984)" }, { "code": "def _get_status_descr_by_id(status_id):\n for status_name, status_data in six.iteritems(LINODE_STATUS):\n if status_data['code'] == int(status_id):\n return status_data['descr']\n return LINODE_STATUS.get(status_id, None)", "docstring": "Return linode status by ID\n\n status_id\n linode VM status ID" }, { "code": "def info(self):\n info = []\n for prior_model_name, prior_model in self.prior_model_tuples:\n info.append(prior_model.name + '\\n')\n info.extend([f\"{prior_model_name}_{item}\" for item in prior_model.info])\n return '\\n'.join(info)", "docstring": "Use the priors that make up the model_mapper to generate information on each parameter of the overall model.\n\n This information is extracted from each priors *model_info* property." }, { "code": "def attribute_exists(self, name):\n if name in self:\n if issubclass(self[name].__class__, Attribute):\n return True\n return False", "docstring": "Returns if given attribute exists in the node.\n\n Usage::\n\n >>>\tnode_a = AbstractNode(\"MyNodeA\", attributeA=Attribute(), attributeB=Attribute())\n >>> node_a.attribute_exists(\"attributeA\")\n True\n >>> node_a.attribute_exists(\"attributeC\")\n False\n\n :param name: Attribute name.\n :type name: unicode\n :return: Attribute exists.\n :rtype: bool" }, { "code": "def _get_node(self, node_id):\n self.non_terminated_nodes({})\n if node_id in self.cached_nodes:\n return self.cached_nodes[node_id]\n matches = list(self.ec2.instances.filter(InstanceIds=[node_id]))\n assert len(matches) == 1, \"Invalid instance id {}\".format(node_id)\n return matches[0]", "docstring": "Refresh and get info for this node, updating the cache." }, { "code": "def find_specs(self, directory):\n specs = []\n spec_files = self.file_finder.find(directory)\n for spec_file in spec_files:\n specs.extend(self.spec_finder.find(spec_file.module))\n return specs", "docstring": "Finds all specs in a given directory. Returns a list of\n Example and ExampleGroup instances." }, { "code": "def interface_direct_class(data_class):\n if data_class in ASSET:\n interface = AssetsInterface()\n elif data_class in PARTY:\n interface = PartiesInterface()\n elif data_class in BOOK:\n interface = BooksInterface()\n elif data_class in CORPORATE_ACTION:\n interface = CorporateActionsInterface()\n elif data_class in MARKET_DATA:\n interface = MarketDataInterface()\n elif data_class in TRANSACTION:\n interface = TransactionsInterface()\n else:\n interface = AssetManagersInterface()\n return interface", "docstring": "help to direct to the correct interface interacting with DB by class name only" }, { "code": "def get_xyz_2d(self, xcoord, x, ycoord, y, u, v):\n xy = xcoord.values.ravel() + 1j * ycoord.values.ravel()\n dist = np.abs(xy - (x + 1j * y))\n imin = np.nanargmin(dist)\n xy_min = xy[imin]\n return (xy_min.real, xy_min.imag, u.values.ravel()[imin],\n v.values.ravel()[imin])", "docstring": "Get closest x, y and z for the given `x` and `y` in `data` for\n 2d coords" }, { "code": "def write_xml(self, xmlfile, config=None):\n root = ElementTree.Element('source_library')\n root.set('title', 'source_library')\n for s in self._srcs:\n s.write_xml(root)\n if config is not None:\n srcs = self.create_diffuse_srcs(config)\n diffuse_srcs = {s.name: s for s in srcs}\n for s in self._diffuse_srcs:\n src = copy.deepcopy(diffuse_srcs.get(s.name, s))\n src.update_spectral_pars(s.spectral_pars)\n src.write_xml(root)\n else:\n for s in self._diffuse_srcs:\n s.write_xml(root)\n output_file = open(xmlfile, 'w')\n output_file.write(utils.prettify_xml(root))", "docstring": "Save the ROI model as an XML file." }, { "code": "def change_to_workdir(self):\n logger.info(\"Changing working directory to: %s\", self.workdir)\n self.check_dir(self.workdir)\n try:\n os.chdir(self.workdir)\n except OSError as exp:\n self.exit_on_error(\"Error changing to working directory: %s. Error: %s. \"\n \"Check the existence of %s and the %s/%s account \"\n \"permissions on this directory.\"\n % (self.workdir, str(exp), self.workdir, self.user, self.group),\n exit_code=3)\n self.pre_log.append((\"INFO\", \"Using working directory: %s\" % os.path.abspath(self.workdir)))", "docstring": "Change working directory to working attribute\n\n :return: None" }, { "code": "def convert_html_to_xml(self):\n if hasattr(self, 'content') and self.content != '':\n regex = r'<(?!/)(?!!)'\n xml_content = re.sub(regex, '' + conf.TYPE_CHAR, value)\n except struct.error:\n raise IllegalDataValueError\n self._value = value", "docstring": "Value to be written on register.\n\n :param value: An integer.\n :raises: IllegalDataValueError when value isn't in range." }, { "code": "def visit_object(self, node):\n if current_app.debug:\n return tags.comment('no implementation in {} to render {}'.format(\n self.__class__.__name__,\n node.__class__.__name__, ))\n return ''", "docstring": "Fallback rendering for objects.\n\n If the current application is in debug-mode\n (``flask.current_app.debug`` is ``True``), an ```` will be rendered, indicating which class is missing a visitation\n function.\n\n Outside of debug-mode, returns an empty string." }, { "code": "def image_tasks(self):\n uri = \"/%s/tasks\" % self.uri_base\n resp, resp_body = self.api.method_get(uri)\n return resp_body", "docstring": "Returns a json-schema document that represents a container of tasks\n entities." }, { "code": "def read(config_values):\n if not config_values:\n raise RheaError('Cannot read config_value: `{}`'.format(config_values))\n config_values = to_list(config_values)\n config = {}\n for config_value in config_values:\n config_value = ConfigSpec.get_from(value=config_value)\n config_value.check_type()\n config_results = config_value.read()\n if config_results and isinstance(config_results, Mapping):\n config = deep_update(config, config_results)\n elif config_value.check_if_exists:\n raise RheaError('Cannot read config_value: `{}`'.format(config_value))\n return config", "docstring": "Reads an ordered list of configuration values and deep merge the values in reverse order." }, { "code": "def proportional_weights(self, fraction_stdev=1.0, wmax=100.0,\n leave_zero=True):\n new_weights = []\n for oval, ow in zip(self.observation_data.obsval,\n self.observation_data.weight):\n if leave_zero and ow == 0.0:\n ow = 0.0\n elif oval == 0.0:\n ow = wmax\n else:\n nw = 1.0 / (np.abs(oval) * fraction_stdev)\n ow = min(wmax, nw)\n new_weights.append(ow)\n self.observation_data.weight = new_weights", "docstring": "setup weights inversely proportional to the observation value\n\n Parameters\n ----------\n fraction_stdev : float\n the fraction portion of the observation\n val to treat as the standard deviation. set to 1.0 for\n inversely proportional\n wmax : float\n maximum weight to allow\n leave_zero : bool\n flag to leave existing zero weights" }, { "code": "def add_resources_to_registry():\n from deform.widget import default_resource_registry\n default_resource_registry.set_js_resources(\"jqueryui\", None, None)\n default_resource_registry.set_js_resources(\"datetimepicker\", None, None)\n default_resource_registry.set_js_resources(\"custom_dates\", None, None)\n default_resource_registry.set_js_resources(\n \"radio_choice_toggle\", None, None\n )\n default_resource_registry.set_js_resources(\"checkbox_toggle\", None, None)\n from js.deform import resource_mapping\n from js.select2 import select2\n resource_mapping['select2'] = select2\n from js.jquery_timepicker_addon import timepicker\n resource_mapping['datetimepicker'] = timepicker\n resource_mapping['custom_dates'] = custom_dates\n resource_mapping['radio_choice_toggle'] = radio_choice_toggle\n resource_mapping['checkbox_toggle'] = checkbox_toggle", "docstring": "Add resources to the deform registry" }, { "code": "def _get_user(self, user: Union[User, str]) -> User:\n user_id: str = getattr(user, 'user_id', user)\n discovery_room = self._global_rooms.get(\n make_room_alias(self.network_id, DISCOVERY_DEFAULT_ROOM),\n )\n if discovery_room and user_id in discovery_room._members:\n duser = discovery_room._members[user_id]\n if getattr(user, 'displayname', None):\n assert isinstance(user, User)\n duser.displayname = user.displayname\n user = duser\n elif not isinstance(user, User):\n user = self._client.get_user(user_id)\n return user", "docstring": "Creates an User from an user_id, if none, or fetch a cached User\n\n As all users are supposed to be in discovery room, its members dict is used for caching" }, { "code": "def file_md5(f, size=8192):\n \"Calculates the MD5 of a file.\"\n md5 = hashlib.md5()\n while True:\n data = f.read(size)\n if not data:\n break\n md5.update(data)\n return md5.hexdigest()", "docstring": "Calculates the MD5 of a file." }, { "code": "def add_output_variable(self, var):\n assert(isinstance(var, Variable))\n self.output_variable_list.append(var)", "docstring": "Adds the argument variable as one of the output variable" }, { "code": "def decode(dct, intype='json', raise_error=False):\n for decoder in get_plugins('decoders').values():\n if (set(list(decoder.dict_signature)).issubset(dct.keys())\n and hasattr(decoder, 'from_{}'.format(intype))\n and getattr(decoder, 'allow_other_keys', False)):\n return getattr(decoder, 'from_{}'.format(intype))(dct)\n break\n elif (sorted(list(decoder.dict_signature)) == sorted(dct.keys())\n and hasattr(decoder, 'from_{}'.format(intype))):\n return getattr(decoder, 'from_{}'.format(intype))(dct)\n break\n if raise_error:\n raise ValueError('no suitable plugin found for: {}'.format(dct))\n else:\n return dct", "docstring": "decode dict objects, via decoder plugins, to new type\n\n Parameters\n ----------\n intype: str\n use decoder method from_ to encode\n raise_error : bool\n if True, raise ValueError if no suitable plugin found\n\n Examples\n --------\n >>> load_builtin_plugins('decoders')\n []\n\n >>> from decimal import Decimal\n >>> decode({'_python_Decimal_':'1.3425345'})\n Decimal('1.3425345')\n\n >>> unload_all_plugins()" }, { "code": "def find_sink_variables(self):\n is_sink = {name: True for name in self.variables.keys()}\n for operator in self.operators.values():\n for variable in operator.inputs:\n is_sink[variable.onnx_name] = False\n return [variable for name, variable in self.variables.items() if is_sink[name]]", "docstring": "Find sink variables in this scope" }, { "code": "def uploads(self):\n if self.syncEnabled == True:\n return Uploads(url=self._url + \"/uploads\",\n securityHandler=self._securityHandler,\n proxy_url=self._proxy_url,\n proxy_port=self._proxy_port)\n return None", "docstring": "returns the class to perform the upload function. it will\n only return the uploads class if syncEnabled is True." }, { "code": "def _decoder(image, shrink):\n decoder = dmtxDecodeCreate(image, shrink)\n if not decoder:\n raise PyLibDMTXError('Could not create decoder')\n else:\n try:\n yield decoder\n finally:\n dmtxDecodeDestroy(byref(decoder))", "docstring": "A context manager for `DmtxDecode`, created and destroyed by\n `dmtxDecodeCreate` and `dmtxDecodeDestroy`.\n\n Args:\n image (POINTER(DmtxImage)):\n shrink (int):\n\n Yields:\n POINTER(DmtxDecode): The created decoder\n\n Raises:\n PyLibDMTXError: If the decoder could not be created." }, { "code": "def _ParseSignatureIdentifiers(self, data_location, signature_identifiers):\n if not signature_identifiers:\n return\n if not data_location:\n raise ValueError('Missing data location.')\n path = os.path.join(data_location, 'signatures.conf')\n if not os.path.exists(path):\n raise IOError(\n 'No such format specification file: {0:s}'.format(path))\n try:\n specification_store = self._ReadSpecificationFile(path)\n except IOError as exception:\n raise IOError((\n 'Unable to read format specification file: {0:s} with error: '\n '{1!s}').format(path, exception))\n signature_identifiers = signature_identifiers.lower()\n signature_identifiers = [\n identifier.strip() for identifier in signature_identifiers.split(',')]\n file_entry_filter = file_entry_filters.SignaturesFileEntryFilter(\n specification_store, signature_identifiers)\n self._filter_collection.AddFilter(file_entry_filter)", "docstring": "Parses the signature identifiers.\n\n Args:\n data_location (str): location of the format specification file, for\n example, \"signatures.conf\".\n signature_identifiers (str): comma separated signature identifiers.\n\n Raises:\n IOError: if the format specification file could not be read from\n the specified data location.\n OSError: if the format specification file could not be read from\n the specified data location.\n ValueError: if no data location was specified." }, { "code": "def dumps(self, bucket=None):\n return [\n self.file_cls(o, self.filesmap.get(o.key, {})).dumps()\n for o in sorted_files_from_bucket(bucket or self.bucket, self.keys)\n ]", "docstring": "Serialize files from a bucket.\n\n :param bucket: Instance of files\n :class:`invenio_files_rest.models.Bucket`. (Default:\n ``self.bucket``)\n :returns: List of serialized files." }, { "code": "def centroid(X):\n C = np.sum(X, axis=0) / len(X)\n return C", "docstring": "Calculate the centroid from a matrix X" }, { "code": "def _compile_rules(self):\n for state, table in self.RULES.items():\n patterns = list()\n actions = list()\n nextstates = list()\n for i, row in enumerate(table):\n if len(row) == 2:\n pattern, _action = row\n nextstate = None\n elif len(row) == 3:\n pattern, _action, nextstate = row\n else:\n fstr = \"invalid RULES: state {}, row {}\"\n raise CompileError(fstr.format(state, i))\n patterns.append(pattern)\n actions.append(_action)\n nextstates.append(nextstate)\n reobj = re.compile('|'.join(\"(\" + p + \")\" for p in patterns))\n self._rules[state] = (reobj, actions, nextstates)", "docstring": "Compile the rules into the internal lexer state." }, { "code": "def _store_credentials(self, username, password, remember=False):\n if username and password and remember:\n CONF.set('main', 'report_error/username', username)\n try:\n keyring.set_password('github', username, password)\n except Exception:\n if self._show_msgbox:\n QMessageBox.warning(self.parent_widget,\n _('Failed to store password'),\n _('It was not possible to securely '\n 'save your password. You will be '\n 'prompted for your Github '\n 'credentials next time you want '\n 'to report an issue.'))\n remember = False\n CONF.set('main', 'report_error/remember_me', remember)", "docstring": "Store credentials for future use." }, { "code": "def update(self, new_email_address, name, custom_fields, resubscribe, consent_to_track, restart_subscription_based_autoresponders=False):\n validate_consent_to_track(consent_to_track)\n params = {\"email\": self.email_address}\n body = {\n \"EmailAddress\": new_email_address,\n \"Name\": name,\n \"CustomFields\": custom_fields,\n \"Resubscribe\": resubscribe,\n \"ConsentToTrack\": consent_to_track,\n \"RestartSubscriptionBasedAutoresponders\": restart_subscription_based_autoresponders}\n response = self._put(\"/subscribers/%s.json\" % self.list_id,\n body=json.dumps(body), params=params)\n self.email_address = new_email_address", "docstring": "Updates any aspect of a subscriber, including email address, name, and\n custom field data if supplied." }, { "code": "def get_groups(self):\n def process_result(result):\n return [self.get_group(group) for group in result]\n return Command('get', [ROOT_GROUPS], process_result=process_result)", "docstring": "Return the groups linked to the gateway.\n\n Returns a Command." }, { "code": "def update_type_lookups(self):\n self.type_to_typestring = dict(zip(self.types,\n self.python_type_strings))\n self.typestring_to_type = dict(zip(self.python_type_strings,\n self.types))", "docstring": "Update type and typestring lookup dicts.\n\n Must be called once the ``types`` and ``python_type_strings``\n attributes are set so that ``type_to_typestring`` and\n ``typestring_to_type`` are constructed.\n\n .. versionadded:: 0.2\n\n Notes\n -----\n Subclasses need to call this function explicitly." }, { "code": "def _read_opt_ilnp(self, code, *, desc):\n _type = self._read_opt_type(code)\n _size = self._read_unpack(1)\n _nval = self._read_fileng(_size)\n opt = dict(\n desc=desc,\n type=_type,\n length=_size + 2,\n value=_nval,\n )\n return opt", "docstring": "Read HOPOPT ILNP Nonce option.\n\n Structure of HOPOPT ILNP Nonce option [RFC 6744]:\n 0 1 2 3\n 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1\n +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n | Next Header | Hdr Ext Len | Option Type | Option Length |\n +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n / Nonce Value /\n +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n\n Octets Bits Name Description\n 0 0 hopopt.ilnp.type Option Type\n 0 0 hopopt.ilnp.type.value Option Number\n 0 0 hopopt.ilnp.type.action Action (10)\n 0 2 hopopt.ilnp.type.change Change Flag (0)\n 1 8 hopopt.ilnp.length Length of Option Data\n 2 16 hopopt.ilnp.value Nonce Value" }, { "code": "def normalize_json(template):\n obj = parse_cloudformation_template(template)\n json_str = json.dumps(\n obj, sort_keys=True, indent=4, default=str, separators=(',', ': '),\n )\n result = []\n lines = json_str.split(\"\\n\")\n for line in lines:\n result.append(line + \"\\n\")\n return result", "docstring": "Normalize our template for diffing.\n\n Args:\n template(str): string representing the template\n\n Returns:\n list: json representation of the parameters" }, { "code": "def group_members(self, group_id, include_orphans=False):\n params = {'includeOrphans': str(include_orphans).lower()}\n url = self._service_url(['triggers', 'groups', group_id, 'members'], params=params)\n return Trigger.list_to_object_list(self._get(url))", "docstring": "Find all group member trigger definitions\n\n :param group_id: group trigger id\n :param include_orphans: If True, include orphan members\n :return: list of asociated group members as trigger objects" }, { "code": "def create_html(api_key, attrs):\n gif = get_gif(api_key, attrs['gif_id'])\n if 'alt' not in attrs.keys():\n attrs['alt'] = 'source: {}'.format(gif['data']['source'])\n html_out = ''.format(gif['data']['url'])\n html_out += '\"{}\"'.format(\n gif['data']['images']['original']['url'],\n attrs['alt'])\n html_out += ''\n return html_out", "docstring": "Returns complete html tag string." }, { "code": "def run_async(**kwargs):\n r = init_runner(**kwargs)\n runner_thread = threading.Thread(target=r.run)\n runner_thread.start()\n return runner_thread, r", "docstring": "Runs an Ansible Runner task in the background which will start immediately. Returns the thread object and a Runner object.\n\n This uses the same parameters as :py:func:`ansible_runner.interface.run`\n\n :returns: A tuple containing a :py:class:`threading.Thread` object and a :py:class:`ansible_runner.runner.Runner` object" }, { "code": "def transceive(self, data, timeout=None):\n log.debug(\">> {0}\".format(hexlify(data)))\n data = self._dep.exchange(data, timeout)\n log.debug(\"<< {0}\".format(hexlify(data) if data else \"None\"))\n return data", "docstring": "Transmit arbitrary data and receive the response.\n\n This is a low level method to send arbitrary data to the\n tag. While it should almost always be better to use\n :meth:`send_apdu` this is the only way to force a specific\n timeout value (which is otherwise derived from the Tag's\n answer to select). The *timeout* value is expected as a float\n specifying the seconds to wait." }, { "code": "def convert_to_mb(s):\n s = s.upper()\n try:\n if s.endswith('G'):\n return float(s[:-1].strip()) * 1024\n elif s.endswith('T'):\n return float(s[:-1].strip()) * 1024 * 1024\n else:\n return float(s[:-1].strip())\n except (IndexError, ValueError, KeyError, TypeError):\n errmsg = (\"Invalid memory format: %s\") % s\n raise exception.SDKInternalError(msg=errmsg)", "docstring": "Convert memory size from GB to MB." }, { "code": "def load_distant(self):\n print(\"Loading distant Zotero data...\")\n self._references = self.get_references()\n self.reference_types = self.get_reference_types()\n self.reference_templates = self.get_reference_templates(self.reference_types)\n print(\"Distant Zotero data loaded.\")\n self.cache()", "docstring": "Load the distant Zotero data." }, { "code": "def extract_audio(filename, channels=1, rate=16000):\n temp = tempfile.NamedTemporaryFile(suffix='.wav', delete=False)\n if not os.path.isfile(filename):\n print(\"The given file does not exist: {}\".format(filename))\n raise Exception(\"Invalid filepath: {}\".format(filename))\n if not which(\"ffmpeg\"):\n print(\"ffmpeg: Executable not found on machine.\")\n raise Exception(\"Dependency not found: ffmpeg\")\n command = [\"ffmpeg\", \"-y\", \"-i\", filename,\n \"-ac\", str(channels), \"-ar\", str(rate),\n \"-loglevel\", \"error\", temp.name]\n use_shell = True if os.name == \"nt\" else False\n subprocess.check_output(command, stdin=open(os.devnull), shell=use_shell)\n return temp.name, rate", "docstring": "Extract audio from an input file to a temporary WAV file." }, { "code": "def on_any_event(self, event):\n for delegate in self.delegates:\n if hasattr(delegate, \"on_any_event\"):\n delegate.on_any_event(event)", "docstring": "On any event method" }, { "code": "def processing_blocks(self):\n sbi_ids = Subarray(self.get_name()).sbi_ids\n pbs = []\n for sbi_id in sbi_ids:\n sbi = SchedulingBlockInstance(sbi_id)\n pbs.append(sbi.processing_block_ids)\n return 'PB', pbs", "docstring": "Return list of PBs associated with the subarray.\n\n " }, { "code": "def write (self, s):\n if isinstance(s, bytes):\n s = self._decode(s)\n for c in s:\n self.process(c)", "docstring": "Process text, writing it to the virtual screen while handling\n ANSI escape codes." }, { "code": "def _get_service_config(self):\n if not os.path.exists(self.config_path):\n try:\n os.makedirs(os.path.dirname(self.config_path))\n except OSError as exc:\n if exc.errno != errno.EEXIST:\n raise\n return {}\n with open(self.config_path, 'r') as data:\n return json.load(data)", "docstring": "Reads in config file of UAA credential information\n or generates one as a side-effect if not yet\n initialized." }, { "code": "def transform_e1e2(x, y, e1, e2, center_x=0, center_y=0):\n x_shift = x - center_x\n y_shift = y - center_y\n x_ = (1-e1) * x_shift - e2 * y_shift\n y_ = -e2 * x_shift + (1 + e1) * y_shift\n det = np.sqrt((1-e1)*(1+e1) + e2**2)\n return x_ / det, y_ / det", "docstring": "maps the coordinates x, y with eccentricities e1 e2 into a new elliptical coordiante system\n\n :param x:\n :param y:\n :param e1:\n :param e2:\n :param center_x:\n :param center_y:\n :return:" }, { "code": "def parse_string(self):\n word = ''\n if self.prior_delim:\n delim = self.prior_delim\n self.prior_delim = None\n else:\n delim = self.char\n word += self.char\n self.update_chars()\n while True:\n if self.char == delim:\n self.update_chars()\n if self.char == delim:\n word += 2 * delim\n self.update_chars()\n else:\n word += delim\n break\n elif self.char == '\\n':\n self.prior_delim = delim\n break\n else:\n word += self.char\n self.update_chars()\n return word", "docstring": "Tokenize a Fortran string." }, { "code": "def prepare_read(data, method='readlines', mode='r'):\n if hasattr(data, 'readlines'):\n data = getattr(data, method)()\n elif isinstance(data, list):\n if method == 'read':\n return ''.join(data)\n elif isinstance(data, basestring):\n data = getattr(open(data, mode), method)()\n else:\n raise TypeError('Unable to handle data of type %r' % type(data))\n return data", "docstring": "Prepare various input types for parsing.\n\n Args:\n data (iter): Data to read\n method (str): Method to process data with\n mode (str): Custom mode to process with, if data is a file\n\n Returns:\n list: List suitable for parsing\n\n Raises:\n TypeError: Invalid value for data" }, { "code": "def set_log_block_num(self, bl):\n if not self._initialized:\n raise pycdlibexception.PyCdlibInternalError('CL record not yet initialized!')\n self.child_log_block_num = bl", "docstring": "Set the logical block number for the child.\n\n Parameters:\n bl - Logical block number of the child.\n Returns:\n Nothing." }, { "code": "def get_access_token(self):\n if self.is_access_token_expired():\n if is_debug_enabled():\n debug('requesting new access_token')\n token = get_access_token(username=self.username,\n password=self.password,\n client_id=self.client_id,\n client_secret=self.client_secret,\n app_url=self.app_url)\n self.expires_at = time.time() + token['expires_in']/2\n self.access_token = token['access_token']\n return self.access_token", "docstring": "get a valid access token" }, { "code": "def match(self, device):\n return all(match_value(getattr(device, k), v)\n for k, v in self._match.items())", "docstring": "Check if the device object matches this filter." }, { "code": "def threaded_start(self, no_init=False):\n thread = Thread(target=self.init_connections, kwargs={\n 'no_init': no_init})\n thread.setDaemon(True)\n thread.start()\n thread.join()", "docstring": "Spawns a worker thread to set up the zookeeper connection" }, { "code": "def write(self, destination, filename, template_name, **kwargs):\n template = self.env.get_template(template_name)\n content = template.render(kwargs)\n super(TemplateFileWriter, self).write(destination=destination, filename=filename, content=content)", "docstring": "Write a file according to the template name\n\n Args:\n destination (string): the destination location\n filename (string): the filename that will be written\n template_name (string): the name of the template\n kwargs (dict): all attribute that will be passed to the template" }, { "code": "def _effective_perm_list_from_iter(self, perm_iter):\n highest_perm_str = self._highest_perm_from_iter(perm_iter)\n return (\n self._equal_or_lower_perm_list(highest_perm_str)\n if highest_perm_str is not None\n else None\n )", "docstring": "Return list of effective permissions for for highest permission in\n ``perm_iter``, ordered lower to higher, or None if ``perm_iter`` is empty." }, { "code": "def _get_block_publisher(self, state_hash):\n state_view = self._state_view_factory.create_view(state_hash)\n try:\n class BatchPublisher:\n def send(self, transactions):\n raise InvalidGenesisConsensusError(\n 'Consensus cannot send transactions during genesis.')\n consensus = ConsensusFactory.get_configured_consensus_module(\n NULL_BLOCK_IDENTIFIER,\n state_view)\n return consensus.BlockPublisher(\n BlockCache(self._block_store),\n state_view_factory=self._state_view_factory,\n batch_publisher=BatchPublisher(),\n data_dir=self._data_dir,\n config_dir=self._config_dir,\n validator_id=self._identity_signer.get_public_key().as_hex())\n except UnknownConsensusModuleError as e:\n raise InvalidGenesisStateError(e)", "docstring": "Returns the block publisher based on the consensus module set by the\n \"sawtooth_settings\" transaction family.\n\n Args:\n state_hash (str): The current state root hash for reading settings.\n\n Raises:\n InvalidGenesisStateError: if any errors occur getting the\n BlockPublisher." }, { "code": "def unlock(self, password: str):\n if self.locked:\n self._privkey = decode_keyfile_json(self.keystore, password.encode('UTF-8'))\n self.locked = False\n self._fill_address()", "docstring": "Unlock the account with a password.\n\n If the account is already unlocked, nothing happens, even if the password is wrong.\n\n Raises:\n ValueError: (originating in ethereum.keys) if the password is wrong\n (and the account is locked)" }, { "code": "def hybrid_meco_frequency(m1, m2, chi1, chi2, qm1=None, qm2=None):\n if qm1 is None:\n qm1 = 1\n if qm2 is None:\n qm2 = 1\n return velocity_to_frequency(hybrid_meco_velocity(m1, m2, chi1, chi2, qm1, qm2), m1 + m2)", "docstring": "Return the frequency of the hybrid MECO\n\n Parameters\n ----------\n m1 : float\n Mass of the primary object in solar masses.\n m2 : float\n Mass of the secondary object in solar masses.\n chi1: float\n Dimensionless spin of the primary object.\n chi2: float\n Dimensionless spin of the secondary object.\n qm1: {None, float}, optional\n Quadrupole-monopole term of the primary object (1 for black holes).\n If None, will be set to qm1 = 1.\n qm2: {None, float}, optional\n Quadrupole-monopole term of the secondary object (1 for black holes).\n If None, will be set to qm2 = 1.\n\n Returns\n -------\n f: float\n The frequency (in Hz) of the hybrid MECO" }, { "code": "def write_tex():\n datadir = livvkit.index_dir\n outdir = os.path.join(datadir, \"tex\")\n print(outdir)\n data_files = glob.glob(datadir + \"/**/*.json\", recursive=True)\n for each in data_files:\n data = functions.read_json(each)\n tex = translate_page(data)\n outfile = os.path.join(outdir, os.path.basename(each).replace('json', 'tex'))\n with open(outfile, 'w') as f:\n f.write(tex)", "docstring": "Finds all of the output data files, and writes them out to .tex" }, { "code": "def parse_tibiadata_datetime(date_dict) -> Optional[datetime.datetime]:\n try:\n t = datetime.datetime.strptime(date_dict[\"date\"], \"%Y-%m-%d %H:%M:%S.%f\")\n except (KeyError, ValueError, TypeError):\n return None\n if date_dict[\"timezone\"] == \"CET\":\n timezone_offset = 1\n elif date_dict[\"timezone\"] == \"CEST\":\n timezone_offset = 2\n else:\n return None\n t = t - datetime.timedelta(hours=timezone_offset)\n return t.replace(tzinfo=datetime.timezone.utc)", "docstring": "Parses time objects from the TibiaData API.\n\n Time objects are made of a dictionary with three keys:\n date: contains a string representation of the time\n timezone: a string representation of the timezone the date time is based on\n timezone_type: the type of representation used in the timezone key\n\n\n Parameters\n ----------\n date_dict: :class:`dict`\n Dictionary representing the time object.\n\n Returns\n -------\n :class:`datetime.date`, optional\n The represented datetime, in UTC." }, { "code": "def set_properties(self, pathobj, props, recursive):\n url = '/'.join([pathobj.drive,\n 'api/storage',\n str(pathobj.relative_to(pathobj.drive)).strip('/')])\n params = {'properties': encode_properties(props)}\n if not recursive:\n params['recursive'] = '0'\n text, code = self.rest_put(url,\n params=params,\n auth=pathobj.auth,\n verify=pathobj.verify,\n cert=pathobj.cert)\n if code == 404 and \"Unable to find item\" in text:\n raise OSError(2, \"No such file or directory: '%s'\" % url)\n if code != 204:\n raise RuntimeError(text)", "docstring": "Set artifact properties" }, { "code": "async def power_on(\n self, comment: str = None,\n wait: bool = False, wait_interval: int = 5):\n params = {\"system_id\": self.system_id}\n if comment is not None:\n params[\"comment\"] = comment\n try:\n self._data = await self._handler.power_on(**params)\n except CallError as error:\n if error.status == HTTPStatus.FORBIDDEN:\n message = \"Not allowed to power on machine.\"\n raise OperationNotAllowed(message) from error\n else:\n raise\n if not wait or self.power_state == PowerState.UNKNOWN:\n return self\n else:\n while self.power_state == PowerState.OFF:\n await asyncio.sleep(wait_interval)\n self._data = await self._handler.read(system_id=self.system_id)\n if self.power_state == PowerState.ERROR:\n msg = \"{hostname} failed to power on.\".format(\n hostname=self.hostname\n )\n raise PowerError(msg, self)\n return self", "docstring": "Power on.\n\n :param comment: Reason machine was powered on.\n :type comment: `str`\n :param wait: If specified, wait until the machine is powered on.\n :type wait: `bool`\n :param wait_interval: How often to poll, defaults to 5 seconds.\n :type wait_interval: `int`" }, { "code": "def handle(self, *args, **options):\n trigger_id = options.get('trigger_id')\n trigger = TriggerService.objects.filter(\n id=int(trigger_id),\n status=True,\n user__is_active=True,\n provider_failed__lt=settings.DJANGO_TH.get('failed_tries', 10),\n consumer_failed__lt=settings.DJANGO_TH.get('failed_tries', 10)\n ).select_related('consumer__name', 'provider__name')\n try:\n with Pool(processes=1) as pool:\n r = Read()\n result = pool.map_async(r.reading, trigger)\n result.get(timeout=360)\n p = Pub()\n result = pool.map_async(p.publishing, trigger)\n result.get(timeout=360)\n cache.delete('django_th' + '_fire_trigger_' + str(trigger_id))\n except TimeoutError as e:\n logger.warning(e)", "docstring": "get the trigger to fire" }, { "code": "def from_hising(cls, h, J, offset=None):\n poly = {(k,): v for k, v in h.items()}\n poly.update(J)\n if offset is not None:\n poly[frozenset([])] = offset\n return cls(poly, Vartype.SPIN)", "docstring": "Construct a binary polynomial from a higher-order Ising problem.\n\n Args:\n h (dict):\n The linear biases.\n\n J (dict):\n The higher-order biases.\n\n offset (optional, default=0.0):\n Constant offset applied to the model.\n\n Returns:\n :obj:`.BinaryPolynomial`\n\n Examples:\n >>> poly = dimod.BinaryPolynomial.from_hising({'a': 2}, {'ab': -1}, 0)" }, { "code": "def authenticate(self, username, password):\n r = self._query_('/users/authenticate', 'POST',\n params={'username': username,\n 'password': password})\n if r.status_code == 201:\n return r.text.strip('\"')\n else:\n raise ValueError('Authentication invalid.')", "docstring": "Authenticates your user and returns an auth token.\n\n :param str username: Hummingbird username.\n :param str password: Hummingbird password.\n :returns: str -- The Auth Token\n :raises: ValueError -- If the Authentication is wrong" }, { "code": "def age(self):\n aff4_type = self.Get(self.Schema.TYPE)\n if aff4_type:\n return aff4_type.age\n else:\n return rdfvalue.RDFDatetime.Now()", "docstring": "RDFDatetime at which the object was created." }, { "code": "def getLogs(self,\n argument_filters=None,\n fromBlock=None,\n toBlock=None,\n blockHash=None):\n if not self.address:\n raise TypeError(\"This method can be only called on \"\n \"an instated contract with an address\")\n abi = self._get_event_abi()\n if argument_filters is None:\n argument_filters = dict()\n _filters = dict(**argument_filters)\n blkhash_set = blockHash is not None\n blknum_set = fromBlock is not None or toBlock is not None\n if blkhash_set and blknum_set:\n raise ValidationError(\n 'blockHash cannot be set at the same'\n ' time as fromBlock or toBlock')\n data_filter_set, event_filter_params = construct_event_filter_params(\n abi,\n contract_address=self.address,\n argument_filters=_filters,\n fromBlock=fromBlock,\n toBlock=toBlock,\n address=self.address,\n )\n if blockHash is not None:\n event_filter_params['blockHash'] = blockHash\n logs = self.web3.eth.getLogs(event_filter_params)\n return tuple(get_event_data(abi, entry) for entry in logs)", "docstring": "Get events for this contract instance using eth_getLogs API.\n\n This is a stateless method, as opposed to createFilter.\n It can be safely called against nodes which do not provide\n eth_newFilter API, like Infura nodes.\n\n If there are many events,\n like ``Transfer`` events for a popular token,\n the Ethereum node might be overloaded and timeout\n on the underlying JSON-RPC call.\n\n Example - how to get all ERC-20 token transactions\n for the latest 10 blocks:\n\n .. code-block:: python\n\n from = max(mycontract.web3.eth.blockNumber - 10, 1)\n to = mycontract.web3.eth.blockNumber\n\n events = mycontract.events.Transfer.getLogs(fromBlock=from, toBlock=to)\n\n for e in events:\n print(e[\"args\"][\"from\"],\n e[\"args\"][\"to\"],\n e[\"args\"][\"value\"])\n\n The returned processed log values will look like:\n\n .. code-block:: python\n\n (\n AttributeDict({\n 'args': AttributeDict({}),\n 'event': 'LogNoArguments',\n 'logIndex': 0,\n 'transactionIndex': 0,\n 'transactionHash': HexBytes('...'),\n 'address': '0xF2E246BB76DF876Cef8b38ae84130F4F55De395b',\n 'blockHash': HexBytes('...'),\n 'blockNumber': 3\n }),\n AttributeDict(...),\n ...\n )\n\n See also: :func:`web3.middleware.filter.local_filter_middleware`.\n\n :param argument_filters:\n :param fromBlock: block number or \"latest\", defaults to \"latest\"\n :param toBlock: block number or \"latest\". Defaults to \"latest\"\n :param blockHash: block hash. blockHash cannot be set at the\n same time as fromBlock or toBlock\n :yield: Tuple of :class:`AttributeDict` instances" }, { "code": "def to(self, unit):\n from astropy.units import au, d\n return (self.au_per_d * au / d).to(unit)", "docstring": "Convert this velocity to the given AstroPy unit." }, { "code": "def shape(self) -> Tuple[int, ...]:\n nmb_place = len(self.sequences)\n nmb_time = len(hydpy.pub.timegrids.init)\n nmb_others = collections.deque()\n for sequence in self.sequences.values():\n nmb_others.append(sequence.shape)\n nmb_others_max = tuple(numpy.max(nmb_others, axis=0))\n return self.sort_timeplaceentries(nmb_time, nmb_place) + nmb_others_max", "docstring": "Required shape of |NetCDFVariableDeep.array|.\n\n For the default configuration, the first axis corresponds to the\n number of devices, and the second one to the number of timesteps.\n We show this for the 0-dimensional input sequence |lland_inputs.Nied|:\n\n >>> from hydpy.core.examples import prepare_io_example_1\n >>> nodes, elements = prepare_io_example_1()\n >>> from hydpy.core.netcdftools import NetCDFVariableDeep\n >>> ncvar = NetCDFVariableDeep('input_nied', isolate=False, timeaxis=1)\n >>> for element in elements:\n ... ncvar.log(element.model.sequences.inputs.nied, None)\n >>> ncvar.shape\n (3, 4)\n\n For higher dimensional sequences, each new entry corresponds\n to the maximum number of fields the respective sequences require.\n In the next example, we select the 1-dimensional sequence\n |lland_fluxes.NKor|. The maximum number 3 (last value of the\n returned |tuple|) is due to the third element defining three\n hydrological response units:\n\n >>> ncvar = NetCDFVariableDeep('flux_nkor', isolate=False, timeaxis=1)\n >>> for element in elements:\n ... ncvar.log(element.model.sequences.fluxes.nkor, None)\n >>> ncvar.shape\n (3, 4, 3)\n\n When using the first axis for time (`timeaxis=0`) the order of the\n first two |tuple| entries turns:\n\n >>> ncvar = NetCDFVariableDeep('flux_nkor', isolate=False, timeaxis=0)\n >>> for element in elements:\n ... ncvar.log(element.model.sequences.fluxes.nkor, None)\n >>> ncvar.shape\n (4, 3, 3)" }, { "code": "def any_ends_with(self, string_list, pattern):\n try:\n s_base = basestring\n except:\n s_base = str\n is_string = isinstance(pattern, s_base)\n if not is_string:\n return False\n for s in string_list:\n if pattern.endswith(s):\n return True\n return False", "docstring": "Returns true iff one of the strings in string_list ends in\n pattern." }, { "code": "def tokenize_string(cls, string, separator):\n results = []\n token = \"\"\n found_escape = False\n for c in string:\n if found_escape:\n if c == separator:\n token += separator\n else:\n token += \"\\\\\" + c\n found_escape = False\n continue\n if c == \"\\\\\":\n found_escape = True\n elif c == separator:\n results.append(token)\n token = \"\"\n else:\n token += c\n results.append(token)\n return results", "docstring": "Split string with given separator unless the separator is escaped with backslash" }, { "code": "def dispatch(self, method_frame):\n method = self.dispatch_map.get(method_frame.method_id)\n if method:\n callback = self.channel.clear_synchronous_cb(method)\n callback(method_frame)\n else:\n raise self.InvalidMethod(\n \"no method is registered with id: %d\" % method_frame.method_id)", "docstring": "Dispatch a method for this protocol." }, { "code": "def jsonld(client, datasets):\n from renku.models._json import dumps\n from renku.models._jsonld import asjsonld\n data = [\n asjsonld(\n dataset,\n basedir=os.path.relpath(\n '.', start=str(dataset.__reference__.parent)\n )\n ) for dataset in datasets\n ]\n click.echo(dumps(data, indent=2))", "docstring": "Format datasets as JSON-LD." }, { "code": "def updateDatasetMenu(self):\n enabled = True\n current = self.vtgui.dbs_tree_view.currentIndex()\n if current:\n leaf = self.vtgui.dbs_tree_model.nodeFromIndex(current)\n if leaf.node_kind in (u'group', u'root group'):\n enabled = False\n self.plot_action.setEnabled(enabled)", "docstring": "Update the `export` QAction when the Dataset menu is pulled down.\n\n This method is a slot. See class ctor for details." }, { "code": "def get_typecast_value(self, value, type):\n if type == entities.Variable.Type.BOOLEAN:\n return value == 'true'\n elif type == entities.Variable.Type.INTEGER:\n return int(value)\n elif type == entities.Variable.Type.DOUBLE:\n return float(value)\n else:\n return value", "docstring": "Helper method to determine actual value based on type of feature variable.\n\n Args:\n value: Value in string form as it was parsed from datafile.\n type: Type denoting the feature flag type.\n\n Return:\n Value type-casted based on type of feature variable." }, { "code": "def publish_topology_closed(self, topology_id):\n event = TopologyClosedEvent(topology_id)\n for subscriber in self.__topology_listeners:\n try:\n subscriber.closed(event)\n except Exception:\n _handle_exception()", "docstring": "Publish a TopologyClosedEvent to all topology listeners.\n\n :Parameters:\n - `topology_id`: A unique identifier for the topology this server\n is a part of." }, { "code": "def _validate_columns(self):\n geom_cols = {'the_geom', 'the_geom_webmercator', }\n col_overlap = set(self.style_cols) & geom_cols\n if col_overlap:\n raise ValueError('Style columns cannot be geometry '\n 'columns. `{col}` was chosen.'.format(\n col=','.join(col_overlap)))", "docstring": "Validate the options in the styles" }, { "code": "def go(gconfig, args):\n rconfig = gconfig['rejester']\n which_worker = rconfig.get('worker', 'fork_worker')\n if which_worker == 'fork_worker':\n yakonfig.set_default_config([rejester], config=gconfig)\n else:\n start_logging(gconfig, args.logpath)\n return start_worker(which_worker, rconfig)", "docstring": "Actually run the worker.\n\n This does some required housekeeping, like setting up logging for\n :class:`~rejester.workers.MultiWorker` and establishing the global\n :mod:`yakonfig` configuration. This expects to be called with the\n :mod:`yakonfig` configuration unset.\n\n :param dict gconfig: the :mod:`yakonfig` global configuration\n :param args: command-line arguments" }, { "code": "def restore(self, hist_uid):\n if self.check_post_role()['ADMIN']:\n pass\n else:\n return False\n histinfo = MWikiHist.get_by_uid(hist_uid)\n if histinfo:\n pass\n else:\n return False\n postinfo = MWiki.get_by_uid(histinfo.wiki_id)\n cur_cnt = tornado.escape.xhtml_unescape(postinfo.cnt_md)\n old_cnt = tornado.escape.xhtml_unescape(histinfo.cnt_md)\n MWiki.update_cnt(\n histinfo.wiki_id,\n {'cnt_md': old_cnt, 'user_name': self.userinfo.user_name}\n )\n MWikiHist.update_cnt(\n histinfo.uid,\n {'cnt_md': cur_cnt, 'user_name': postinfo.user_name}\n )\n if postinfo.kind == '1':\n self.redirect('/wiki/{0}'.format(postinfo.title))\n elif postinfo.kind == '2':\n self.redirect('/page/{0}.html'.format(postinfo.uid))", "docstring": "Restore by ID" }, { "code": "def can_execute(self):\n return not self._disabled and all(dep.status == dep.node.S_OK for dep in self.deps)", "docstring": "True if we can execute the callback." }, { "code": "def get_value(self):\r\n if self.__is_value_array:\r\n if self.__bit_size == 8:\n return list(self.__value)\r\n else:\r\n result = []\r\n for i in range(self.__report_count):\r\n result.append(self.__getitem__(i))\r\n return result\r\n else:\r\n return self.__value", "docstring": "Retreive usage value within report" }, { "code": "def delete_answer(self, answer_id):\n from dlkit.abstract_osid.id.primitives import Id as ABCId\n from .objects import Answer\n collection = JSONClientValidated('assessment',\n collection='Item',\n runtime=self._runtime)\n if not isinstance(answer_id, ABCId):\n raise errors.InvalidArgument('the argument is not a valid OSID Id')\n item = collection.find_one({'answers._id': ObjectId(answer_id.get_identifier())})\n index = 0\n found = False\n for i in item['answers']:\n if i['_id'] == ObjectId(answer_id.get_identifier()):\n answer_map = item['answers'].pop(index)\n index += 1\n found = True\n if not found:\n raise errors.OperationFailed()\n Answer(\n osid_object_map=answer_map,\n runtime=self._runtime,\n proxy=self._proxy)._delete()\n collection.save(item)", "docstring": "Deletes the ``Answer`` identified by the given ``Id``.\n\n arg: answer_id (osid.id.Id): the ``Id`` of the ``Answer`` to\n delete\n raise: NotFound - an ``Answer`` was not found identified by the\n given ``Id``\n raise: NullArgument - ``answer_id`` is ``null``\n raise: OperationFailed - unable to complete request\n raise: PermissionDenied - authorization failure occurred\n *compliance: mandatory -- This method must be implemented.*" }, { "code": "def parse_json(target, json, create_sections = False, create_options = False):\r\n is_dict = isinstance(json, dict)\r\n for o in json:\r\n if is_dict:\r\n section = o\r\n else:\r\n section = o[0]\r\n if not target.has_section(section):\r\n if create_sections:\r\n target.add_section(section)\r\n else:\r\n continue\r\n for k, v in (json[o].items() if is_dict else o[1]):\r\n if target.has_option(section, k) or create_options:\r\n target.set(section, k, v)\n return target", "docstring": "Given a confmanager object and a dictionary object, import the values from the dictionary into the object, optionally adding sections and options as it goes." }, { "code": "def show_error(self, message):\n assert isinstance(message, string_types)\n self.post('error', data=message)", "docstring": "Send an error message to the active client. The new error will be\n displayed on any active GUI clients.\n\n Args:\n message (str): Plain-text message to display.\n\n Returns:\n None\n\n >>> s = _syncthing()\n >>> s.system.show_error('my error msg')\n >>> s.system.errors()[0]\n ... # doctest: +ELLIPSIS\n ErrorEvent(when=datetime.datetime(...), message='\"my error msg\"')\n >>> s.system.clear_errors()\n >>> s.system.errors()\n []" }, { "code": "def generate_lifetime_subparser(subparsers):\n parser = subparsers.add_parser(\n 'lifetime', description=constants.LIFETIME_DESCRIPTION,\n epilog=constants.LIFETIME_EPILOG, formatter_class=ParagraphFormatter,\n help=constants.LIFETIME_HELP)\n parser.set_defaults(func=lifetime_report)\n utils.add_tokenizer_argument(parser)\n utils.add_common_arguments(parser)\n utils.add_query_arguments(parser)\n parser.add_argument('results', help=constants.LIFETIME_RESULTS_HELP,\n metavar='RESULTS')\n parser.add_argument('label', help=constants.LIFETIME_LABEL_HELP,\n metavar='LABEL')\n parser.add_argument('output', help=constants.REPORT_OUTPUT_HELP,\n metavar='OUTPUT')", "docstring": "Adds a sub-command parser to `subparsers` to make a lifetime report." }, { "code": "def results(project, apikey, run, watch, server, output):\n status = run_get_status(server, project, run, apikey)\n log(format_run_status(status))\n if watch:\n for status in watch_run_status(server, project, run, apikey, 24*60*60):\n log(format_run_status(status))\n if status['state'] == 'completed':\n log(\"Downloading result\")\n response = run_get_result_text(server, project, run, apikey)\n log(\"Received result\")\n print(response, file=output)\n elif status['state'] == 'error':\n log(\"There was an error\")\n error_result = run_get_result_text(server, project, run, apikey)\n print(error_result, file=output)\n else:\n log(\"No result yet\")", "docstring": "Check to see if results are available for a particular mapping\n and if so download.\n\n Authentication is carried out using the --apikey option which\n must be provided. Depending on the server operating mode this\n may return a mask, a linkage table, or a permutation. Consult\n the entity service documentation for details." }, { "code": "def check_cups_allowed(func):\n @wraps(func)\n def decorator(*args, **kwargs):\n cups = kwargs.get('cups')\n if (cups and current_user.is_authenticated()\n and not current_user.allowed(cups, 'cups')):\n return current_app.login_manager.unauthorized()\n return func(*args, **kwargs)\n return decorator", "docstring": "Check if CUPS is allowd by token" }, { "code": "def start(self):\n yield from self._do_connect()\n _LOGGER.info('connected to snapserver on %s:%s', self._host, self._port)\n status = yield from self.status()\n self.synchronize(status)\n self._on_server_connect()", "docstring": "Initiate server connection." }, { "code": "def add_key_filters(self, key_filters):\n if self._input_mode == 'query':\n raise ValueError('Key filters are not supported in a query.')\n self._key_filters.extend(key_filters)\n return self", "docstring": "Adds key filters to the inputs.\n\n :param key_filters: a list of filters\n :type key_filters: list\n :rtype: :class:`RiakMapReduce`" }, { "code": "def _emit(self, s):\n if os.path.exists(self._html_dir):\n self._report_file.write(s)\n self._report_file.flush()", "docstring": "Append content to the main report file." }, { "code": "def get_allow_future(self):\n qs = self.get_queryset()\n post_edit_permission = '{}.edit_{}'.format(\n qs.model._meta.app_label, qs.model._meta.model_name\n )\n if self.request.user.has_perm(post_edit_permission):\n return True\n return False", "docstring": "Only superusers and users with the permission can edit the post." }, { "code": "def set_managing_editor(self):\n try:\n self.managing_editor = self.soup.find('managingeditor').string\n except AttributeError:\n self.managing_editor = None", "docstring": "Parses managing editor and set value" }, { "code": "def date_this_decade(self, before_today=True, after_today=False):\n today = date.today()\n this_decade_start = date(today.year - (today.year % 10), 1, 1)\n next_decade_start = date(this_decade_start.year + 10, 1, 1)\n if before_today and after_today:\n return self.date_between_dates(this_decade_start, next_decade_start)\n elif not before_today and after_today:\n return self.date_between_dates(today, next_decade_start)\n elif not after_today and before_today:\n return self.date_between_dates(this_decade_start, today)\n else:\n return today", "docstring": "Gets a Date object for the decade year.\n\n :param before_today: include days in current decade before today\n :param after_today: include days in current decade after today\n :example Date('2012-04-04')\n :return Date" }, { "code": "def binary_op(data, op, other, blen=None, storage=None, create='array',\n **kwargs):\n if hasattr(other, 'shape') and len(other.shape) == 0:\n other = other[()]\n if np.isscalar(other):\n def f(block):\n return op(block, other)\n return map_blocks(data, f, blen=blen, storage=storage, create=create, **kwargs)\n elif len(data) == len(other):\n def f(a, b):\n return op(a, b)\n return map_blocks((data, other), f, blen=blen, storage=storage, create=create,\n **kwargs)\n else:\n raise NotImplementedError('argument type not supported')", "docstring": "Compute a binary operation block-wise over `data`." }, { "code": "def iter_identities(self, stanza=None):\n for (category, type_), names in self._identities.items():\n for lang, name in names.items():\n yield category, type_, lang, name\n if not names:\n yield category, type_, None, None", "docstring": "Return an iterator of tuples describing the identities of the node.\n\n :param stanza: The IQ request stanza\n :type stanza: :class:`~aioxmpp.IQ` or :data:`None`\n :rtype: iterable of (:class:`str`, :class:`str`, :class:`str` or\n :data:`None`, :class:`str` or :data:`None`) tuples\n :return: :xep:`30` identities of this node\n\n `stanza` can be the :class:`aioxmpp.IQ` stanza of the request. This can\n be used to hide a node depending on who is asking. If the returned\n iterable is empty, the :class:`~.DiscoServer` returns an\n ```` error.\n\n `stanza` may be :data:`None` if the identities are queried without\n a specific request context. In that case, implementors should assume\n that the result is visible to everybody.\n\n .. note::\n\n Subclasses must allow :data:`None` for `stanza` and default it to\n :data:`None`.\n\n Return an iterator which yields tuples consisting of the category, the\n type, the language code and the name of each identity declared in this\n :class:`Node`.\n\n Both the language code and the name may be :data:`None`, if no names or\n a name without language code have been declared." }, { "code": "def delete_tenant(self, tenant):\n tenant_id = utils.get_id(tenant)\n uri = \"tenants/%s\" % tenant_id\n resp, resp_body = self.method_delete(uri)\n if resp.status_code == 404:\n raise exc.TenantNotFound(\"Tenant '%s' does not exist.\" % tenant)", "docstring": "ADMIN ONLY. Removes the tenant from the system. There is no 'undo'\n available, so you should be certain that the tenant specified is the\n tenant you wish to delete." }, { "code": "def _find_neighbor_and_lambda(neighbor_indices, neighbor_distances,\n core_distances, min_samples):\n neighbor_core_distances = core_distances[neighbor_indices]\n point_core_distances = neighbor_distances[min_samples] * np.ones(\n neighbor_indices.shape[0])\n mr_distances = np.vstack((\n neighbor_core_distances,\n point_core_distances,\n neighbor_distances\n )).max(axis=0)\n nn_index = mr_distances.argmin()\n nearest_neighbor = neighbor_indices[nn_index]\n if mr_distances[nn_index] > 0.0:\n lambda_ = 1. / mr_distances[nn_index]\n else:\n lambda_ = np.finfo(np.double).max\n return nearest_neighbor, lambda_", "docstring": "Find the nearest mutual reachability neighbor of a point, and compute\n the associated lambda value for the point, given the mutual reachability\n distance to a nearest neighbor.\n\n Parameters\n ----------\n neighbor_indices : array (2 * min_samples, )\n An array of raw distance based nearest neighbor indices.\n\n neighbor_distances : array (2 * min_samples, )\n An array of raw distances to the nearest neighbors.\n\n core_distances : array (n_samples, )\n An array of core distances for all points\n\n min_samples : int\n The min_samples value used to generate core distances.\n\n Returns\n -------\n neighbor : int\n The index into the full raw data set of the nearest mutual reachability\n distance neighbor of the point.\n\n lambda_ : float\n The lambda value at which this point joins/merges with `neighbor`." }, { "code": "def getNameOwner(self, busName):\n d = self.callRemote(\n '/org/freedesktop/DBus',\n 'GetNameOwner',\n interface='org.freedesktop.DBus',\n signature='s',\n body=[busName],\n destination='org.freedesktop.DBus',\n )\n return d", "docstring": "Calls org.freedesktop.DBus.GetNameOwner\n @rtype: L{twisted.internet.defer.Deferred}\n @returns: a Deferred to the unique connection name owning the bus name" }, { "code": "def get_named_graph(identifier, store_id=DEFAULT_STORE, create=True):\n if not isinstance(identifier, URIRef):\n identifier = URIRef(identifier)\n store = DjangoStore(store_id)\n graph = Graph(store, identifier=identifier)\n if graph.open(None, create=create) != VALID_STORE:\n raise ValueError(\"The store identified by {0} is not a valid store\".format(store_id))\n return graph", "docstring": "Returns an open named graph." }, { "code": "def DbGetExportdDeviceListForClass(self, argin):\n self._log.debug(\"In DbGetExportdDeviceListForClass()\")\n argin = replace_wildcard(argin)\n return self.db.get_exported_device_list_for_class(argin)", "docstring": "Query the database for device exported for the specified class.\n\n :param argin: Class name\n :type: tango.DevString\n :return: Device exported list\n :rtype: tango.DevVarStringArray" }, { "code": "def _compile_to_sklearn(self, expr):\n sklearn_pipeline_str = generate_pipeline_code(expr_to_tree(expr, self._pset), self.operators)\n sklearn_pipeline = eval(sklearn_pipeline_str, self.operators_context)\n sklearn_pipeline.memory = self._memory\n return sklearn_pipeline", "docstring": "Compile a DEAP pipeline into a sklearn pipeline.\n\n Parameters\n ----------\n expr: DEAP individual\n The DEAP pipeline to be compiled\n\n Returns\n -------\n sklearn_pipeline: sklearn.pipeline.Pipeline" }, { "code": "def update_policy(self,defaultHeaders):\n\t\tif self.inputs is not None:\n\t\t\tfor k,v in defaultHeaders.items():\n\t\t\t\tif k not in self.inputs:\n\t\t\t\t\tself.inputs[k] = v\n\t\t\t\tif k == 'pins':\n\t\t\t\t\tself.inputs[k] = self.inputs[k] + defaultHeaders[k]\n\t\t\treturn self.inputs\n\t\telse:\n\t\t\treturn self.inputs", "docstring": "rewrite update policy so that additional pins are added and not overwritten" }, { "code": "def organization_deidentify_template_path(cls, organization, deidentify_template):\n return google.api_core.path_template.expand(\n \"organizations/{organization}/deidentifyTemplates/{deidentify_template}\",\n organization=organization,\n deidentify_template=deidentify_template,\n )", "docstring": "Return a fully-qualified organization_deidentify_template string." }, { "code": "def show_calltip(self, signature, doc='', parameter='', parameter_doc='',\r\n color=_DEFAULT_TITLE_COLOR, is_python=False):\r\n point = self._calculate_position()\r\n tiptext, wrapped_lines = self._format_signature(\r\n signature,\r\n doc,\r\n parameter,\r\n parameter_doc,\r\n color,\r\n is_python,\r\n )\r\n self._update_stylesheet(self.calltip_widget)\r\n self.calltip_widget.show_tip(point, tiptext, wrapped_lines)", "docstring": "Show calltip.\r\n\r\n Calltips look like tooltips but will not disappear if mouse hovers\r\n them. They are useful for displaying signature information on methods\r\n and functions." }, { "code": "def copy_func(func: Callable) -> Callable:\n copied = types.FunctionType(\n func.__code__, func.__globals__, name=func.__name__,\n argdefs=func.__defaults__, closure=func.__closure__)\n copied = functools.update_wrapper(copied, func)\n copied.__kwdefaults__ = func.__kwdefaults__\n return copied", "docstring": "Returns a copy of a function.\n\n :param func: The function to copy.\n :returns: The copied function." }, { "code": "def hyphenation(phrase, format='json'):\n base_url = Vocabulary.__get_api_link(\"wordnik\")\n url = base_url.format(word=phrase.lower(), action=\"hyphenation\")\n json_obj = Vocabulary.__return_json(url)\n if json_obj:\n return Response().respond(json_obj, format)\n else:\n return False", "docstring": "Returns back the stress points in the \"phrase\" passed\n\n :param phrase: word for which hyphenation is to be found\n :param format: response structure type. Defaults to: \"json\"\n :returns: returns a json object as str, False if invalid phrase" }, { "code": "def wait(msg='', exceptions=None, timeout=10):\n exc = [StaleElementReferenceException]\n if exceptions is not None:\n try:\n exc.extend(iter(exceptions))\n except TypeError:\n exc.append(exceptions)\n exc = tuple(exc)\n if not msg:\n msg = \"Could not recover from Exception(s): {}\".format(', '.join([e.__name__ for e in exc]))\n def wrapper(func):\n def wait_handler(*args, **kwargs):\n import time\n poll_freq = 0.5\n end_time = time.time() + timeout\n while time.time() <= end_time:\n try:\n value = func(*args, **kwargs)\n if value:\n return value\n except exc as e:\n LOGGER.debug(e)\n pass\n time.sleep(poll_freq)\n poll_freq *= 1.25\n raise RuntimeError(msg)\n return wait_handler\n return wrapper", "docstring": "Decorator to handle generic waiting situations.\n\n Will handle StaleElementReferenceErrors.\n\n :param msg: Error message\n :param exceptions: Extra exceptions to handle\n :param timeout: time to keep trying (default: 10 seconds)\n :return: the result of the decorated function" }, { "code": "def rotation(self):\n\t\trotation = self._libinput.libinput_event_tablet_tool_get_rotation(\n\t\t\tself._handle)\n\t\tchanged = self._libinput. \\\n\t\t\tlibinput_event_tablet_tool_rotation_has_changed(self._handle)\n\t\treturn rotation, changed", "docstring": "The current Z rotation of the tool in degrees, clockwise\n\t\tfrom the tool's logical neutral position and whether it has changed\n\t\tin this event.\n\n\t\tFor tools of type :attr:`~libinput.constant.TabletToolType.MOUSE`\n\t\tand :attr:`~libinput.constant.TabletToolType.LENS` the logical\n\t\tneutral position is pointing to the current logical north\n\t\tof the tablet. For tools of type\n\t\t:attr:`~libinput.constant.TabletToolType.BRUSH`, the logical\n\t\tneutral position is with the buttons pointing up.\n\n\t\tIf this axis does not exist on the current tool, this property is\n\t\t(0, :obj:`False`).\n\n\t\tReturns:\n\t\t\t(float, bool): The current value of the the axis and whether it has\n\t\t\tchanged." }, { "code": "def anscombe():\n _, ((axa, axb), (axc, axd)) = plt.subplots(2, 2, sharex='col', sharey='row')\n colors = get_color_cycle()\n for arr, ax, color in zip(ANSCOMBE, (axa, axb, axc, axd), colors):\n x = arr[0]\n y = arr[1]\n ax.set_xlim(0, 15)\n ax.set_ylim(0, 15)\n ax.scatter(x, y, c=color)\n draw_best_fit(x, y, ax, c=color)\n return (axa, axb, axc, axd)", "docstring": "Creates 2x2 grid plot of the 4 anscombe datasets for illustration." }, { "code": "def create_ui(self):\n self.entry = gtk.Entry()\n self.widget.add(self.entry)", "docstring": "Create the user interface\n\n create_ui is a method called during the Delegate's\n initialisation process, to create, add to, or modify any UI\n created by GtkBuilder files." }, { "code": "def integrate(self, wave=None):\n if wave is None:\n wave = self.wave\n ans = self.trapezoidIntegration(wave, self(wave))\n return ans", "docstring": "Integrate the throughput over the specified wavelength set.\n If no wavelength set is specified, the built-in one is used.\n\n Integration is done using :meth:`~Integrator.trapezoidIntegration`\n with ``x=wave`` and ``y=throughput``.\n Also see :ref:`pysynphot-formula-equvw`.\n\n Parameters\n ----------\n wave : array_like or `None`\n Wavelength set for integration.\n\n Returns\n -------\n ans : float\n Integrated sum." }, { "code": "def get_all_parcels(self, view = None):\n return parcels.get_all_parcels(self._get_resource_root(), self.name, view)", "docstring": "Get all parcels in this cluster.\n\n @return: A list of ApiParcel objects." }, { "code": "def get_attr_info(binary_view):\n global _ATTR_BASIC\n attr_type, attr_len, non_resident = _ATTR_BASIC.unpack(binary_view[:9])\n return (AttrTypes(attr_type), attr_len, bool(non_resident))", "docstring": "Gets basic information from a binary stream to allow correct processing of\n the attribute header.\n\n This function allows the interpretation of the Attribute type, attribute length\n and if the attribute is non resident.\n\n Args:\n binary_view (memoryview of bytearray) - A binary stream with the\n information of the attribute\n\n Returns:\n An tuple with the attribute type, the attribute length, in bytes, and\n if the attribute is resident or not." }, { "code": "def _render_internal_label(self):\n ncc = self._num_complete_chars\n bar = self._lbl.center(self.iwidth)\n cm_chars = self._comp_style(bar[:ncc])\n em_chars = self._empt_style(bar[ncc:])\n return f'{self._first}{cm_chars}{em_chars}{self._last}'", "docstring": "Render with a label inside the bar graph." }, { "code": "def get_action_group_names(self):\n return self.get_group_names(\n list(itertools.chain(\n *[self._get_array('add'),\n self._get_array('remove'),\n self._get_array('isolation-group')])))", "docstring": "Return all the security group names configured in this action." }, { "code": "def run():\n logging.basicConfig(level=logging.DEBUG)\n load_config.ConfigLoader().load()\n config.debug = True\n print(repr(config.engine.item(sys.argv[1])))", "docstring": "Module level test." }, { "code": "def A_hollow_cylinder(Di, Do, L):\n r\n side_o = pi*Do*L\n side_i = pi*Di*L\n cap_circle = pi*Do**2/4*2\n cap_removed = pi*Di**2/4*2\n return side_o + side_i + cap_circle - cap_removed", "docstring": "r'''Returns the surface area of a hollow cylinder.\n\n .. math::\n A = \\pi D_o L + \\pi D_i L + 2\\cdot \\frac{\\pi D_o^2}{4}\n - 2\\cdot \\frac{\\pi D_i^2}{4}\n\n Parameters\n ----------\n Di : float\n Diameter of the hollow in the cylinder, [m]\n Do : float\n Diameter of the exterior of the cylinder, [m]\n L : float\n Length of the cylinder, [m]\n\n Returns\n -------\n A : float\n Surface area [m^2]\n\n Examples\n --------\n >>> A_hollow_cylinder(0.005, 0.01, 0.1)\n 0.004830198704894308" }, { "code": "def update_milestone(self, milestone_id, title, deadline, party_id, notify,\n move_upcoming_milestones=None,\n move_upcoming_milestones_off_weekends=None):\n path = '/milestones/update/%u' % milestone_id\n req = ET.Element('request')\n req.append(\n self._create_milestone_elem(title, deadline, party_id, notify))\n if move_upcoming_milestones is not None:\n ET.SubElement(req, 'move-upcoming-milestones').text \\\n = str(bool()).lower()\n if move_upcoming_milestones_off_weekends is not None:\n ET.SubElement(req, 'move-upcoming-milestones-off-weekends').text \\\n = str(bool()).lower()\n return self._request(path, req)", "docstring": "Modifies a single milestone. You can use this to shift the deadline of\n a single milestone, and optionally shift the deadlines of subsequent\n milestones as well." }, { "code": "def _read_mode_qsopt(self, size, kind):\n rvrr = self._read_binary(1)\n ttld = self._read_unpack(1)\n noun = self._read_fileng(4)\n data = dict(\n kind=kind,\n length=size,\n req_rate=int(rvrr[4:], base=2),\n ttl_diff=ttld,\n nounce=noun[:-2],\n )\n return data", "docstring": "Read Quick-Start Response option.\n\n Positional arguments:\n * size - int, length of option\n * kind - int, 27 (Quick-Start Response)\n\n Returns:\n * dict -- extracted Quick-Start Response (QS) option\n\n Structure of TCP QSopt [RFC 4782]:\n 0 1 2 3\n 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1\n +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n | Kind | Length=8 | Resv. | Rate | TTL Diff |\n | | | |Request| |\n +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n | QS Nonce | R |\n +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n\n Octets Bits Name Description\n 0 0 tcp.qs.kind Kind (27)\n 1 8 tcp.qs.length Length (8)\n 2 16 - Reserved (must be zero)\n 2 20 tcp.qs.req_rate Request Rate\n 3 24 tcp.qs.ttl_diff TTL Difference\n 4 32 tcp.qs.nounce QS Nounce\n 7 62 - Reserved (must be zero)" }, { "code": "def get_item_key(self, item):\n try:\n ret = item[item['key']]\n except KeyError:\n logger.error(\"No 'key' available in {}\".format(item))\n if isinstance(ret, list):\n return ret[0]\n else:\n return ret", "docstring": "Return the value of the item 'key'." }, { "code": "def get_fw_dict(self):\n fw_dict = {}\n if self.fw_id is None:\n return fw_dict\n fw_dict = {'rules': {}, 'tenant_name': self.tenant_name,\n 'tenant_id': self.tenant_id, 'fw_id': self.fw_id,\n 'fw_name': self.fw_name,\n 'firewall_policy_id': self.active_pol_id,\n 'fw_type': self.fw_type, 'router_id': self.router_id}\n if self.active_pol_id not in self.policies:\n return fw_dict\n pol_dict = self.policies[self.active_pol_id]\n for rule in pol_dict['rule_dict']:\n fw_dict['rules'][rule] = self.rules[rule]\n return fw_dict", "docstring": "This API creates a FW dictionary from the local attributes." }, { "code": "def fill_nulls(self, col: str):\n n = [None, \"\"]\n try:\n self.df[col] = self.df[col].replace(n, nan)\n except Exception as e:\n self.err(e)", "docstring": "Fill all null values with NaN values in a column.\n Null values are ``None`` or en empty string\n\n :param col: column name\n :type col: str\n\n :example: ``ds.fill_nulls(\"mycol\")``" }, { "code": "def search_function(encoding):\n if encoding in _CACHE:\n return _CACHE[encoding]\n norm_encoding = normalize_encoding(encoding)\n codec = None\n if norm_encoding in UTF8_VAR_NAMES:\n from ftfy.bad_codecs.utf8_variants import CODEC_INFO\n codec = CODEC_INFO\n elif norm_encoding.startswith('sloppy_'):\n from ftfy.bad_codecs.sloppy import CODECS\n codec = CODECS.get(norm_encoding)\n if codec is not None:\n _CACHE[encoding] = codec\n return codec", "docstring": "Register our \"bad codecs\" with Python's codecs API. This involves adding\n a search function that takes in an encoding name, and returns a codec\n for that encoding if it knows one, or None if it doesn't.\n\n The encodings this will match are:\n\n - Encodings of the form 'sloppy-windows-NNNN' or 'sloppy-iso-8859-N',\n where the non-sloppy version is an encoding that leaves some bytes\n unmapped to characters.\n - The 'utf-8-variants' encoding, which has the several aliases seen\n above." }, { "code": "def lock(key, text):\n return hmac.new(key.encode('utf-8'), text.encode('utf-8')).hexdigest()", "docstring": "Locks the given text using the given key and returns the result" }, { "code": "def _calc_d(aod700, p):\n p0 = 101325.\n dp = 1/(18 + 152*aod700)\n d = -0.337*aod700**2 + 0.63*aod700 + 0.116 + dp*np.log(p/p0)\n return d", "docstring": "Calculate the d coefficient." }, { "code": "def init0(self, dae):\n dae.y[self.v] = self.v0\n dae.y[self.q] = mul(self.u, self.qg)", "docstring": "Set initial voltage and reactive power for PQ.\n Overwrites Bus.voltage values" }, { "code": "def safe_unicode(string):\n if not isinstance(string, basestring):\n string = unicode(string)\n if isinstance(string, unicode):\n string = string.encode('utf8')\n return string", "docstring": "Safely transform any object into utf8 encoded bytes" }, { "code": "def separate_struct_array(array, dtypes):\n try:\n offsets = np.cumsum([np.dtype(dtype).itemsize for dtype in dtypes])\n except TypeError:\n dtype_size = np.dtype(dtypes).itemsize\n num_fields = int(array.nbytes / (array.size * dtype_size))\n offsets = np.cumsum([dtype_size] * num_fields)\n dtypes = [dtypes] * num_fields\n offsets = np.concatenate([[0], offsets]).astype(int)\n uint_array = array.view(np.uint8).reshape(array.shape + (-1,))\n return [\n uint_array[..., offsets[idx]:offsets[idx+1]].flatten().view(dtype)\n for idx, dtype in enumerate(dtypes)\n ]", "docstring": "Takes an array with a structured dtype, and separates it out into\n a list of arrays with dtypes coming from the input ``dtypes``.\n Does the inverse of ``join_struct_arrays``.\n\n :param np.ndarray array: Structured array.\n :param dtypes: List of ``np.dtype``, or just a ``np.dtype`` and the number of\n them is figured out automatically by counting bytes." }, { "code": "def write_blockdata(self, obj, parent=None):\n if type(obj) is str:\n obj = to_bytes(obj, \"latin-1\")\n length = len(obj)\n if length <= 256:\n self._writeStruct(\">B\", 1, (self.TC_BLOCKDATA,))\n self._writeStruct(\">B\", 1, (length,))\n else:\n self._writeStruct(\">B\", 1, (self.TC_BLOCKDATALONG,))\n self._writeStruct(\">I\", 1, (length,))\n self.object_stream.write(obj)", "docstring": "Appends a block of data to the serialization stream\n\n :param obj: String form of the data block" }, { "code": "def preproc_directive(self) -> bool:\n self._stream.save_context()\n if self.read_until(\"\\n\", '\\\\'):\n return self._stream.validate_context()\n return self._stream.restore_context()", "docstring": "Consume a preproc directive." }, { "code": "def hostname(name, hostname=None):\n ret = _default_ret(name)\n current_name = __salt__['cimc.get_hostname']()\n req_change = False\n try:\n if current_name != hostname:\n req_change = True\n if req_change:\n update = __salt__['cimc.set_hostname'](hostname)\n if not update:\n ret['result'] = False\n ret['comment'] = \"Error setting hostname.\"\n return ret\n ret['changes']['before'] = current_name\n ret['changes']['after'] = hostname\n ret['comment'] = \"Hostname modified.\"\n else:\n ret['comment'] = \"Hostname already configured. No changes required.\"\n except Exception as err:\n ret['result'] = False\n ret['comment'] = \"Error occurred setting hostname.\"\n log.error(err)\n return ret\n ret['result'] = True\n return ret", "docstring": "Ensures that the hostname is set to the specified value.\n\n .. versionadded:: 2019.2.0\n\n name: The name of the module function to execute.\n\n hostname(str): The hostname of the server.\n\n SLS Example:\n\n .. code-block:: yaml\n\n set_name:\n cimc.hostname:\n - hostname: foobar" }, { "code": "def component_acting_parent_tag(parent_tag, tag):\n if parent_tag.name == \"fig-group\":\n if (len(tag.find_previous_siblings(\"fig\")) > 0):\n acting_parent_tag = first(extract_nodes(parent_tag, \"fig\"))\n else:\n return None\n else:\n acting_parent_tag = parent_tag\n return acting_parent_tag", "docstring": "Only intended for use in getting components, look for tag name of fig-group\n and if so, find the first fig tag inside it as the acting parent tag" }, { "code": "def restore_site_properties(self, site_property=\"ff_map\", filename=None):\n if not self.control_params[\"filetype\"] == \"pdb\":\n raise ValueError()\n filename = filename or self.control_params[\"output\"]\n bma = BabelMolAdaptor.from_file(filename, \"pdb\")\n pbm = pb.Molecule(bma._obmol)\n assert len(pbm.residues) == sum([x[\"number\"]\n for x in self.param_list])\n packed_mol = self.convert_obatoms_to_molecule(\n pbm.residues[0].atoms, residue_name=pbm.residues[0].name,\n site_property=site_property)\n for resid in pbm.residues[1:]:\n mol = self.convert_obatoms_to_molecule(\n resid.atoms, residue_name=resid.name,\n site_property=site_property)\n for site in mol:\n packed_mol.append(site.species, site.coords,\n properties=site.properties)\n return packed_mol", "docstring": "Restore the site properties for the final packed molecule.\n\n Args:\n site_property (str):\n filename (str): path to the final packed molecule.\n\n Returns:\n Molecule" }, { "code": "def predict_files(self, files):\n imgs = [0]*len(files)\n for i, file in enumerate(files):\n img = cv2.imread(file).astype('float64')\n img = cv2.resize(img, (224,224))\n img = preprocess_input(img)\n if img is None:\n print('failed to open: {}, continuing...'.format(file))\n imgs[i] = img\n return self.model.predict(np.array(imgs))", "docstring": "reads files off disk, resizes them\n and then predicts them, files should\n be a list or itrerable of file paths\n that lead to images, they are then\n loaded with opencv, resized, and predicted" }, { "code": "def delete(self, invoice_id, **kwargs):\n url = \"{}/{}\".format(self.base_url, invoice_id)\n return self.delete_url(url, {}, **kwargs)", "docstring": "Delete an invoice\n You can delete an invoice which is in the draft state.\n\n Args:\n invoice_id : Id for delete the invoice\n Returns:\n The response is always be an empty array like this - []" }, { "code": "def add_resource(self, resource_id, attributes, parents=[],\n issuer='default'):\n assert isinstance(attributes, (dict)), \"attributes expected to be dict\"\n attrs = []\n for key in attributes.keys():\n attrs.append({\n 'issuer': issuer,\n 'name': key,\n 'value': attributes[key]\n })\n body = {\n \"resourceIdentifier\": resource_id,\n \"parents\": parents,\n \"attributes\": attrs,\n }\n return self._put_resource(resource_id, body)", "docstring": "Will add the given resource with a given identifier and attribute\n dictionary.\n\n example/\n\n add_resource('/asset/12', {'id': 12, 'manufacturer': 'GE'})" }, { "code": "def register(scraper):\n\tglobal scrapers\n\tlanguage = scraper('').language\n\tif not language:\n\t\traise Exception('No language specified for your scraper.')\n\tif scrapers.has_key(language):\n\t\tscrapers[language].append(scraper)\n\telse:\n\t\tscrapers[language] = [scraper]", "docstring": "Registers a scraper to make it available for the generic scraping interface." }, { "code": "def _red_listing_validation(key, listing):\n if listing:\n try:\n jsonschema.validate(listing, cwl_job_listing_schema)\n except ValidationError as e:\n raise RedValidationError('REDFILE listing of input \"{}\" does not comply with jsonschema: {}'\n .format(key, e.context))", "docstring": "Raises an RedValidationError, if the given listing does not comply with cwl_job_listing_schema.\n If listing is None or an empty list, no exception is thrown.\n\n :param key: The input key to build an error message if needed.\n :param listing: The listing to validate\n :raise RedValidationError: If the given listing does not comply with cwl_job_listing_schema" }, { "code": "def get_ilwdchar_class(tbl_name, col_name, namespace = globals()):\n\tkey = (str(tbl_name), str(col_name))\n\tcls_name = \"%s_%s_class\" % key\n\tassert cls_name != \"get_ilwdchar_class\"\n\ttry:\n\t\treturn namespace[cls_name]\n\texcept KeyError:\n\t\tpass\n\tclass new_class(_ilwd.ilwdchar):\n\t\t__slots__ = ()\n\t\ttable_name, column_name = key\n\t\tindex_offset = len(\"%s:%s:\" % key)\n\tnew_class.__name__ = cls_name\n\tnamespace[cls_name] = new_class\n\tcopy_reg.pickle(new_class, lambda x: (ilwdchar, (unicode(x),)))\n\treturn new_class", "docstring": "Searches this module's namespace for a subclass of _ilwd.ilwdchar\n\twhose table_name and column_name attributes match those provided.\n\tIf a matching subclass is found it is returned; otherwise a new\n\tclass is defined, added to this module's namespace, and returned.\n\n\tExample:\n\n\t>>> process_id = get_ilwdchar_class(\"process\", \"process_id\")\n\t>>> x = process_id(10)\n\t>>> str(type(x))\n\t\"\"\n\t>>> str(x)\n\t'process:process_id:10'\n\n\tRetrieving and storing the class provides a convenient mechanism\n\tfor quickly constructing new ID objects.\n\n\tExample:\n\n\t>>> for i in range(10):\n\t...\tprint str(process_id(i))\n\t...\n\tprocess:process_id:0\n\tprocess:process_id:1\n\tprocess:process_id:2\n\tprocess:process_id:3\n\tprocess:process_id:4\n\tprocess:process_id:5\n\tprocess:process_id:6\n\tprocess:process_id:7\n\tprocess:process_id:8\n\tprocess:process_id:9" }, { "code": "def _infer_decorator_callchain(node):\n if not isinstance(node, FunctionDef):\n return None\n if not node.parent:\n return None\n try:\n result = next(node.infer_call_result(node.parent))\n except exceptions.InferenceError:\n return None\n if isinstance(result, bases.Instance):\n result = result._proxied\n if isinstance(result, ClassDef):\n if result.is_subtype_of(\"%s.classmethod\" % BUILTINS):\n return \"classmethod\"\n if result.is_subtype_of(\"%s.staticmethod\" % BUILTINS):\n return \"staticmethod\"\n return None", "docstring": "Detect decorator call chaining and see if the end result is a\n static or a classmethod." }, { "code": "def all(cls):\n account = cls.info()\n creditusage = cls.creditusage()\n if not creditusage:\n return account\n left = account['credits'] / creditusage\n years, hours = divmod(left, 365 * 24)\n months, hours = divmod(hours, 31 * 24)\n days, hours = divmod(hours, 24)\n account.update({'credit_usage': creditusage,\n 'left': (years, months, days, hours)})\n return account", "docstring": "Get all informations about this account" }, { "code": "def _compute_site_scaling(self, C, vs30):\n site_term = np.zeros(len(vs30), dtype=float)\n site_term[vs30 < 760.0] = C[\"e\"]\n return site_term", "docstring": "Returns the site scaling term as a simple coefficient" }, { "code": "def fit(self, data, labels, **kwargs):\n self._som.train(data, **kwargs)\n bmus, q_error, t_error = self.bmus_with_errors(data)\n self.quant_error = q_error\n self.topog_error = t_error\n self._bmus = bmus\n self._calibrate(data, labels)", "docstring": "\\\n Training the SOM on the the data and calibrate itself.\n\n After the training, `self.quant_error` and `self.topog_error` are \n respectively set.\n\n :param data: sparse input matrix (ideal dtype is `numpy.float32`)\n :type data: :class:`scipy.sparse.csr_matrix`\n :param labels: the labels associated with data\n :type labels: iterable\n :param \\**kwargs: optional parameters for :meth:`train`" }, { "code": "def handle(self, handler_name, request, suffix=''):\n return self.runtime.handle(self, handler_name, request, suffix)", "docstring": "Handle `request` with this block's runtime." }, { "code": "def should_obfuscate_filename(self):\n for pattern in self.args.hide_file_names:\n try:\n compiled = re.compile(pattern, re.IGNORECASE)\n if compiled.search(self.entity):\n return True\n except re.error as ex:\n log.warning(u('Regex error ({msg}) for hide_file_names pattern: {pattern}').format(\n msg=u(ex),\n pattern=u(pattern),\n ))\n return False", "docstring": "Returns True if hide_file_names is true or the entity file path\n matches one in the list of obfuscated file paths." }, { "code": "async def _make_connection(self):\n return await aioredis.create_redis(\n 'redis://{}:{}'.format(\n self._redis_params.get('host', 'localhost'),\n self._redis_params.get('port', 6379)\n ),\n db=int(self._redis_params.get('db', 1))\n )", "docstring": "Construct a connection to Redis." }, { "code": "def sg_seek_streamer(self, index, force, value):\n force = bool(force)\n err = self.sensor_graph.acknowledge_streamer(index, value, force)\n return [err]", "docstring": "Ackowledge a streamer." }, { "code": "def _bind_method(self, name, unconditionally=False):\n exists = self.run_func('exist', name)['result'] in [2, 3, 5]\n if not unconditionally and not exists:\n raise AttributeError(\"'Matlab' object has no attribute '%s'\" % name)\n method_instance = MatlabFunction(weakref.ref(self), name)\n method_instance.__name__ = name\n if sys.version.startswith('3'):\n method = types.MethodType(method_instance, weakref.ref(self))\n else:\n method = types.MethodType(method_instance, weakref.ref(self),\n _Session)\n setattr(self, name, method)\n return getattr(self, name)", "docstring": "Generate a Matlab function and bind it to the instance\n\n This is where the magic happens. When an unknown attribute of the\n Matlab class is requested, it is assumed to be a call to a\n Matlab function, and is generated and bound to the instance.\n\n This works because getattr() falls back to __getattr__ only if no\n attributes of the requested name can be found through normal\n routes (__getattribute__, __dict__, class tree).\n\n bind_method first checks whether the requested name is a callable\n Matlab function before generating a binding.\n\n Parameters\n ----------\n name : str\n The name of the Matlab function to call\n e.g. 'sqrt', 'sum', 'svd', etc\n unconditionally : bool, optional\n Bind the method without performing\n checks. Used to bootstrap methods that are required and\n know to exist\n\n Returns\n -------\n MatlabFunction\n A reference to a newly bound MatlabFunction instance if the\n requested name is determined to be a callable function\n\n Raises\n ------\n AttributeError: if the requested name is not a callable\n Matlab function" }, { "code": "def load_trajectory(name, format=None, skip=1):\n df = datafile(name, format=format)\n ret = {}\n t, coords = df.read('trajectory', skip=skip)\n boxes = df.read('boxes')\n ret['t'] = t\n ret['coords'] = coords\n ret['boxes'] = boxes\n return ret", "docstring": "Read a trajectory from a file.\n\n .. seealso:: `chemlab.io.datafile`" }, { "code": "def _serve_forever_wrapper(self, _srv, poll_interval=0.1):\n self.logger.info('Opening tunnel: {0} <> {1}'.format(\n address_to_str(_srv.local_address),\n address_to_str(_srv.remote_address))\n )\n _srv.serve_forever(poll_interval)\n self.logger.info('Tunnel: {0} <> {1} released'.format(\n address_to_str(_srv.local_address),\n address_to_str(_srv.remote_address))\n )", "docstring": "Wrapper for the server created for a SSH forward" }, { "code": "def ctrl_transfer(self,\n dev_handle,\n bmRequestType,\n bRequest,\n wValue,\n wIndex,\n data,\n timeout):\n r\n _not_implemented(self.ctrl_transfer)", "docstring": "r\"\"\"Perform a control transfer on the endpoint 0.\n\n The direction of the transfer is inferred from the bmRequestType\n field of the setup packet.\n\n dev_handle is the value returned by the open_device() method.\n bmRequestType, bRequest, wValue and wIndex are the same fields\n of the setup packet. data is an array object, for OUT requests\n it contains the bytes to transmit in the data stage and for\n IN requests it is the buffer to hold the data read. The number\n of bytes requested to transmit or receive is equal to the length\n of the array times the data.itemsize field. The timeout parameter\n specifies a time limit to the operation in miliseconds.\n\n Return the number of bytes written (for OUT transfers) or the data\n read (for IN transfers), as an array.array object." }, { "code": "def get_subscriptions(self, limit=100, offset=0, params={}):\n url = self.SUBSCRIPTIONS_URL + \"?limit=%s&offset=%s\" % (limit, offset)\n for key, value in params.items():\n if key is 'ids':\n value = \",\".join(value)\n url += '&%s=%s' % (key, value)\n connection = Connection(self.token)\n connection.set_url(self.production, url)\n return connection.get_request()", "docstring": "Get all subscriptions" }, { "code": "def read_hdf5_array(source, path=None, array_type=Array):\n dataset = io_hdf5.find_dataset(source, path=path)\n attrs = dict(dataset.attrs)\n try:\n attrs['channel'] = _unpickle_channel(attrs['channel'])\n except KeyError:\n pass\n for key in attrs:\n if isinstance(attrs[key], bytes):\n attrs[key] = attrs[key].decode('utf-8')\n return array_type(dataset[()], **attrs)", "docstring": "Read an `Array` from the given HDF5 object\n\n Parameters\n ----------\n source : `str`, :class:`h5py.HLObject`\n path to HDF file on disk, or open `h5py.HLObject`.\n\n path : `str`\n path in HDF hierarchy of dataset.\n\n array_type : `type`\n desired return type" }, { "code": "def request_done(self, request):\n if self._requests is None:\n return\n assert request == self._requests[0], \"Unexpected request done\"\n del self._requests[0]\n if request.persistent:\n if self._requests:\n self._requests[0].activate()\n else:\n self.transport.loseConnection()", "docstring": "Called by the active request when it is done writing" }, { "code": "def symbolize(flt: float) -> sympy.Symbol:\n try:\n ratio = rationalize(flt)\n res = sympy.simplify(ratio)\n except ValueError:\n ratio = rationalize(flt/np.pi)\n res = sympy.simplify(ratio) * sympy.pi\n return res", "docstring": "Attempt to convert a real number into a simpler symbolic\n representation.\n\n Returns:\n A sympy Symbol. (Convert to string with str(sym) or to latex with\n sympy.latex(sym)\n Raises:\n ValueError: If cannot simplify float" }, { "code": "def start_wsgi_server(port, addr='', registry=REGISTRY):\n app = make_wsgi_app(registry)\n httpd = make_server(addr, port, app, handler_class=_SilentHandler)\n t = threading.Thread(target=httpd.serve_forever)\n t.daemon = True\n t.start()", "docstring": "Starts a WSGI server for prometheus metrics as a daemon thread." }, { "code": "def decode_html(html):\n if isinstance(html, unicode):\n return html\n match = CHARSET_META_TAG_PATTERN.search(html)\n if match:\n declared_encoding = match.group(1).decode(\"ASCII\")\n with ignored(LookupError):\n return html.decode(declared_encoding, \"ignore\")\n with ignored(UnicodeDecodeError):\n return html.decode(\"utf8\")\n text = TAG_MARK_PATTERN.sub(to_bytes(\" \"), html)\n diff = text.decode(\"utf8\", \"ignore\").encode(\"utf8\")\n sizes = len(diff), len(text)\n if abs(len(text) - len(diff)) < max(sizes) * 0.01:\n return html.decode(\"utf8\", \"ignore\")\n encoding = \"utf8\"\n encoding_detector = chardet.detect(text)\n if encoding_detector[\"encoding\"]:\n encoding = encoding_detector[\"encoding\"]\n return html.decode(encoding, \"ignore\")", "docstring": "Converts bytes stream containing an HTML page into Unicode.\n Tries to guess character encoding from meta tag of by \"chardet\" library." }, { "code": "def consecutive_ones_property(sets, universe=None):\n if universe is None:\n universe = set()\n for S in sets:\n universe |= set(S)\n tree = PQ_tree(universe)\n try:\n for S in sets:\n tree.reduce(S)\n return tree.border()\n except IsNotC1P:\n return None", "docstring": "Check the consecutive ones property.\n\n :param list sets: is a list of subsets of the ground set.\n :param groundset: is the set of all elements,\n by default it is the union of the given sets\n :returns: returns a list of the ordered ground set where\n every given set is consecutive,\n or None if there is no solution.\n :complexity: O(len(groundset) * len(sets))\n :disclaimer: an optimal implementation would have complexity\n O(len(groundset) + len(sets) + sum(map(len,sets))),\n and there are more recent easier algorithms for this problem." }, { "code": "def translate_labels(val):\n if not isinstance(val, dict):\n if not isinstance(val, list):\n val = split(val)\n new_val = {}\n for item in val:\n if isinstance(item, dict):\n if len(item) != 1:\n raise SaltInvocationError('Invalid label(s)')\n key = next(iter(item))\n val = item[key]\n else:\n try:\n key, val = split(item, '=', 1)\n except ValueError:\n key = item\n val = ''\n if not isinstance(key, six.string_types):\n key = six.text_type(key)\n if not isinstance(val, six.string_types):\n val = six.text_type(val)\n new_val[key] = val\n val = new_val\n return val", "docstring": "Can either be a list of label names, or a list of name=value pairs. The API\n can accept either a list of label names or a dictionary mapping names to\n values, so the value we translate will be different depending on the input." }, { "code": "def filter(args):\n p = OptionParser(filter.__doc__)\n p.add_option(\"--less\", default=False, action=\"store_true\",\n help=\"filter the sizes < certain cutoff [default: >=]\")\n p.set_outfile()\n opts, args = p.parse_args(args)\n if len(args) != 2:\n sys.exit(not p.print_help())\n fastafile, cutoff = args\n try:\n cutoff = int(cutoff)\n except ValueError:\n sys.exit(not p.print_help())\n f = Fasta(fastafile, lazy=True)\n fw = must_open(opts.outfile, \"w\")\n for name, rec in f.iteritems_ordered():\n if opts.less and len(rec) >= cutoff:\n continue\n if (not opts.less) and len(rec) < cutoff:\n continue\n SeqIO.write([rec], fw, \"fasta\")\n fw.flush()\n return fw.name", "docstring": "%prog filter fastafile 100\n\n Filter the FASTA file to contain records with size >= or <= certain cutoff." }, { "code": "def get_as_nullable_parameters(self, key):\n value = self.get_as_nullable_map(key)\n return Parameters(value) if value != None else None", "docstring": "Converts map element into an Parameters or returns null if conversion is not possible.\n\n :param key: a key of element to get.\n\n :return: Parameters value of the element or null if conversion is not supported." }, { "code": "def blast(args):\n p = OptionParser(blast.__doc__)\n opts, args = p.parse_args(args)\n if len(args) != 1:\n sys.exit(not p.print_help())\n btabfile, = args\n btab = Btab(btabfile)\n for b in btab:\n print(b.blastline)", "docstring": "%prog blast btabfile\n\n Convert to BLAST -m8 format." }, { "code": "def to_mongo(self):\n d = copy.copy(self._fields)\n for k, v in self._slices.items():\n d[k] = {'$slice': v}\n return d", "docstring": "Translate projection to MongoDB query form.\n\n :return: Dictionary to put into a MongoDB JSON query\n :rtype: dict" }, { "code": "def isfile(self, path, follow_symlinks=True):\n return self._is_of_type(path, S_IFREG, follow_symlinks)", "docstring": "Determine if path identifies a regular file.\n\n Args:\n path: Path to filesystem object.\n\n Returns:\n `True` if path points to a regular file (following symlinks).\n\n Raises:\n TypeError: if path is None." }, { "code": "def fetch(self, raise_exc=True):\n self._request(GET, raise_exc=raise_exc)\n self.fetched = True\n return self.state.copy()", "docstring": "Performs a GET request to the uri of this navigator" }, { "code": "def update_snapshot_schedule(cls, cluster_id_label, s3_location=None, frequency_unit=None, frequency_num=None, status=None):\n conn = Qubole.agent(version=Cluster.api_version)\n data = {}\n if s3_location is not None:\n data[\"s3_location\"] = s3_location\n if frequency_unit is not None:\n data[\"frequency_unit\"] = frequency_unit\n if frequency_num is not None:\n data[\"frequency_num\"] = frequency_num\n if status is not None:\n data[\"status\"] = status\n return conn.put(cls.element_path(cluster_id_label) + \"/snapshot_schedule\", data)", "docstring": "Update for snapshot schedule" }, { "code": "def migrate(belstr: str) -> str:\n bo.ast = bel.lang.partialparse.get_ast_obj(belstr, \"2.0.0\")\n return migrate_ast(bo.ast).to_string()", "docstring": "Migrate BEL 1 to 2.0.0\n\n Args:\n bel: BEL 1\n\n Returns:\n bel: BEL 2" }, { "code": "def atanh(x):\n if isinstance(x, UncertainFunction):\n mcpts = np.arctanh(x._mcpts)\n return UncertainFunction(mcpts)\n else:\n return np.arctanh(x)", "docstring": "Inverse hyperbolic tangent" }, { "code": "def prob(self, pw):\n tokens = self.pcfgtokensofw(pw)\n S, tokens = tokens[0], tokens[1:]\n l = len(tokens)\n assert l % 2 == 0, \"Expecting even number of tokens!. got {}\".format(tokens)\n p = float(self._T.get(S, 0.0)) / sum(v for k, v in self._T.items('__S__'))\n for i, t in enumerate(tokens):\n f = self._T.get(t, 0.0)\n if f == 0:\n return 0.0\n if i < l / 2:\n p /= f\n else:\n p *= f\n return p", "docstring": "Return the probability of pw under the Weir PCFG model.\n P[{S -> L2D1Y3, L2 -> 'ab', D1 -> '1', Y3 -> '!@#'}]" }, { "code": "def connect(self, protocolFactory):\n deferred = self._startProcess()\n deferred.addCallback(self._connectRelay, protocolFactory)\n deferred.addCallback(self._startRelay)\n return deferred", "docstring": "Starts a process and connect a protocol to it." }, { "code": "def absolute_magnitude(distance_modulus,g,r,prob=None):\n V = g - 0.487*(g - r) - 0.0249\n flux = np.sum(10**(-(V-distance_modulus)/2.5))\n Mv = -2.5*np.log10(flux)\n return Mv", "docstring": "Calculate the absolute magnitude from a set of bands" }, { "code": "def _dict_to_obj(self, d):\n if JsonEncoder.TYPE_ID not in d:\n return d\n type_name = d.pop(JsonEncoder.TYPE_ID)\n if type_name in _TYPE_NAME_TO_DECODER:\n decoder = _TYPE_NAME_TO_DECODER[type_name]\n return decoder(d)\n else:\n raise TypeError(\"Invalid type %s.\", type_name)", "docstring": "Converts a dictionary of json object to a Python object." }, { "code": "def devserver_cmd(argv=sys.argv[1:]):\n arguments = docopt(devserver_cmd.__doc__, argv=argv)\n initialize_config()\n app.run(\n host=arguments['--host'],\n port=int(arguments['--port']),\n debug=int(arguments['--debug']),\n )", "docstring": "\\\nServe the web API for development.\n\nUsage:\n pld-devserver [options]\n\nOptions:\n -h --help Show this screen.\n\n --host= The host to use [default: 0.0.0.0].\n\n --port= The port to use [default: 5000].\n\n --debug= Whether or not to use debug mode [default: 0]." }, { "code": "def canonical_new_peer_list( self, peers_to_add ):\n new_peers = list(set(self.new_peers + peers_to_add))\n random.shuffle( new_peers )\n tmp = []\n for peer in new_peers:\n tmp.append( self.canonical_peer(peer) )\n new_peers = tmp\n if self.my_hostport in new_peers:\n new_peers.remove(self.my_hostport)\n return new_peers", "docstring": "Make a list of canonical new peers, using the\n self.new_peers and the given peers to add\n\n Return a shuffled list of canonicalized host:port\n strings." }, { "code": "def qteUpdateLogSlot(self):\n log = self.logHandler.fetch(start=self.qteLogCnt)\n self.qteLogCnt += len(log)\n if not len(log):\n return\n log_pruned = []\n last_entry = log[0]\n num_rep = -1\n for cur_entry in log:\n if last_entry.msg == cur_entry.msg:\n num_rep += 1\n else:\n log_pruned.append([last_entry, num_rep])\n num_rep = 0\n last_entry = cur_entry\n log_pruned.append([cur_entry, num_rep])\n log_formatted = \"\"\n for cur_entry in log_pruned:\n log_formatted += self.qteFormatMessage(cur_entry[0], cur_entry[1])\n log_formatted + '\\n'\n self.qteText.insertHtml(log_formatted)\n self.qteMoveToEndOfBuffer()\n if self.qteAutoActivate:\n self.qteAutoActivate = False\n self.qteMain.qteMakeAppletActive(self)", "docstring": "Fetch and display the next batch of log messages." }, { "code": "def add_alias(agent, prefix, alias):\n return _broadcast(agent, AddMappingManager, RecordType.record_CNAME,\n prefix, alias)", "docstring": "Adds an alias mapping with a contract.\n It has high latency but gives some kind of guarantee." }, { "code": "def info_hash_base32(self):\n if getattr(self, '_data', None):\n return b32encode(sha1(bencode(self._data['info'])).digest())\n else:\n raise exceptions.TorrentNotGeneratedException", "docstring": "Returns the base32 info hash of the torrent. Useful for generating\n magnet links.\n\n .. note:: ``generate()`` must be called first." }, { "code": "def write_content(self, content, destination):\n directory = os.path.dirname(destination)\n if directory and not os.path.exists(directory):\n os.makedirs(directory)\n with io.open(destination, 'w', encoding='utf-8') as f:\n f.write(content)\n return destination", "docstring": "Write given content to destination path.\n\n It will create needed directory structure first if it contain some\n directories that does not allready exists.\n\n Args:\n content (str): Content to write to target file.\n destination (str): Destination path for target file.\n\n Returns:\n str: Path where target file has been written." }, { "code": "def all_errors(self, joiner=\"; \"):\n parts = []\n for pname, errs in self.errors.items():\n for err in errs:\n parts.append(\"{0}: {1}\".format(pname, err))\n return joiner.join(parts)", "docstring": "Returns a string representation of all errors recorded for the instance." }, { "code": "def safe_type(self, data, tree):\n if not isinstance(data, list):\n name = self.__class__.__name__\n msg = \"did not pass validation against callable: %s\" % name\n reason = 'expected a list but got %s' % safe_repr(data)\n raise Invalid(self.schema, tree, reason=reason, pair='value', msg=msg)", "docstring": "Make sure that the incoming data complies with the class type we\n are expecting it to be. In this case, classes that inherit from this\n base class expect data to be of type ``list``." }, { "code": "def read_git_commit_timestamp_for_file(filepath, repo_path=None):\n repo = git.repo.base.Repo(path=repo_path, search_parent_directories=True)\n head_commit = repo.head.commit\n for commit in head_commit.iter_parents(filepath):\n return commit.committed_datetime\n raise IOError('File {} not found'.format(filepath))", "docstring": "Obtain the timestamp for the most recent commit to a given file in a\n Git repository.\n\n Parameters\n ----------\n filepath : `str`\n Repository-relative path for a file.\n repo_path : `str`, optional\n Path to the Git repository. Leave as `None` to use the current working\n directory.\n\n Returns\n -------\n commit_timestamp : `datetime.datetime`\n The datetime of a the most recent commit to the given file.\n\n Raises\n ------\n IOError\n Raised if the ``filepath`` does not exist in the Git repository." }, { "code": "def compute_K_analytical(self, spacing):\n assert isinstance(spacing, Number)\n K = geometric_factors.compute_K_analytical(self.data, spacing)\n self.data = geometric_factors.apply_K(self.data, K)\n fix_sign_with_K(self.data)", "docstring": "Assuming an equal electrode spacing, compute the K-factor over a\n homogeneous half-space.\n\n For more complex grids, please refer to the module:\n reda.utils.geometric_factors\n\n Parameters\n ----------\n spacing: float\n Electrode spacing" }, { "code": "def sync_files(self, dataset_key):\n try:\n self._datasets_api.sync(*(parse_dataset_key(dataset_key)))\n except _swagger.rest.ApiException as e:\n raise RestApiError(cause=e)", "docstring": "Trigger synchronization process to update all dataset files linked to\n source URLs.\n\n :param dataset_key: Dataset identifier, in the form of owner/id\n :type dataset_key: str\n :raises RestApiException: If a server error occurs\n\n Examples\n --------\n >>> import datadotworld as dw\n >>> api_client = dw.api_client()\n >>> api_client.sync_files('username/test-dataset') # doctest: +SKIP" }, { "code": "def detect(self, text):\n t = text.encode(\"utf-8\")\n reliable, index, top_3_choices = cld2.detect(t, bestEffort=False)\n if not reliable:\n self.reliable = False\n reliable, index, top_3_choices = cld2.detect(t, bestEffort=True)\n if not self.quiet:\n if not reliable:\n raise UnknownLanguage(\"Try passing a longer snippet of text\")\n else:\n logger.warning(\"Detector is not able to detect the language reliably.\")\n self.languages = [Language(x) for x in top_3_choices]\n self.language = self.languages[0]\n return self.language", "docstring": "Decide which language is used to write the text.\n\n The method tries first to detect the language with high reliability. If\n that is not possible, the method switches to best effort strategy.\n\n\n Args:\n text (string): A snippet of text, the longer it is the more reliable we\n can detect the language used to write the text." }, { "code": "def keep_only_update_source_in_field(field, root, head, update):\n update_sources = {source.lower() for source in get_value(thaw(update), '.'.join([field, 'source']), [])}\n if len(update_sources) != 1:\n return root, head, update\n source = update_sources.pop()\n if field in root:\n root = root.set(field, remove_elements_with_source(source, root[field]))\n if field in head:\n head = head.set(field, remove_elements_with_source(source, head[field]))\n return root, head, update", "docstring": "Remove elements from root and head where ``source`` matches the update.\n\n This is useful if the update needs to overwrite all elements with the same\n source.\n\n .. note::\n If the update doesn't contain exactly one source in ``field``, the\n records are returned with no modifications.\n\n Args:\n field (str): the field to filter out.\n root (pmap): the root record, whose ``field`` will be cleaned.\n head (pmap): the head record, whose ``field`` will be cleaned.\n update (pmap): the update record, from which the ``source`` is read.\n\n Returns:\n tuple: ``(root, head, update)`` with some elements filtered out from\n ``root`` and ``head``." }, { "code": "def results(self, *args, **kwargs):\n def worker():\n kwargs['page'] = 1\n while True:\n response = self.client(*args, **kwargs)\n if isinstance(response, list):\n yield response\n break\n elif _is_page(response):\n yield response['results']\n if response['next']:\n kwargs['page'] += 1\n else:\n break\n else:\n raise NoResultsError(response)\n return itertools.chain.from_iterable(worker())", "docstring": "Return an iterator with all pages of data.\n Return NoResultsError with response if there is unexpected data." }, { "code": "def ContainsNone(self, *values):\n self._awql = self._CreateMultipleValuesCondition(values, 'CONTAINS_NONE')\n return self._query_builder", "docstring": "Sets the type of the WHERE clause as \"contains none\".\n\n Args:\n *values: The values to be used in the WHERE condition.\n\n Returns:\n The query builder that this WHERE builder links to." }, { "code": "def get_module_attr(module_filename, module_attr, namespace=None):\n if namespace is None:\n namespace = {}\n module_filename = os.path.abspath(module_filename)\n namespace['__file__'] = module_filename\n module_dir = os.path.dirname(module_filename)\n old_cwd = os.getcwd()\n old_sys_path = sys.path[:]\n try:\n os.chdir(module_dir)\n sys.path.append(module_dir)\n with open(module_filename, 'r') as mf:\n exec(compile(mf.read(), module_filename, 'exec'), namespace)\n return namespace[module_attr]\n finally:\n os.chdir(old_cwd)\n sys.path = old_sys_path", "docstring": "Get an attribute from a module.\n\n This uses exec to load the module with a private namespace, and then\n plucks and returns the given attribute from that module's namespace.\n\n Note that, while this method doesn't have any explicit unit tests, it is\n tested implicitly by the doctor's own documentation. The Sphinx\n build process will fail to generate docs if this does not work.\n\n :param str module_filename: Path to the module to execute (e.g.\n \"../src/app.py\").\n :param str module_attr: Attribute to pluck from the module's namespace.\n (e.g. \"app\").\n :param dict namespace: Optional namespace. If one is not passed, an empty\n dict will be used instead. Note that this function mutates the passed\n namespace, so you can inspect a passed dict after calling this method\n to see how the module changed it.\n :returns: The attribute from the module.\n :raises KeyError: if the module doesn't have the given attribute." }, { "code": "def __identify_user(self, username, csrf):\n data = {\n \"username\": username,\n \"csrf\": csrf,\n \"apiClient\": \"WEB\",\n \"bindDevice\": \"false\",\n \"skipLinkAccount\": \"false\",\n \"redirectTo\": \"\",\n \"skipFirstUse\": \"\",\n \"referrerId\": \"\",\n }\n r = self.post(\"/login/identifyUser\", data)\n if r.status_code == requests.codes.ok:\n result = r.json()\n new_csrf = getSpHeaderValue(result, CSRF_KEY)\n auth_level = getSpHeaderValue(result, AUTH_LEVEL_KEY)\n return (new_csrf, auth_level)\n return (None, None)", "docstring": "Returns reusable CSRF code and the auth level as a 2-tuple" }, { "code": "def _import_plugins(self):\n if self.detected:\n return\n self.scanLock.acquire()\n if self.detected:\n return\n try:\n import_apps_submodule(\"content_plugins\")\n self.detected = True\n finally:\n self.scanLock.release()", "docstring": "Internal function, ensure all plugin packages are imported." }, { "code": "def _vertex_net_cost(vertex, v2n, placements, has_wrap_around_links, machine):\n total_cost = 0.0\n for net in v2n[vertex]:\n total_cost += _net_cost(net, placements, has_wrap_around_links,\n machine)\n return total_cost", "docstring": "Get the total cost of the nets connected to the given vertex.\n\n Parameters\n ----------\n vertex\n The vertex whose nets we're interested in.\n v2n : {vertex: [:py:class:`rig.netlist.Net`, ...], ...}\n placements : {vertex: (x, y), ...}\n has_wrap_around_links : bool\n machine : :py:class:`rig.place_and_route.Machine`\n\n Returns\n -------\n float" }, { "code": "def abort_now ():\n if os.name == 'posix':\n import signal\n os.kill(os.getpid(), signal.SIGTERM)\n time.sleep(1)\n os.kill(os.getpid(), signal.SIGKILL)\n elif os.name == 'nt':\n os.abort()\n else:\n os._exit(3)", "docstring": "Force exit of current process without cleanup." }, { "code": "def warning(message):\n\timport lltk.config as config\n\tif config['warnings']:\n\t\ttry:\n\t\t\tfrom termcolor import colored\n\t\texcept ImportError:\n\t\t\tdef colored(message, color):\n\t\t\t\treturn message\n\t\tprint colored('@LLTK-WARNING: ' + message, 'red')", "docstring": "Prints a message if warning mode is enabled." }, { "code": "def search(self,\n id_list: List,\n negated_classes: List,\n limit: Optional[int],\n method: Optional) -> List[SimResult]:\n raise NotImplementedError", "docstring": "Given an input list of classes or individuals,\n provides a ranking of similar profiles" }, { "code": "def mimf_ferrario(mi):\n mf=-0.00012336*mi**6+0.003160*mi**5-0.02960*mi**4+\\\n 0.12350*mi**3-0.21550*mi**2+0.19022*mi+0.46575\n return mf", "docstring": "Curvature MiMf from Ferrario etal. 2005MNRAS.361.1131." }, { "code": "def GetOptions(self):\n if self._options:\n return self._options\n from google.protobuf import descriptor_pb2\n try:\n options_class = getattr(descriptor_pb2, self._options_class_name)\n except AttributeError:\n raise RuntimeError('Unknown options class name %s!' %\n (self._options_class_name))\n self._options = options_class()\n return self._options", "docstring": "Retrieves descriptor options.\n\n This method returns the options set or creates the default options for the\n descriptor." }, { "code": "def actualize_source_type (self, sources, prop_set):\n assert is_iterable_typed(sources, VirtualTarget)\n assert isinstance(prop_set, property_set.PropertySet)\n result = []\n for i in sources:\n scanner = None\n if i.type ():\n scanner = b2.build.type.get_scanner (i.type (), prop_set)\n r = i.actualize (scanner)\n result.append (r)\n return result", "docstring": "Helper for 'actualize_sources'.\n For each passed source, actualizes it with the appropriate scanner.\n Returns the actualized virtual targets." }, { "code": "def patch_wave_header(body):\n length = len(body)\n padded = length + length % 2\n total = WAVE_HEADER_LENGTH + padded\n header = copy.copy(WAVE_HEADER)\n header[4:8] = bytearray(struct.pack('" }, { "code": "def get_installed_extension(name,\n user=None,\n host=None,\n port=None,\n maintenance_db=None,\n password=None,\n runas=None):\n return installed_extensions(user=user,\n host=host,\n port=port,\n maintenance_db=maintenance_db,\n password=password,\n runas=runas).get(name, None)", "docstring": "Get info about an installed postgresql extension\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' postgres.get_installed_extension plpgsql" }, { "code": "def resource_filename(package_or_requirement, resource_name):\n if pkg_resources.resource_exists(package_or_requirement, resource_name):\n return pkg_resources.resource_filename(package_or_requirement, resource_name)\n path = _search_in_share_folders(package_or_requirement, resource_name)\n if path:\n return path\n raise RuntimeError(\"Resource {} not found in {}\".format(package_or_requirement, resource_name))", "docstring": "Similar to pkg_resources.resource_filename but if the resource it not found via pkg_resources\n it also looks in a predefined list of paths in order to find the resource\n\n :param package_or_requirement: the module in which the resource resides\n :param resource_name: the name of the resource\n :return: the path to the resource\n :rtype: str" }, { "code": "def _CreateDynamicDisplayAdSettings(media_service, opener):\n image = _CreateImage(media_service, opener, 'https://goo.gl/dEvQeF')\n logo = {\n 'type': 'IMAGE',\n 'mediaId': image['mediaId'],\n 'xsi_type': 'Image'\n }\n dynamic_settings = {\n 'landscapeLogoImage': logo,\n 'pricePrefix': 'as low as',\n 'promoText': 'Free shipping!',\n 'xsi_type': 'DynamicSettings',\n }\n return dynamic_settings", "docstring": "Creates settings for dynamic display ad.\n\n Args:\n media_service: a SudsServiceProxy instance for AdWords's MediaService.\n opener: an OpenerDirector instance.\n\n Returns:\n The dynamic display ad settings." }, { "code": "def get_lib_from(search_directory, lib_extension='.so'):\n for root, dirs, files in walk(search_directory):\n for file in files:\n if file.endswith(lib_extension):\n print('get_lib_from: {}\\n\\t- {}'.format(\n search_directory, join(root, file)))\n return join(root, file)\n return None", "docstring": "Scan directories recursively until find any file with the given\n extension. The default extension to search is ``.so``." }, { "code": "def execute(self, sql, *args, **kwargs):\n try:\n self.cursor.execute(sql, *args)\n except self.sqlite3.InterfaceError, msg:\n raise self.sqlite3.InterfaceError(unicode(msg) + '\\nTry converting types or pickling.')\n rows = self.cursor.fetchall()\n self.__commit_if_necessary(kwargs)\n if None == self.cursor.description:\n return None\n else:\n colnames = [d[0].decode('utf-8') for d in self.cursor.description]\n rawdata = [OrderedDict(zip(colnames,row)) for row in rows]\n return rawdata", "docstring": "Run raw SQL on the database, and receive relaxing output.\n This is sort of the foundational method that most of the\n others build on." }, { "code": "def set_direct(self, address_value_dict):\n with self._lock:\n for address, value in address_value_dict.items():\n self._validate_write(address)\n if address in self._state:\n self._state[address].set_result(result=value)\n else:\n fut = _ContextFuture(address=address)\n self._state[address] = fut\n fut.set_result(result=value)", "docstring": "Called in the context manager's set method to either overwrite the\n value for an address, or create a new future and immediately set a\n value in the future.\n\n Args:\n address_value_dict (dict of str:bytes): The unique full addresses\n with bytes to set at that address.\n\n Raises:\n AuthorizationException" }, { "code": "def reorder(self, dst_order, arr, src_order=None):\n if dst_order is None:\n dst_order = self.viewer.rgb_order\n if src_order is None:\n src_order = self.rgb_order\n if src_order != dst_order:\n arr = trcalc.reorder_image(dst_order, arr, src_order)\n return arr", "docstring": "Reorder the output array to match that needed by the viewer." }, { "code": "def execute_once(self, string):\n for rule in self.rules:\n if rule[0] in string:\n pos = string.find(rule[0])\n self.last_rule = rule\n return string[:pos] + rule[1] + string[pos+len(rule[0]):]\n self.last_rule = None\n return string", "docstring": "Execute only one rule." }, { "code": "def exit(self):\n self.client.flush()\n self.client.close()\n super(Export, self).exit()", "docstring": "Close the Kafka export module." }, { "code": "def resolve(self, notes=None):\n self.set_status(self._redmine.ISSUE_STATUS_ID_RESOLVED, notes=notes)", "docstring": "Save all changes and resolve this issue" }, { "code": "def force_directed(self,defaultEdgeWeight=None,defaultNodeMass=None,\\\n\t\tdefaultSpringCoefficient=None,defaultSpringLength=None,EdgeAttribute=None,\\\n\t\tisDeterministic=None,maxWeightCutoff=None,minWeightCutoff=None,network=None,\\\n\t\tNodeAttribute=None,nodeList=None,numIterations=None,singlePartition=None,\\\n\t\tType=None,verbose=None):\n\t\tnetwork=check_network(self,network,verbose=verbose)\n\t\tPARAMS=set_param(['defaultEdgeWeight','defaultNodeMass','defaultSpringCoefficient',\\\n\t\t'defaultSpringLength','EdgeAttribute','isDeterministic','maxWeightCutoff',\\\n\t\t'minWeightCutoff','network','NodeAttribute','nodeList','numIterations',\\\n\t\t'singlePartition','Type'],[defaultEdgeWeight,defaultNodeMass,\\\n\t\tdefaultSpringCoefficient,defaultSpringLength,EdgeAttribute,isDeterministic,\\\n\t\tmaxWeightCutoff,minWeightCutoff,network,NodeAttribute,nodeList,numIterations,\\\n\t\tsinglePartition,Type])\n\t\tresponse=api(url=self.__url+\"/force-directed\", PARAMS=PARAMS, method=\"POST\", verbose=verbose)\n\t\treturn response", "docstring": "Execute the Prefuse Force Directed Layout on a network\n\n\t\t:param defaultEdgeWeight (string, optional): The default edge weight to con\n\t\t\tsider, default is 0.5\n\t\t:param defaultNodeMass (string, optional): Default Node Mass, in numeric va\n\t\t\tlue\n\t\t:param defaultSpringCoefficient (string, optional): Default Spring Coeffici\n\t\t\tent, in numeric value\n\t\t:param defaultSpringLength (string, optional): Default Spring Length, in nu\n\t\t\tmeric value\n\t\t:param EdgeAttribute (string, optional): The name of the edge column contai\n\t\t\tning numeric values that will be used as weights in the layout algor\n\t\t\tithm. Only columns containing numeric values are shown\n\t\t:param isDeterministic (string, optional): Force deterministic layouts (slo\n\t\t\twer); boolean values only, true or false; defaults to false\n\t\t:param maxWeightCutoff (string, optional): The maximum edge weight to consi\n\t\t\tder, default to the Double.MAX value\n\t\t:param minWeightCutoff (string, optional): The minimum edge weight to consi\n\t\t\tder, numeric values, default is 0\n\t\t:param network (string, optional): Specifies a network by name, or by SUID\n\t\t\tif the prefix SUID: is used. The keyword CURRENT, or a blank value c\n\t\t\tan also be used to specify the current network.\n\t\t:param NodeAttribute (string, optional): The name of the node column contai\n\t\t\tning numeric values that will be used as weights in the layout algor\n\t\t\tithm. Only columns containing numeric values are shown\n\t\t:param nodeList (string, optional): Specifies a list of nodes. The keywords\n\t\t\t\tall, selected, or unselected can be used to specify nodes by their\n\t\t\tselection state. The pattern COLUMN:VALUE sets this parameter to any\n\t\t\t\trows that contain the specified column value; if the COLUMN prefix\n\t\t\tis not used, the NAME column is matched by default. A list of COLUMN\n\t\t\t:VALUE pairs of the format COLUMN1:VALUE1,COLUMN2:VALUE2,... can be\n\t\t\tused to match multiple values.\n\t\t:param numIterations (string, optional): Number of Iterations, in numeric v\n\t\t\talue\n\t\t:param singlePartition (string, optional): Don't partition graph before lay\n\t\t\tout; boolean values only, true or false; defaults to false\n\t\t:param Type (string, optional): How to interpret weight values; must be one\n\t\t\t\tof Heuristic, -Log(value), 1 - normalized value and normalized valu\n\t\t\te. Defaults to Heuristic = ['Heuristic', '-Log(value)', '1 - normali\n\t\t\tzed value', 'normalized value']" }, { "code": "def multivariate_hypergeometric_expval(n, m):\n m = np.asarray(m, float)\n return n * (m / m.sum())", "docstring": "Expected value of multivariate hypergeometric distribution.\n\n Parameters:\n - `n` : Number of draws.\n - `m` : Number of items in each categoy." }, { "code": "def uninstall_hook(ctx):\n try:\n lint_config = ctx.obj[0]\n hooks.GitHookInstaller.uninstall_commit_msg_hook(lint_config)\n hook_path = hooks.GitHookInstaller.commit_msg_hook_path(lint_config)\n click.echo(u\"Successfully uninstalled gitlint commit-msg hook from {0}\".format(hook_path))\n ctx.exit(0)\n except hooks.GitHookInstallerError as e:\n click.echo(ustr(e), err=True)\n ctx.exit(GIT_CONTEXT_ERROR_CODE)", "docstring": "Uninstall gitlint commit-msg hook." }, { "code": "def bbox_flip(bbox, d, rows, cols):\n if d == 0:\n bbox = bbox_vflip(bbox, rows, cols)\n elif d == 1:\n bbox = bbox_hflip(bbox, rows, cols)\n elif d == -1:\n bbox = bbox_hflip(bbox, rows, cols)\n bbox = bbox_vflip(bbox, rows, cols)\n else:\n raise ValueError('Invalid d value {}. Valid values are -1, 0 and 1'.format(d))\n return bbox", "docstring": "Flip a bounding box either vertically, horizontally or both depending on the value of `d`.\n\n Raises:\n ValueError: if value of `d` is not -1, 0 or 1." }, { "code": "def time_estimate(self, duration, **kwargs):\n path = '%s/%s/time_estimate' % (self.manager.path, self.get_id())\n data = {'duration': duration}\n return self.manager.gitlab.http_post(path, post_data=data, **kwargs)", "docstring": "Set an estimated time of work for the object.\n\n Args:\n duration (str): Duration in human format (e.g. 3h30)\n **kwargs: Extra options to send to the server (e.g. sudo)\n\n Raises:\n GitlabAuthenticationError: If authentication is not correct\n GitlabTimeTrackingError: If the time tracking update cannot be done" }, { "code": "def compare_config(self):\n if self.ssh_connection is False:\n self._open_ssh()\n self.ssh_device.exit_config_mode()\n diff = self.ssh_device.send_command(\"show config diff\")\n return diff.strip()", "docstring": "Netmiko is being used to obtain config diffs because pan-python\n doesn't support the needed command." }, { "code": "def _init_grps(code2nt):\n seen = set()\n seen_add = seen.add\n groups = [nt.group for nt in code2nt.values()]\n return [g for g in groups if not (g in seen or seen_add(g))]", "docstring": "Return list of groups in same order as in code2nt" }, { "code": "def connect(self, signal, slot, transform=None, condition=None):\n if not signal in self.signals:\n print(\"WARNING: {0} is trying to connect a slot to an undefined signal: {1}\".format(self.__class__.__name__,\n str(signal)))\n return\n if not hasattr(self, 'connections'):\n self.connections = {}\n connection = self.connections.setdefault(signal, {})\n connection = connection.setdefault(condition, {})\n connection[slot] = transform", "docstring": "Defines a connection between this objects signal and another objects slot\n\n signal: the signal this class will emit, to cause the slot method to be called\n receiver: the object containing the slot method to be called\n slot: the slot method to call\n transform: an optional value override to pass into the slot method as the first variable\n condition: only call the slot if the value emitted matches the required value or calling required returns True" }, { "code": "def InternalExchange(self, cmd, payload_in):\n self.logger.debug('payload: ' + str(list(payload_in)))\n payload = bytearray()\n payload[:] = payload_in\n for _ in range(2):\n self.InternalSend(cmd, payload)\n ret_cmd, ret_payload = self.InternalRecv()\n if ret_cmd == UsbHidTransport.U2FHID_ERROR:\n if ret_payload == UsbHidTransport.ERR_CHANNEL_BUSY:\n time.sleep(0.5)\n continue\n raise errors.HidError('Device error: %d' % int(ret_payload[0]))\n elif ret_cmd != cmd:\n raise errors.HidError('Command mismatch!')\n return ret_payload\n raise errors.HidError('Device Busy. Please retry')", "docstring": "Sends and receives a message from the device." }, { "code": "def __learn_oneself(self):\r\n if not self.__parent_path or not self.__text_nodes:\r\n raise Exception(\"This error occurred because the step constructor\\\r\n had insufficient textnodes or it had empty string\\\r\n for its parent xpath\")\r\n self.tnodes_cnt = len(self.__text_nodes)\r\n self.ttl_strlen = sum([len(tnode) for tnode in self.__text_nodes])\r\n self.avg_strlen = self.ttl_strlen/self.tnodes_cnt", "docstring": "calculate cardinality, total and average string length" }, { "code": "async def open(self) -> '_BaseAgent':\n LOGGER.debug('_BaseAgent.open >>>')\n await self.wallet.open()\n LOGGER.debug('_BaseAgent.open <<<')\n return self", "docstring": "Context manager entry; open wallet.\n For use when keeping agent open across multiple calls.\n\n :return: current object" }, { "code": "def variance_larger_than_standard_deviation(x):\n y = np.var(x)\n return y > np.sqrt(y)", "docstring": "Boolean variable denoting if the variance of x is greater than its standard deviation. Is equal to variance of x\n being larger than 1\n\n :param x: the time series to calculate the feature of\n :type x: numpy.ndarray\n :return: the value of this feature\n :return type: bool" }, { "code": "def getPlaintextLen(self, ciphertext):\n completeCiphertextHeader = (len(ciphertext) >= 16)\n if completeCiphertextHeader is False:\n raise RecoverableDecryptionError('Incomplete ciphertext header.')\n ciphertext_header = ciphertext[:16]\n L = self._ecb_enc_K1.decrypt(ciphertext_header)\n padding_expected = '\\x00\\x00\\x00\\x00'\n padding_actual = L[-8:-4]\n validPadding = (padding_actual == padding_expected)\n if validPadding is False:\n raise UnrecoverableDecryptionError(\n 'Invalid padding: ' + padding_actual)\n message_length = fte.bit_ops.bytes_to_long(L[-8:])\n msgLenNonNegative = (message_length >= 0)\n if msgLenNonNegative is False:\n raise UnrecoverableDecryptionError('Negative message length.')\n return message_length", "docstring": "Given a ``ciphertext`` with a valid header, returns the length of the plaintext payload." }, { "code": "def _create_mappings(self, spec):\n ret = dict(zip(set(spec.fields), set(spec.fields)))\n ret.update(dict([(n, s.alias) for n, s in spec.fields.items() if s.alias]))\n return ret", "docstring": "Create property name map based on aliases." }, { "code": "def get_predecessors(self, head):\n frozen_head = frozenset(head)\n if frozen_head not in self._predecessors:\n return set()\n return set(self._predecessors[frozen_head].values())", "docstring": "Given a head set of nodes, get a list of edges of which the node set\n is the head of each edge.\n\n :param head: set of nodes that correspond to the heads of some\n (possibly empty) set of edges.\n :returns: set -- hyperedge_ids of the hyperedges that have head\n in the head." }, { "code": "def _remove_existing(self):\n for key in self._keys:\n if key in os.environ:\n LOG.debug('%r: removing old key %r', self, key)\n del os.environ[key]\n self._keys = []", "docstring": "When a change is detected, remove keys that existed in the old file." }, { "code": "def read_stack_frame(self, structure, offset = 0):\n aProcess = self.get_process()\n stackData = aProcess.read_structure(self.get_fp() + offset, structure)\n return tuple([ stackData.__getattribute__(name)\n for (name, type) in stackData._fields_ ])", "docstring": "Reads the stack frame of the thread.\n\n @type structure: ctypes.Structure\n @param structure: Structure of the stack frame.\n\n @type offset: int\n @param offset: Offset from the frame pointer to begin reading.\n The frame pointer is the same returned by the L{get_fp} method.\n\n @rtype: tuple\n @return: Tuple of elements read from the stack frame. The type of each\n element matches the types in the stack frame structure." }, { "code": "def save_callback(sender, instance, created, update_fields, **kwargs):\n if validate_instance(instance):\n status = 'add' if created is True else 'change'\n change = ''\n if status == 'change' and 'al_chl' in instance.__dict__.keys():\n changelog = instance.al_chl.modification\n change = ' to following changed: {}'.format(changelog)\n processor(status, sender, instance, update_fields, addition=change)", "docstring": "Save object & link logging entry" }, { "code": "def magnetic_lat(inc):\n rad = old_div(np.pi, 180.)\n paleo_lat = old_div(np.arctan(0.5 * np.tan(inc * rad)), rad)\n return paleo_lat", "docstring": "returns magnetic latitude from inclination" }, { "code": "def as_list(func):\n @wraps(func)\n def wrapper(*args, **kwargs):\n response = func(*args, **kwargs)\n if isinstance(response, Response):\n return response\n return as_json_list(\n response,\n **_serializable_params(request.args, check_groupby=True))\n return wrapper", "docstring": "A decorator used to return a JSON response of a list of model\n objects. It expects the decorated function to return a list\n of model instances. It then converts the instances to dicts\n and serializes them into a json response\n\n Examples:\n\n >>> @app.route('/api')\n ... @as_list\n ... def list_customers():\n ... return Customer.all()" }, { "code": "def pseudosample(x):\n BXs = []\n for k in range(len(x)):\n ind = random.randint(0, len(x) - 1)\n BXs.append(x[ind])\n return BXs", "docstring": "draw a bootstrap sample of x" }, { "code": "def repair_url(url):\n url = url.strip('\\n')\n if not re.match(r\"^http\", url):\n url = \"http://\" + url\n if \"?\" in url:\n url, _ = url.split('?')\n if not url.endswith(\"/\"):\n return url + \"/\"\n else :\n return url", "docstring": "Fixes URL.\n @param url: url to repair.\n @param out: instance of StandardOutput as defined in this lib.\n @return: Newline characters are stripped from the URL string.\n If the url string parameter does not start with http, it prepends http://\n If the url string parameter does not end with a slash, appends a slash.\n If the url contains a query string, it gets removed." }, { "code": "def open(self, auto_commit=None, schema=None):\n if schema is None:\n schema = self.schema\n ac = auto_commit if auto_commit is not None else schema.auto_commit\n exe = ExecutionContext(self.path, schema=schema, auto_commit=ac)\n if not os.path.isfile(self.path) or os.path.getsize(self.path) == 0:\n getLogger().warning(\"DB does not exist at {}. Setup is required.\".format(self.path))\n if schema is not None and schema.setup_files:\n for file_path in schema.setup_files:\n getLogger().debug(\"Executing script file: {}\".format(file_path))\n exe.cur.executescript(self.read_file(file_path))\n if schema.setup_scripts:\n for script in schema.setup_scripts:\n exe.cur.executescript(script)\n return exe", "docstring": "Create a context to execute queries" }, { "code": "def beforeSummaryReport(self, event):\n self.prof.disable()\n stats = pstats.Stats(self.prof, stream=event.stream).sort_stats(\n self.sort)\n event.stream.writeln(nose2.util.ln('Profiling results'))\n stats.print_stats()\n if self.pfile:\n stats.dump_stats(self.pfile)\n if self.cachegrind:\n visualize(self.prof.getstats())", "docstring": "Output profiling results" }, { "code": "def build_grouped_ownership_map(table,\n key_from_row,\n value_from_row,\n group_key):\n grouped_rows = groupby(\n group_key,\n sa.select(table.c).execute().fetchall(),\n )\n return {\n key: _build_ownership_map_from_rows(\n rows,\n key_from_row,\n value_from_row,\n )\n for key, rows in grouped_rows.items()\n }", "docstring": "Builds a dict mapping group keys to maps of keys to to lists of\n OwnershipPeriods, from a db table." }, { "code": "def add_aggregate(self, name, data_fac):\n @self.add_target(name)\n def wrap(outdir, c):\n return data_fac()", "docstring": "Add an aggregate target to this nest.\n\n\n Since nests added after the aggregate can access the construct returned\n by the factory function value, it can be mutated to provide additional\n values for use when the decorated function is called.\n\n To do something with the aggregates, you must :meth:`SConsWrap.pop`\n nest levels created between addition of the aggregate and then can add\n any normal targets you would like which take advantage of the targets\n added to the data structure.\n\n :param name: Name for the target in the nest\n :param data_fac: a nullary factory function which will be called\n immediately for each of the current control dictionaries and stored\n in each dictionary with the given name as in\n :meth:`SConsWrap.add_target`." }, { "code": "def _ps(osdata):\n grains = {}\n bsd_choices = ('FreeBSD', 'NetBSD', 'OpenBSD', 'MacOS')\n if osdata['os'] in bsd_choices:\n grains['ps'] = 'ps auxwww'\n elif osdata['os_family'] == 'Solaris':\n grains['ps'] = '/usr/ucb/ps auxwww'\n elif osdata['os'] == 'Windows':\n grains['ps'] = 'tasklist.exe'\n elif osdata.get('virtual', '') == 'openvzhn':\n grains['ps'] = (\n 'ps -fH -p $(grep -l \\\"^envID:[[:space:]]*0\\\\$\\\" '\n '/proc/[0-9]*/status | sed -e \\\"s=/proc/\\\\([0-9]*\\\\)/.*=\\\\1=\\\") '\n '| awk \\'{ $7=\\\"\\\"; print }\\''\n )\n elif osdata['os_family'] == 'AIX':\n grains['ps'] = '/usr/bin/ps auxww'\n elif osdata['os_family'] == 'NILinuxRT':\n grains['ps'] = 'ps -o user,pid,ppid,tty,time,comm'\n else:\n grains['ps'] = 'ps -efHww'\n return grains", "docstring": "Return the ps grain" }, { "code": "def get_join_parameters(join_kwargs):\n by = join_kwargs.get('by', None)\n suffixes = join_kwargs.get('suffixes', ('_x', '_y'))\n if isinstance(by, tuple):\n left_on, right_on = by\n elif isinstance(by, list):\n by = [x if isinstance(x, tuple) else (x, x) for x in by]\n left_on, right_on = (list(x) for x in zip(*by))\n else:\n left_on, right_on = by, by\n return left_on, right_on, suffixes", "docstring": "Convenience function to determine the columns to join the right and\n left DataFrames on, as well as any suffixes for the columns." }, { "code": "def serial(self):\n asnint = libcrypto.X509_get_serialNumber(self.cert)\n bio = Membio()\n libcrypto.i2a_ASN1_INTEGER(bio.bio, asnint)\n return int(str(bio), 16)", "docstring": "Serial number of certificate as integer" }, { "code": "def list_opts():\n for mod in load_conf_modules():\n mod_opts = mod.list_opts()\n if type(mod_opts) is list:\n for single_mod_opts in mod_opts:\n yield single_mod_opts[0], single_mod_opts[1]\n else:\n yield mod_opts[0], mod_opts[1]", "docstring": "List all conf modules opts.\n\n Goes through all conf modules and yields their opts." }, { "code": "def open(self, path, delimiter=None, mode='r', buffering=-1, encoding=None, errors=None,\n newline=None):\n if not re.match('^[rbt]{1,3}$', mode):\n raise ValueError('mode argument must be only have r, b, and t')\n file_open = get_read_function(path, self.disable_compression)\n file = file_open(path, mode=mode, buffering=buffering, encoding=encoding, errors=errors,\n newline=newline)\n if delimiter is None:\n return self(file)\n else:\n return self(''.join(list(file)).split(delimiter))", "docstring": "Reads and parses input files as defined.\n\n If delimiter is not None, then the file is read in bulk then split on it. If it is None\n (the default), then the file is parsed as sequence of lines. The rest of the options are\n passed directly to builtins.open with the exception that write/append file modes is not\n allowed.\n\n >>> seq.open('examples/gear_list.txt').take(1)\n [u'tent\\\\n']\n\n :param path: path to file\n :param delimiter: delimiter to split joined text on. if None, defaults to per line split\n :param mode: file open mode\n :param buffering: passed to builtins.open\n :param encoding: passed to builtins.open\n :param errors: passed to builtins.open\n :param newline: passed to builtins.open\n :return: output of file depending on options wrapped in a Sequence via seq" }, { "code": "def source(self):\n if len(self.sources) == 0:\n raise ValueError(\"No source associated with %s\" % self.__class__.__name__)\n elif len(self.sources) > 1:\n raise ValueError(\"Multiple sources for %s\" % self.__class__.__name__)\n return list(self.sources)[0]", "docstring": "Returns the single source name for a variant collection if it is unique,\n otherwise raises an error." }, { "code": "def json_options_to_metadata(options, add_brackets=True):\n try:\n options = loads('{' + options + '}' if add_brackets else options)\n return options\n except ValueError:\n return {}", "docstring": "Read metadata from its json representation" }, { "code": "def mixerfields(data, commdct):\n objkey = \"Connector:Mixer\".upper()\n fieldlists = splittermixerfieldlists(data, commdct, objkey)\n return extractfields(data, commdct, objkey, fieldlists)", "docstring": "get mixer fields to diagram it" }, { "code": "def _preprocess(project_dict):\n handlers = {\n ('archive',): _list_if_none,\n ('on-run-start',): _list_if_none_or_string,\n ('on-run-end',): _list_if_none_or_string,\n }\n for k in ('models', 'seeds'):\n handlers[(k,)] = _dict_if_none\n handlers[(k, 'vars')] = _dict_if_none\n handlers[(k, 'pre-hook')] = _list_if_none_or_string\n handlers[(k, 'post-hook')] = _list_if_none_or_string\n handlers[('seeds', 'column_types')] = _dict_if_none\n def converter(value, keypath):\n if keypath in handlers:\n handler = handlers[keypath]\n return handler(value)\n else:\n return value\n return deep_map(converter, project_dict)", "docstring": "Pre-process certain special keys to convert them from None values\n into empty containers, and to turn strings into arrays of strings." }, { "code": "def default_depart(self, mdnode):\n if mdnode.is_container():\n fn_name = 'visit_{0}'.format(mdnode.t)\n if not hasattr(self, fn_name):\n warn(\"Container node skipped: type={0}\".format(mdnode.t))\n else:\n self.current_node = self.current_node.parent", "docstring": "Default node depart handler\n\n If there is a matching ``visit_`` method for a container node,\n then we should make sure to back up to it's parent element when the node\n is exited." }, { "code": "def delete_key(self, key_to_delete):\n log = logging.getLogger(self.cls_logger + '.delete_key')\n log.info('Attempting to delete key: {k}'.format(k=key_to_delete))\n try:\n self.s3client.delete_object(Bucket=self.bucket_name, Key=key_to_delete)\n except ClientError:\n _, ex, trace = sys.exc_info()\n log.error('ClientError: Unable to delete key: {k}\\n{e}'.format(k=key_to_delete, e=str(ex)))\n return False\n else:\n log.info('Successfully deleted key: {k}'.format(k=key_to_delete))\n return True", "docstring": "Deletes the specified key\n\n :param key_to_delete:\n :return:" }, { "code": "def _cursor_forward(self, count=1):\n self.x = min(self.size[1] - 1, self.x + count)", "docstring": "Moves cursor right count columns. Cursor stops at right margin." }, { "code": "def _byte_pad(data, bound=4):\n bound = int(bound)\n if len(data) % bound != 0:\n pad = bytes(bound - (len(data) % bound))\n result = bytes().join([data, pad])\n assert (len(result) % bound) == 0\n return result\n return data", "docstring": "GLTF wants chunks aligned with 4- byte boundaries\n so this function will add padding to the end of a\n chunk of bytes so that it aligns with a specified\n boundary size\n\n Parameters\n --------------\n data : bytes\n Data to be padded\n bound : int\n Length of desired boundary\n\n Returns\n --------------\n padded : bytes\n Result where: (len(padded) % bound) == 0" }, { "code": "def select_from_drop_down_by_text(self, drop_down_locator, option_locator, option_text, params=None):\n self.click(drop_down_locator, params['drop_down'] if params else None)\n for option in self.get_present_elements(option_locator, params['option'] if params else None):\n if self.get_text(option) == option_text:\n self.click(option)\n break", "docstring": "Select option from drop down widget using text.\n\n :param drop_down_locator: locator tuple (if any, params needs to be in place) or WebElement instance\n :param option_locator: locator tuple (if any, params needs to be in place)\n :param option_text: text to base option selection on\n :param params: Dictionary containing dictionary of params\n :return: None" }, { "code": "def deploy_clone_from_vm(self, si, logger, data_holder, vcenter_data_model, reservation_id, cancellation_context):\n template_resource_model = data_holder.template_resource_model\n return self._deploy_a_clone(si,\n logger,\n data_holder.app_name,\n template_resource_model.vcenter_vm,\n template_resource_model,\n vcenter_data_model,\n reservation_id,\n cancellation_context)", "docstring": "deploy Cloned VM From VM Command, will deploy vm from another vm\n\n :param cancellation_context:\n :param reservation_id:\n :param si:\n :param logger:\n :type data_holder:\n :type vcenter_data_model:\n :rtype DeployAppResult:\n :return:" }, { "code": "def subscriber_choice_control(self):\n self.current.task_data['option'] = None\n self.current.task_data['chosen_subscribers'], names = self.return_selected_form_items(\n self.input['form']['SubscriberList'])\n self.current.task_data[\n 'msg'] = \"You should choose at least one subscriber for migration operation.\"\n if self.current.task_data['chosen_subscribers']:\n self.current.task_data['option'] = self.input['cmd']\n del self.current.task_data['msg']", "docstring": "It controls subscribers choice and generates\n error message if there is a non-choice." }, { "code": "def create_conversion_event(self, event_key, user_id, attributes, event_tags):\n params = self._get_common_params(user_id, attributes)\n conversion_params = self._get_required_params_for_conversion(event_key, event_tags)\n params[self.EventParams.USERS][0][self.EventParams.SNAPSHOTS].append(conversion_params)\n return Event(self.EVENTS_URL,\n params,\n http_verb=self.HTTP_VERB,\n headers=self.HTTP_HEADERS)", "docstring": "Create conversion Event to be sent to the logging endpoint.\n\n Args:\n event_key: Key representing the event which needs to be recorded.\n user_id: ID for user.\n attributes: Dict representing user attributes and values.\n event_tags: Dict representing metadata associated with the event.\n\n Returns:\n Event object encapsulating the conversion event." }, { "code": "def show(cobertura_file, format, output, source, source_prefix):\n cobertura = Cobertura(cobertura_file, source=source)\n Reporter = reporters[format]\n reporter = Reporter(cobertura)\n report = reporter.generate()\n if not isinstance(report, bytes):\n report = report.encode('utf-8')\n isatty = True if output is None else output.isatty()\n click.echo(report, file=output, nl=isatty)", "docstring": "show coverage summary of a Cobertura report" }, { "code": "def ping(self):\n msg_code = riak.pb.messages.MSG_CODE_PING_REQ\n codec = self._get_codec(msg_code)\n msg = codec.encode_ping()\n resp_code, _ = self._request(msg, codec)\n if resp_code == riak.pb.messages.MSG_CODE_PING_RESP:\n return True\n else:\n return False", "docstring": "Ping the remote server" }, { "code": "def _show_previous_blank_lines(block):\n pblock = block.previous()\n while (pblock.text().strip() == '' and\n pblock.blockNumber() >= 0):\n pblock.setVisible(True)\n pblock = pblock.previous()", "docstring": "Show the block previous blank lines" }, { "code": "def set_time_zone(self, item):\n i3s_time = item[\"full_text\"].encode(\"UTF-8\", \"replace\")\n try:\n i3s_time = i3s_time.decode()\n except:\n pass\n parts = i3s_time.split()\n i3s_datetime = \" \".join(parts[:2])\n if len(parts) < 3:\n return True\n else:\n i3s_time_tz = parts[2]\n date = datetime.strptime(i3s_datetime, TIME_FORMAT)\n utcnow = datetime.utcnow()\n delta = datetime(\n date.year, date.month, date.day, date.hour, date.minute\n ) - datetime(utcnow.year, utcnow.month, utcnow.day, utcnow.hour, utcnow.minute)\n try:\n self.tz = Tz(i3s_time_tz, delta)\n except ValueError:\n return False\n return True", "docstring": "Work out the time zone and create a shim tzinfo.\n\n We return True if all is good or False if there was an issue and we\n need to re check the time zone. see issue #1375" }, { "code": "def join_resource_name(self, v):\n d = self.dict\n d['fragment'] = [v, None]\n return MetapackResourceUrl(downloader=self._downloader, **d)", "docstring": "Return a MetapackResourceUrl that includes a reference to the resource. Returns a\n MetapackResourceUrl, which will have a fragment" }, { "code": "def import_from_netcdf(network, path, skip_time=False):\n assert has_xarray, \"xarray must be installed for netCDF support.\"\n basename = os.path.basename(path) if isinstance(path, string_types) else None\n with ImporterNetCDF(path=path) as importer:\n _import_from_importer(network, importer, basename=basename,\n skip_time=skip_time)", "docstring": "Import network data from netCDF file or xarray Dataset at `path`.\n\n Parameters\n ----------\n path : string|xr.Dataset\n Path to netCDF dataset or instance of xarray Dataset\n skip_time : bool, default False\n Skip reading in time dependent attributes" }, { "code": "def _cache_loc(self, path, saltenv='base', cachedir=None):\n cachedir = self.get_cachedir(cachedir)\n dest = salt.utils.path.join(cachedir,\n 'files',\n saltenv,\n path)\n destdir = os.path.dirname(dest)\n with salt.utils.files.set_umask(0o077):\n if os.path.isfile(destdir):\n os.remove(destdir)\n try:\n os.makedirs(destdir)\n except OSError as exc:\n if exc.errno != errno.EEXIST:\n raise\n yield dest", "docstring": "Return the local location to cache the file, cache dirs will be made" }, { "code": "def import_legislators(src):\n logger.info(\"Importing Legislators From: {0}\".format(src))\n current = pd.read_csv(\"{0}/{1}/legislators-current.csv\".format(\n src, LEGISLATOR_DIR))\n historic = pd.read_csv(\"{0}/{1}/legislators-historic.csv\".format(\n src, LEGISLATOR_DIR))\n legislators = current.append(historic)\n return legislators", "docstring": "Read the legislators from the csv files into a single Dataframe. Intended\n for importing new data." }, { "code": "def training_set_multiplication(training_set, mult_queue):\n logging.info(\"Multiply data...\")\n for algorithm in mult_queue:\n new_trning_set = []\n for recording in training_set:\n samples = algorithm(recording['handwriting'])\n for sample in samples:\n new_trning_set.append({'id': recording['id'],\n 'is_in_testset': 0,\n 'formula_id': recording['formula_id'],\n 'handwriting': sample,\n 'formula_in_latex':\n recording['formula_in_latex']})\n training_set = new_trning_set\n return new_trning_set", "docstring": "Multiply the training set by all methods listed in mult_queue.\n\n Parameters\n ----------\n training_set :\n set of all recordings that will be used for training\n mult_queue :\n list of all algorithms that will take one recording and generate more\n than one.\n\n Returns\n -------\n mutliple recordings" }, { "code": "def create_unique_wcsname(fimg, extnum, wcsname):\n wnames = list(wcsutil.altwcs.wcsnames(fimg, ext=extnum).values())\n if wcsname not in wnames:\n uniqname = wcsname\n else:\n rpatt = re.compile(wcsname+'_\\d')\n index = 0\n for wname in wnames:\n rmatch = rpatt.match(wname)\n if rmatch:\n n = int(wname[wname.rfind('_')+1:])\n if n > index: index = 1\n index += 1\n uniqname = \"%s_%d\"%(wcsname,index)\n return uniqname", "docstring": "This function evaluates whether the specified wcsname value has\n already been used in this image. If so, it automatically modifies\n the name with a simple version ID using wcsname_NNN format.\n\n Parameters\n ----------\n fimg : obj\n PyFITS object of image with WCS information to be updated\n\n extnum : int\n Index of extension with WCS information to be updated\n\n wcsname : str\n Value of WCSNAME specified by user for labelling the new WCS\n\n Returns\n -------\n uniqname : str\n Unique WCSNAME value" }, { "code": "def unpack(s):\n header = IRHeader(*struct.unpack(_IR_FORMAT, s[:_IR_SIZE]))\n s = s[_IR_SIZE:]\n if header.flag > 0:\n header = header._replace(label=np.frombuffer(s, np.float32, header.flag))\n s = s[header.flag*4:]\n return header, s", "docstring": "Unpack a MXImageRecord to string.\n\n Parameters\n ----------\n s : str\n String buffer from ``MXRecordIO.read``.\n\n Returns\n -------\n header : IRHeader\n Header of the image record.\n s : str\n Unpacked string.\n\n Examples\n --------\n >>> record = mx.recordio.MXRecordIO('test.rec', 'r')\n >>> item = record.read()\n >>> header, s = mx.recordio.unpack(item)\n >>> header\n HEADER(flag=0, label=14.0, id=20129312, id2=0)" }, { "code": "def help_heading(self):\n message = m.Heading(\n tr('Help for {step_name}').format(step_name=self.step_name),\n **SUBSECTION_STYLE)\n return message", "docstring": "Helper method that returns just the header.\n\n :returns: A heading object.\n :rtype: safe.messaging.heading.Heading" }, { "code": "def set_win_wallpaper(img):\n if \"x86\" in os.environ[\"PROGRAMFILES\"]:\n ctypes.windll.user32.SystemParametersInfoW(20, 0, img, 3)\n else:\n ctypes.windll.user32.SystemParametersInfoA(20, 0, img, 3)", "docstring": "Set the wallpaper on Windows." }, { "code": "def refresh_fqdn_cache(force=False):\n if not isinstance(force, bool):\n raise CommandExecutionError(\"Force option must be boolean.\")\n if force:\n query = {'type': 'op',\n 'cmd': 'yes'}\n else:\n query = {'type': 'op', 'cmd': ''}\n return __proxy__['panos.call'](query)", "docstring": "Force refreshes all FQDNs used in rules.\n\n force\n Forces all fqdn refresh\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' panos.refresh_fqdn_cache\n salt '*' panos.refresh_fqdn_cache force=True" }, { "code": "def mbar_log_W_nk(u_kn, N_k, f_k):\n u_kn, N_k, f_k = validate_inputs(u_kn, N_k, f_k)\n log_denominator_n = logsumexp(f_k - u_kn.T, b=N_k, axis=1)\n logW = f_k - u_kn.T - log_denominator_n[:, np.newaxis]\n return logW", "docstring": "Calculate the log weight matrix.\n\n Parameters\n ----------\n u_kn : np.ndarray, shape=(n_states, n_samples), dtype='float'\n The reduced potential energies, i.e. -log unnormalized probabilities\n N_k : np.ndarray, shape=(n_states), dtype='int'\n The number of samples in each state\n f_k : np.ndarray, shape=(n_states), dtype='float'\n The reduced free energies of each state\n\n Returns\n -------\n logW_nk : np.ndarray, dtype='float', shape=(n_samples, n_states)\n The normalized log weights.\n\n Notes\n -----\n Equation (9) in JCP MBAR paper." }, { "code": "def get_details(app_url=defaults.APP_URL):\n url = '%s/environment' % app_url\n response = requests.get(url)\n if response.status_code == 200:\n return response.json()\n else:\n raise JutException('Unable to retrieve environment details from %s, got %s: %s' %\n (url, response.status_code, response.text))", "docstring": "returns environment details for the app url specified" }, { "code": "def scheme(name, bins, bin_method='quantiles'):\n return {\n 'name': name,\n 'bins': bins,\n 'bin_method': (bin_method if isinstance(bins, int) else ''),\n }", "docstring": "Return a custom scheme based on CARTOColors.\n\n Args:\n name (str): Name of a CARTOColor.\n bins (int or iterable): If an `int`, the number of bins for classifying\n data. CARTOColors have 7 bins max for quantitative data, and 11 max\n for qualitative data. If `bins` is a `list`, it is the upper range\n for classifying data. E.g., `bins` can be of the form ``(10, 20, 30,\n 40, 50)``.\n bin_method (str, optional): One of methods in :obj:`BinMethod`.\n Defaults to ``quantiles``. If `bins` is an interable, then that is\n the bin method that will be used and this will be ignored.\n\n .. Warning::\n\n Input types are particularly sensitive in this function, and little\n feedback is given for errors. ``name`` and ``bin_method`` arguments\n are case-sensitive." }, { "code": "def stream_directory(directory,\n recursive=False,\n patterns='**',\n chunk_size=default_chunk_size):\n stream = DirectoryStream(directory,\n recursive=recursive,\n patterns=patterns,\n chunk_size=chunk_size)\n return stream.body(), stream.headers", "docstring": "Gets a buffered generator for streaming directories.\n\n Returns a buffered generator which encodes a directory as\n :mimetype:`multipart/form-data` with the corresponding headers.\n\n Parameters\n ----------\n directory : str\n The filepath of the directory to stream\n recursive : bool\n Stream all content within the directory recursively?\n patterns : str | list\n Single *glob* pattern or list of *glob* patterns and compiled\n regular expressions to match the names of the filepaths to keep\n chunk_size : int\n Maximum size of each stream chunk" }, { "code": "def get_layer_description_from_canvas(self, layer, purpose):\n if not layer:\n return \"\"\n try:\n keywords = self.keyword_io.read_keywords(layer)\n if 'layer_purpose' not in keywords:\n keywords = None\n except (HashNotFoundError,\n OperationalError,\n NoKeywordsFoundError,\n KeywordNotFoundError,\n InvalidParameterError,\n UnsupportedProviderError):\n keywords = None\n self.layer = layer\n if purpose == layer_purpose_hazard['key']:\n self.hazard_layer = layer\n elif purpose == layer_purpose_exposure['key']:\n self.exposure_layer = layer\n else:\n self.aggregation_layer = layer\n if keywords and 'keyword_version' in keywords:\n kw_ver = str(keywords['keyword_version'])\n self.is_selected_layer_keywordless = (\n not is_keyword_version_supported(kw_ver))\n else:\n self.is_selected_layer_keywordless = True\n description = layer_description_html(layer, keywords)\n return description", "docstring": "Obtain the description of a canvas layer selected by user.\n\n :param layer: The QGIS layer.\n :type layer: QgsMapLayer\n\n :param purpose: The layer purpose of the layer to get the description.\n :type purpose: string\n\n :returns: description of the selected layer.\n :rtype: string" }, { "code": "def transition(trname='', field='', check=None, before=None, after=None):\n if is_callable(trname):\n raise ValueError(\n \"The @transition decorator should be called as \"\n \"@transition(['transition_name'], **kwargs)\")\n if check or before or after:\n warnings.warn(\n \"The use of check=, before= and after= in @transition decorators is \"\n \"deprecated in favor of @transition_check, @before_transition and \"\n \"@after_transition decorators.\",\n DeprecationWarning,\n stacklevel=2)\n return TransitionWrapper(trname, field=field, check=check, before=before, after=after)", "docstring": "Decorator to declare a function as a transition implementation." }, { "code": "def _show(self, message, indent=0, enable_verbose=True):\n if enable_verbose:\n print(\" \" * indent + message)", "docstring": "Message printer." }, { "code": "def move_to(x, y):\n for b in _button_state:\n if _button_state[b]:\n e = Quartz.CGEventCreateMouseEvent(\n None,\n _button_mapping[b][3],\n (x, y),\n _button_mapping[b][0])\n break\n else:\n e = Quartz.CGEventCreateMouseEvent(\n None,\n Quartz.kCGEventMouseMoved,\n (x, y),\n Quartz.kCGMouseButtonLeft)\n Quartz.CGEventPost(Quartz.kCGHIDEventTap, e)", "docstring": "Sets the mouse's location to the specified coordinates." }, { "code": "def _group(self, group_data):\n if isinstance(group_data, dict):\n xid = group_data.get('xid')\n else:\n xid = group_data.xid\n if self.groups.get(xid) is not None:\n group_data = self.groups.get(xid)\n elif self.groups_shelf.get(xid) is not None:\n group_data = self.groups_shelf.get(xid)\n else:\n self.groups[xid] = group_data\n return group_data", "docstring": "Return previously stored group or new group.\n\n Args:\n group_data (dict|obj): An Group dict or instance of Group object.\n\n Returns:\n dict|obj: The new Group dict/object or the previously stored dict/object." }, { "code": "def format_variable_map(variable_map, join_lines=True):\n rows = []\n rows.append((\"Key\", \"Variable\", \"Shape\", \"Type\", \"Collections\", \"Device\"))\n var_to_collections = _get_vars_to_collections(variable_map)\n sort_key = lambda item: (item[0], item[1].name)\n for key, var in sorted(variable_map_items(variable_map), key=sort_key):\n shape = \"x\".join(str(dim) for dim in var.get_shape().as_list())\n dtype = repr(var.dtype.base_dtype).replace(\"tf.\", \"\")\n coll = \", \".join(sorted(var_to_collections[var]))\n rows.append((key, var.op.name, shape, dtype, coll, _format_device(var)))\n return _format_table(rows, join_lines)", "docstring": "Takes a key-to-variable map and formats it as a table." }, { "code": "def reset_option(self, key, subkey):\n if not self.open:\n return\n key, subkey = _lower_keys(key, subkey)\n _entry_must_exist(self.gc, key, subkey)\n df = self.gc[(self.gc[\"k1\"] == key) & (self.gc[\"k2\"] == subkey)]\n if df[\"locked\"].values[0]:\n raise ValueError(\"{0}.{1} option is locked\".format(key, subkey))\n val = df[\"default\"].values[0]\n self.gc.loc[\n (self.gc[\"k1\"] == key) &\n (self.gc[\"k2\"] == subkey), \"value\"] = val", "docstring": "Resets a single option to the default values.\n\n :param str key: First identifier of the option.\n :param str subkey: Second identifier of the option.\n\n :raise:\n :NotRegisteredError: If ``key`` or ``subkey`` do not define any\n option.\n :ValueError: If the targeted obtion is locked." }, { "code": "def _check_split_list_validity(self):\n if not (hasattr(self,\"_splitListsSet\") and (self._splitListsSet)):\n return False\n elif len(self) != self._splitListsLength:\n return False\n else:\n return True", "docstring": "See _temporal_split_list above. This function checks if the current\n split lists are still valid." }, { "code": "def placeholdit(\n width,\n height,\n background_color=\"cccccc\",\n text_color=\"969696\",\n text=None,\n random_background_color=False\n):\n url = get_placeholdit_url(\n width,\n height,\n background_color=background_color,\n text_color=text_color,\n text=text,\n )\n return format_html('', url)", "docstring": "Creates a placeholder image using placehold.it\n\n Usage format:\n\n {% placeholdit [width] [height] [background_color] [text_color] [text] %}\n\n Example usage:\n\n Default image at 250 square\n {% placeholdit 250 %}\n\n 100 wide and 200 high\n {% placeholdit 100 200 %}\n\n Custom background and text colors\n {% placeholdit 100 200 background_color='fff' text_color=000' %}\n\n Custom text\n {% placeholdit 100 200 text='Hello LA' %}" }, { "code": "def do_state_tomography(preparation_program, nsamples, cxn, qubits=None, use_run=False):\n return tomography._do_tomography(preparation_program, nsamples, cxn, qubits,\n tomography.MAX_QUBITS_STATE_TOMO,\n StateTomography, state_tomography_programs,\n DEFAULT_STATE_TOMO_SETTINGS, use_run=use_run)", "docstring": "Method to perform both a QPU and QVM state tomography, and use the latter as\n as reference to calculate the fidelity of the former.\n\n :param Program preparation_program: Program to execute.\n :param int nsamples: Number of samples to take for the program.\n :param QVMConnection|QPUConnection cxn: Connection on which to run the program.\n :param list qubits: List of qubits for the program.\n to use in the tomography analysis.\n :param bool use_run: If ``True``, use append measurements on all qubits and use ``cxn.run``\n instead of ``cxn.run_and_measure``.\n :return: The state tomogram.\n :rtype: StateTomography" }, { "code": "def finalize(self):\n if self.total_instances > 1:\n print('{} of {} instances contained dead code.'\n .format(self.dead_code_instances, self.total_instances))", "docstring": "Output the number of instances that contained dead code." }, { "code": "def max_version(self):\n data = self.version_downloads\n if not data:\n return None, 0\n return max(data.items(), key=lambda item: item[1])", "docstring": "Version with the most downloads.\n\n :return: A tuple of the form (version, n_downloads)" }, { "code": "def ReadTriggers(self, collection_link, options=None):\n if options is None:\n options = {}\n return self.QueryTriggers(collection_link, None, options)", "docstring": "Reads all triggers in a collection.\n\n :param str collection_link:\n The link to the document collection.\n :param dict options:\n The request options for the request.\n\n :return:\n Query Iterable of Triggers.\n :rtype:\n query_iterable.QueryIterable" }, { "code": "def define_saver(exclude=None):\n variables = []\n exclude = exclude or []\n exclude = [re.compile(regex) for regex in exclude]\n for variable in tf.global_variables():\n if any(regex.match(variable.name) for regex in exclude):\n continue\n variables.append(variable)\n saver = tf.train.Saver(variables, keep_checkpoint_every_n_hours=5)\n return saver", "docstring": "Create a saver for the variables we want to checkpoint.\n\n Args:\n exclude: List of regexes to match variable names to exclude.\n\n Returns:\n Saver object." }, { "code": "def _add_coverage_bedgraph_to_output(out, data):\n out_file = \"%s.coverage.bedgraph\" % os.path.splitext(out[\"cns\"])[0]\n if utils.file_exists(out_file):\n out[\"bedgraph\"] = out_file\n return out\n bam_file = dd.get_align_bam(data)\n bedtools = config_utils.get_program(\"bedtools\", data[\"config\"])\n samtools = config_utils.get_program(\"samtools\", data[\"config\"])\n cns_file = out[\"cns\"]\n bed_file = tempfile.NamedTemporaryFile(suffix=\".bed\", delete=False).name\n with file_transaction(data, out_file) as tx_out_file:\n cmd = (\"sed 1d {cns_file} | cut -f1,2,3 > {bed_file}; \"\n \"{samtools} view -b -L {bed_file} {bam_file} | \"\n \"{bedtools} genomecov -bg -ibam - -g {bed_file} >\"\n \"{tx_out_file}\").format(**locals())\n do.run(cmd, \"CNVkit bedGraph conversion\")\n os.remove(bed_file)\n out[\"bedgraph\"] = out_file\n return out", "docstring": "Add BedGraph representation of coverage to the output" }, { "code": "def in_timezone(self, tz):\n tz = pendulum._safe_timezone(tz)\n return tz.convert(self, dst_rule=pendulum.POST_TRANSITION)", "docstring": "Set the instance's timezone from a string or object." }, { "code": "def basic_parse(response, buf_size=ijson.backend.BUFSIZE):\n lexer = iter(IncrementalJsonParser.lexer(response, buf_size))\n for value in ijson.backend.parse_value(lexer):\n yield value\n try:\n next(lexer)\n except StopIteration:\n pass\n else:\n raise ijson.common.JSONError('Additional data')", "docstring": "Iterator yielding unprefixed events.\n\n Parameters:\n\n - response: a stream response from requests" }, { "code": "def _left_zero_blocks(self, r):\n if not self._include_off_diagonal:\n return r\n elif not self._upper:\n return 0\n elif self._include_diagonal:\n return r\n else:\n return r + 1", "docstring": "Number of blocks with zeros from the left in block row `r`." }, { "code": "def is_compatible_with(self, other):\n other = as_dtype(other)\n return self._type_enum in (\n other.as_datatype_enum,\n other.base_dtype.as_datatype_enum,\n )", "docstring": "Returns True if the `other` DType will be converted to this DType.\n\n The conversion rules are as follows:\n\n ```python\n DType(T) .is_compatible_with(DType(T)) == True\n DType(T) .is_compatible_with(DType(T).as_ref) == True\n DType(T).as_ref.is_compatible_with(DType(T)) == False\n DType(T).as_ref.is_compatible_with(DType(T).as_ref) == True\n ```\n\n Args:\n other: A `DType` (or object that may be converted to a `DType`).\n\n Returns:\n True if a Tensor of the `other` `DType` will be implicitly converted to\n this `DType`." }, { "code": "def set_rendering_intent(self, rendering_intent):\n if rendering_intent not in (None,\n PERCEPTUAL,\n RELATIVE_COLORIMETRIC,\n SATURATION,\n ABSOLUTE_COLORIMETRIC):\n raise FormatError('Unknown redering intent')\n self.rendering_intent = rendering_intent", "docstring": "Set rendering intent variant for sRGB chunk" }, { "code": "def proxy_protocol(self, error='raise', default=None, limit=None, authenticate=False):\n if error not in ('raise', 'unread'):\n raise ValueError('error=\"{0}\" is not \"raise\" or \"unread\"\"')\n if not isinstance(self.request, SocketBuffer):\n self.request = SocketBuffer(self.request)\n if default == 'peer':\n default = ProxyInfo(\n self.client_address[0], self.client_address[1],\n self.client_address[0], self.client_address[1],\n )\n try:\n line = read_line(\n self.request.sock,\n self.request.buf,\n limit=limit,\n )\n except exc.ReadError:\n if error == 'raise':\n raise\n return default\n try:\n info = parse_line(line)\n except exc.ParseError:\n if error == 'raise':\n raise\n self.request.unread(line)\n return default\n if authenticate and not self.proxy_authenticate(info):\n logger.info('authentication failed - %s', info)\n return default\n return info", "docstring": "Parses, and optionally authenticates, proxy protocol information from\n request. Note that ``self.request`` is wrapped by ``SocketBuffer``.\n\n :param error:\n How read (``exc.ReadError``) and parse (``exc.ParseError``) errors\n are handled. One of:\n - \"raise\" to propagate.\n - \"unread\" to suppress exceptions and unread back to socket.\n :param default:\n What to return when no ``ProxyInfo`` was found. Only meaningful\n with error \"unread\".\n :param limit:\n Maximum number of bytes to read when probing request for\n ``ProxyInfo``.\n\n :returns: Parsed ``ProxyInfo`` instance or **default** if none found." }, { "code": "def _define_range(self, sequences):\n sequence_count = 0\n total_sequence = 0\n for record in SeqIO.parse(open(sequences), 'fasta'):\n total_sequence+=1\n sequence_count+=len(record.seq)\n max_range = (sequence_count/total_sequence)*1.5\n return max_range", "docstring": "define_range - define the maximum range within which two hits in a db\n search can be linked. This is defined as 1.5X the average length of all\n reads in the database.\n\n Parameters\n ----------\n sequences : str\n A path to the sequences in FASTA format. This fasta file is assumed\n to be in the correct format. i.e. headers start with '>'\n\n Returns\n -------\n max_range : int\n As described above, 1.5X the size of the average length of genes\n within the database" }, { "code": "def parser_factory(fake_args=None):\n parser = ArgumentParser(description='aomi')\n subparsers = parser.add_subparsers(dest='operation',\n help='Specify the data '\n ' or extraction operation')\n extract_file_args(subparsers)\n environment_args(subparsers)\n aws_env_args(subparsers)\n seed_args(subparsers)\n render_args(subparsers)\n diff_args(subparsers)\n freeze_args(subparsers)\n thaw_args(subparsers)\n template_args(subparsers)\n password_args(subparsers)\n token_args(subparsers)\n help_args(subparsers)\n export_args(subparsers)\n if fake_args is None:\n return parser, parser.parse_args()\n return parser, parser.parse_args(fake_args)", "docstring": "Return a proper contextual OptionParser" }, { "code": "def get_whitelist_page(self, page_number=None, page_size=None):\n params = {\n 'pageNumber': page_number,\n 'pageSize': page_size\n }\n resp = self._client.get(\"whitelist\", params=params)\n return Page.from_dict(resp.json(), content_type=Indicator)", "docstring": "Gets a paginated list of indicators that the user's company has whitelisted.\n\n :param int page_number: the page number to get.\n :param int page_size: the size of the page to be returned.\n :return: A |Page| of |Indicator| objects." }, { "code": "def _cmp_date(self):\n dates = sorted(val for val in self.kw.values()\n if isinstance(val, CalendarDate))\n if dates:\n return dates[0]\n return CalendarDate()", "docstring": "Returns Calendar date used for comparison.\n\n Use the earliest date out of all CalendarDates in this instance,\n or some date in the future if there are no CalendarDates (e.g.\n when Date is a phrase)." }, { "code": "def model_base(bind_label=None, info=None):\n Model = type('Model', (BaseModel,), {'__odm_abstract__': True})\n info = {}\n Model.__table_args__ = table_args(info=info)\n if bind_label:\n info['bind_label'] = bind_label\n return Model", "docstring": "Create a base declarative class" }, { "code": "def sparql_query(self, query, flush=None, limit=None):\n return self.find_statements(query, language='sparql', type='tuples',\n flush=flush, limit=limit)", "docstring": "Run a Sparql query.\n\n :param query: sparql query string\n :rtype: list of dictionary" }, { "code": "def query_symbol(self, asset: str) -> str:\n contract_address = self.get_asset_address(asset)\n method = 'symbol'\n invoke_code = build_native_invoke_code(contract_address, b'\\x00', method, bytearray())\n tx = Transaction(0, 0xd1, int(time()), 0, 0, None, invoke_code, bytearray(), list())\n response = self.__sdk.rpc.send_raw_transaction_pre_exec(tx)\n symbol = ContractDataParser.to_utf8_str(response['Result'])\n return symbol", "docstring": "This interface is used to query the asset's symbol of ONT or ONG.\n\n :param asset: a string which is used to indicate which asset's symbol we want to get.\n :return: asset's symbol in the form of string." }, { "code": "def getStartdatetime(self):\n return datetime(self.startdate_year, self.startdate_month, self.startdate_day,\n self.starttime_hour, self.starttime_minute, self.starttime_second)", "docstring": "Returns the date and starttime as datetime object\n\n Parameters\n ----------\n None\n\n Examples\n --------\n >>> import pyedflib\n >>> f = pyedflib.data.test_generator()\n >>> f.getStartdatetime()\n datetime.datetime(2011, 4, 4, 12, 57, 2)\n >>> f._close()\n >>> del f" }, { "code": "def paths(self, destination_account, destination_amount, source_account, destination_asset_code,\n destination_asset_issuer=None):\n destination_asset = Asset(destination_asset_code, destination_asset_issuer)\n destination_asset_params = {\n 'destination_asset_type': destination_asset.type,\n 'destination_asset_code': None if destination_asset.is_native() else destination_asset.code,\n 'destination_asset_issuer': destination_asset.issuer\n }\n endpoint = '/paths'\n params = self.__query_params(destination_account=destination_account,\n source_account=source_account,\n destination_amount=destination_amount,\n **destination_asset_params\n )\n return self.query(endpoint, params)", "docstring": "Load a list of assets available to the source account id and find\n any payment paths from those source assets to the desired\n destination asset.\n\n See the below docs for more information on required and optional\n parameters for further specifying your search.\n\n `GET /paths\n `_\n\n :param str destination_account: The destination account that any returned path should use.\n :param str destination_amount: The amount, denominated in the destination asset,\n that any returned path should be able to satisfy.\n :param str source_account: The sender's account id. Any returned path must use a source that the sender can hold.\n :param str destination_asset_code: The asset code for the destination.\n :param destination_asset_issuer: The asset issuer for the destination, if it is a native asset, let it be `None`.\n :type destination_asset_issuer: str, None\n\n\n :return: A list of paths that can be used to complete a payment based\n on a given query.\n :rtype: dict" }, { "code": "def annotate_gemini(data, retriever=None):\n r = dd.get_variation_resources(data)\n return all([r.get(k) and objectstore.file_exists_or_remote(r[k]) for k in [\"exac\", \"gnomad_exome\"]])", "docstring": "Annotate with population calls if have data installed." }, { "code": "def _get_default_router(self, routers, router_name=None):\n if router_name is None:\n for router in routers:\n if router['id'] is not None:\n return router['id']\n else:\n for router in routers:\n if router['hostname'] == router_name:\n return router['id']\n raise SoftLayer.SoftLayerError(\"Could not find valid default router\")", "docstring": "Returns the default router for ordering a dedicated host." }, { "code": "def postags(self):\n if not self.is_tagged(ANALYSIS):\n self.tag_analysis()\n return self.get_analysis_element(POSTAG)", "docstring": "The list of word part-of-speech tags.\n\n Ambiguous cases are separated with pipe character by default.\n Use :py:meth:`~estnltk.text.Text.get_analysis_element` to specify custom separator for ambiguous entries." }, { "code": "def check_existing_results(self, benchmark):\n if os.path.exists(benchmark.log_folder):\n sys.exit('Output directory {0} already exists, will not overwrite existing results.'.format(benchmark.log_folder))\n if os.path.exists(benchmark.log_zip):\n sys.exit('Output archive {0} already exists, will not overwrite existing results.'.format(benchmark.log_zip))", "docstring": "Check and abort if the target directory for the benchmark results\n already exists in order to avoid overwriting results." }, { "code": "def compare(self, compare_recipe, suffix='_compare'):\n assert isinstance(compare_recipe, Recipe)\n assert isinstance(suffix, basestring)\n self.compare_recipe.append(compare_recipe)\n self.suffix.append(suffix)\n self.dirty = True\n return self.recipe", "docstring": "Adds a comparison recipe to a base recipe." }, { "code": "def dump(props, output):\n def escape(token):\n return re.sub(r'([=:\\s])', r'\\\\\\1', token)\n def write(out):\n for k, v in props.items():\n out.write('%s=%s\\n' % (escape(str(k)), escape(str(v))))\n if hasattr(output, 'write') and callable(output.write):\n write(output)\n elif isinstance(output, six.string_types):\n with open(output, 'w+') as out:\n write(out)\n else:\n raise TypeError('Can only dump data to a path or a writable object, given: %s' % output)", "docstring": "Dumps a dict of properties to the specified open stream or file path.\n\n :API: public" }, { "code": "def to_list(self):\n output = []\n for i in range(1, len(self.elements), 2):\n output.append(self.elements[i])\n return output", "docstring": "Converts the vector to an array of the elements within the vector" }, { "code": "def assert_trigger(self, session, protocol):\n try:\n return self.sessions[session].assert_trigger(protocol)\n except KeyError:\n return constants.StatusCode.error_invalid_object", "docstring": "Asserts software or hardware trigger.\n\n Corresponds to viAssertTrigger function of the VISA library.\n\n :param session: Unique logical identifier to a session.\n :param protocol: Trigger protocol to use during assertion. (Constants.PROT*)\n :return: return value of the library call.\n :rtype: :class:`pyvisa.constants.StatusCode`" }, { "code": "def extract_facts(rule):\n def _extract_facts(ce):\n if isinstance(ce, Fact):\n yield ce\n elif isinstance(ce, TEST):\n pass\n else:\n for e in ce:\n yield from _extract_facts(e)\n return set(_extract_facts(rule))", "docstring": "Given a rule, return a set containing all rule LHS facts." }, { "code": "def render_subgraph(self, ontol, nodes, **args):\n subont = ontol.subontology(nodes, **args)\n return self.render(subont, **args)", "docstring": "Render a `ontology` object after inducing a subgraph" }, { "code": "def get_post(self, slug):\n cache_key = self.get_cache_key(post_slug=slug)\n content = cache.get(cache_key)\n if not content:\n post = Post.objects.get(slug=slug)\n content = self._format(post)\n cache_duration = conf.GOSCALE_CACHE_DURATION if post else 1\n cache.set(cache_key, content, cache_duration)\n return content", "docstring": "This method returns a single post by slug" }, { "code": "def make_blastdb(self):\n db = os.path.splitext(self.formattedprimers)[0]\n nhr = '{db}.nhr'.format(db=db)\n if not os.path.isfile(str(nhr)):\n command = 'makeblastdb -in {primerfile} -parse_seqids -max_file_sz 2GB -dbtype nucl -out {outfile}'\\\n .format(primerfile=self.formattedprimers,\n outfile=db)\n run_subprocess(command)", "docstring": "Create a BLAST database of the primer file" }, { "code": "def to_bytes(s, encoding=\"utf8\"):\n if PY_VERSION == 2:\n b = bytes(s)\n elif PY_VERSION == 3:\n b = bytes(s, encoding)\n else:\n raise ValueError(\"Is Python 4 out already?\")\n return b", "docstring": "Converts str s to bytes" }, { "code": "def mmi_to_delimited_file(self, force_flag=True):\n LOGGER.debug('mmi_to_delimited_text requested.')\n csv_path = os.path.join(\n self.output_dir, 'mmi.csv')\n if os.path.exists(csv_path) and force_flag is not True:\n return csv_path\n csv_file = open(csv_path, 'w')\n csv_file.write(self.mmi_to_delimited_text())\n csv_file.close()\n csvt_path = os.path.join(\n self.output_dir, self.output_basename + '.csvt')\n csvt_file = open(csvt_path, 'w')\n csvt_file.write('\"Real\",\"Real\",\"Real\"')\n csvt_file.close()\n return csv_path", "docstring": "Save mmi_data to delimited text file suitable for gdal_grid.\n\n The output file will be of the same format as strings returned from\n :func:`mmi_to_delimited_text`.\n\n :param force_flag: Whether to force the regeneration of the output\n file. Defaults to False.\n :type force_flag: bool\n\n :returns: The absolute file system path to the delimited text file.\n :rtype: str\n\n .. note:: An accompanying .csvt will be created which gdal uses to\n determine field types. The csvt will contain the following string:\n \"Real\",\"Real\",\"Real\". These types will be used in other conversion\n operations. For example to convert the csv to a shp you would do::\n\n ogr2ogr -select mmi -a_srs EPSG:4326 mmi.shp mmi.vrt mmi" }, { "code": "def updateActiveMarkupClass(self):\n\t\tpreviousMarkupClass = self.activeMarkupClass\n\t\tself.activeMarkupClass = find_markup_class_by_name(globalSettings.defaultMarkup)\n\t\tif self._fileName:\n\t\t\tmarkupClass = get_markup_for_file_name(\n\t\t\t\tself._fileName, return_class=True)\n\t\t\tif markupClass:\n\t\t\t\tself.activeMarkupClass = markupClass\n\t\tif self.activeMarkupClass != previousMarkupClass:\n\t\t\tself.highlighter.docType = self.activeMarkupClass.name if self.activeMarkupClass else None\n\t\t\tself.highlighter.rehighlight()\n\t\t\tself.activeMarkupChanged.emit()\n\t\t\tself.triggerPreviewUpdate()", "docstring": "Update the active markup class based on the default class and\n\t\tthe current filename. If the active markup class changes, the\n\t\thighlighter is rerun on the input text, the markup object of\n\t\tthis tab is replaced with one of the new class and the\n\t\tactiveMarkupChanged signal is emitted." }, { "code": "def copy_assets(self, path='assets'):\n\t\tpath = os.path.join(self.root_path, path)\n\t\tfor root, _, files in os.walk(path):\n\t\t\tfor file in files:\n\t\t\t\tfullpath = os.path.join(root, file)\n\t\t\t\trelpath = os.path.relpath(fullpath, path)\n\t\t\t\tcopy_to = os.path.join(self._get_dist_path(relpath, directory='assets'))\n\t\t\t\tLOG.debug('copying %r to %r', fullpath, copy_to)\n\t\t\t\tshutil.copyfile(fullpath, copy_to)", "docstring": "Copy assets into the destination directory." }, { "code": "def delete_user(self, id):\n self.assert_has_permission('scim.write')\n uri = self.uri + '/Users/%s' % id\n headers = self._get_headers()\n logging.debug(\"URI=\" + str(uri))\n logging.debug(\"HEADERS=\" + str(headers))\n response = self.session.delete(uri, headers=headers)\n logging.debug(\"STATUS=\" + str(response.status_code))\n if response.status_code == 200:\n return response\n else:\n logging.error(response.content)\n response.raise_for_status()", "docstring": "Delete user with given id." }, { "code": "def iter_sources(self):\n for src_id in xrange(self.get_source_count()):\n yield src_id, self.get_source_name(src_id)", "docstring": "Iterates over all source names and IDs." }, { "code": "def _realwavelets(s_freq, freqs, dur, width):\n x = arange(-dur / 2, dur / 2, 1 / s_freq)\n wavelets = empty((len(freqs), len(x)))\n g = exp(-(pi * x ** 2) / width ** 2)\n for i, one_freq in enumerate(freqs):\n y = cos(2 * pi * x * one_freq)\n wavelets[i, :] = y * g\n return wavelets", "docstring": "Create real wavelets, for UCSD.\n\n Parameters\n ----------\n s_freq : int\n sampling frequency\n freqs : ndarray\n vector with frequencies of interest\n dur : float\n duration of the wavelets in s\n width : float\n parameter controlling gaussian shape\n\n Returns\n -------\n ndarray\n wavelets" }, { "code": "def klucher(surface_tilt, surface_azimuth, dhi, ghi, solar_zenith,\n solar_azimuth):\n r\n cos_tt = aoi_projection(surface_tilt, surface_azimuth,\n solar_zenith, solar_azimuth)\n cos_tt = np.maximum(cos_tt, 0)\n F = 1 - ((dhi / ghi) ** 2)\n try:\n F.fillna(0, inplace=True)\n except AttributeError:\n F = np.where(np.isnan(F), 0, F)\n term1 = 0.5 * (1 + tools.cosd(surface_tilt))\n term2 = 1 + F * (tools.sind(0.5 * surface_tilt) ** 3)\n term3 = 1 + F * (cos_tt ** 2) * (tools.sind(solar_zenith) ** 3)\n sky_diffuse = dhi * term1 * term2 * term3\n return sky_diffuse", "docstring": "r'''\n Determine diffuse irradiance from the sky on a tilted surface\n using Klucher's 1979 model\n\n .. math::\n\n I_{d} = DHI \\frac{1 + \\cos\\beta}{2} (1 + F' \\sin^3(\\beta/2))\n (1 + F' \\cos^2\\theta\\sin^3\\theta_z)\n\n where\n\n .. math::\n\n F' = 1 - (I_{d0} / GHI)\n\n Klucher's 1979 model determines the diffuse irradiance from the sky\n (ground reflected irradiance is not included in this algorithm) on a\n tilted surface using the surface tilt angle, surface azimuth angle,\n diffuse horizontal irradiance, direct normal irradiance, global\n horizontal irradiance, extraterrestrial irradiance, sun zenith\n angle, and sun azimuth angle.\n\n Parameters\n ----------\n surface_tilt : numeric\n Surface tilt angles in decimal degrees. surface_tilt must be >=0\n and <=180. The tilt angle is defined as degrees from horizontal\n (e.g. surface facing up = 0, surface facing horizon = 90)\n\n surface_azimuth : numeric\n Surface azimuth angles in decimal degrees. surface_azimuth must\n be >=0 and <=360. The Azimuth convention is defined as degrees\n east of north (e.g. North = 0, South=180 East = 90, West = 270).\n\n dhi : numeric\n Diffuse horizontal irradiance in W/m^2. DHI must be >=0.\n\n ghi : numeric\n Global irradiance in W/m^2. DNI must be >=0.\n\n solar_zenith : numeric\n Apparent (refraction-corrected) zenith angles in decimal\n degrees. solar_zenith must be >=0 and <=180.\n\n solar_azimuth : numeric\n Sun azimuth angles in decimal degrees. solar_azimuth must be >=0\n and <=360. The Azimuth convention is defined as degrees east of\n north (e.g. North = 0, East = 90, West = 270).\n\n Returns\n -------\n diffuse : numeric\n The sky diffuse component of the solar radiation.\n\n References\n ----------\n [1] Loutzenhiser P.G. et. al. \"Empirical validation of models to compute\n solar irradiance on inclined surfaces for building energy simulation\"\n 2007, Solar Energy vol. 81. pp. 254-267\n\n [2] Klucher, T.M., 1979. Evaluation of models to predict insolation on\n tilted surfaces. Solar Energy 23 (2), 111-114." }, { "code": "def toggle_badge(self, kind):\n badge = self.get_badge(kind)\n if badge:\n return self.remove_badge(kind)\n else:\n return self.add_badge(kind)", "docstring": "Toggle a bdage given its kind" }, { "code": "def _cache_get_for_dn(self, dn: str) -> Dict[str, bytes]:\n self._do_with_retry(\n lambda obj: obj.search(\n dn,\n '(objectclass=*)',\n ldap3.BASE,\n attributes=['*', '+']))\n results = self._obj.response\n if len(results) < 1:\n raise NoSuchObject(\"No results finding current value\")\n if len(results) > 1:\n raise RuntimeError(\"Too many results finding current value\")\n return results[0]['raw_attributes']", "docstring": "Object state is cached. When an update is required the update will be\n simulated on this cache, so that rollback information can be correct.\n This function retrieves the cached data." }, { "code": "def is_won(grid):\n \"Did the latest move win the game?\"\n p, q = grid\n return any(way == (way & q) for way in ways_to_win)", "docstring": "Did the latest move win the game?" }, { "code": "def get_id_head(self):\n id_head = None\n for target_node in self:\n if target_node.is_head():\n id_head = target_node.get_id()\n break\n return id_head", "docstring": "Returns the id of the target that is set as \"head\"\n @rtype: string\n @return: the target id (or None) of the head target" }, { "code": "def assess_content(member,file_filter):\n member_path = member.name.replace('.','',1)\n if len(member_path) == 0:\n return False\n if \"skip_files\" in file_filter:\n if member_path in file_filter['skip_files']:\n return False\n if \"assess_content\" in file_filter:\n if member_path in file_filter['assess_content']:\n return True\n return False", "docstring": "Determine if the filter wants the file to be read for content.\n In the case of yes, we would then want to add the content to the\n hash and not the file object." }, { "code": "def scale_samples(params, bounds):\n b = np.array(bounds)\n lower_bounds = b[:, 0]\n upper_bounds = b[:, 1]\n if np.any(lower_bounds >= upper_bounds):\n raise ValueError(\"Bounds are not legal\")\n np.add(np.multiply(params,\n (upper_bounds - lower_bounds),\n out=params),\n lower_bounds,\n out=params)", "docstring": "Rescale samples in 0-to-1 range to arbitrary bounds\n\n Arguments\n ---------\n bounds : list\n list of lists of dimensions `num_params`-by-2\n params : numpy.ndarray\n numpy array of dimensions `num_params`-by-:math:`N`,\n where :math:`N` is the number of samples" }, { "code": "def get_duration_metadata(self):\n metadata = dict(self._mdata['duration'])\n metadata.update({'existing_duration_values': self._my_map['duration']})\n return Metadata(**metadata)", "docstring": "Gets the metadata for the assessment duration.\n\n return: (osid.Metadata) - metadata for the duration\n *compliance: mandatory -- This method must be implemented.*" }, { "code": "def _in(ins):\n output = _16bit_oper(ins.quad[1])\n output.append('ld b, h')\n output.append('ld c, l')\n output.append('in a, (c)')\n output.append('push af')\n return output", "docstring": "Translates IN to asm." }, { "code": "def encrypt(self, s, mac_bytes=10):\n if isinstance(s, six.text_type):\n raise ValueError(\n \"Encode `s` to a bytestring yourself to\" +\n \" prevent problems with different default encodings\")\n out = BytesIO()\n with self.encrypt_to(out, mac_bytes) as f:\n f.write(s)\n return out.getvalue()", "docstring": "Encrypt `s' for this pubkey." }, { "code": "def _metadata_is_invalid(cls, fact):\n return any(isinstance(token, URIRef) and ' ' in token\n for token in fact)", "docstring": "Determines if the fact is not well formed." }, { "code": "def post(self, path, auth=None, **kwargs):\n return self._check_ok(self._post(path, auth=auth, **kwargs))", "docstring": "Manually make a POST request.\n\n :param str path: relative url of the request (e.g. `/users/username`)\n :param auth.Authentication auth: authentication object\n :param kwargs dict: Extra arguments for the request, as supported by the\n `requests `_ library.\n :raises NetworkFailure: if there is an error communicating with the server\n :raises ApiFailure: if the request cannot be serviced" }, { "code": "def add_context_action(self, action):\n self.main_tab_widget.context_actions.append(action)\n for child_splitter in self.child_splitters:\n child_splitter.add_context_action(action)", "docstring": "Adds a custom context menu action\n\n :param action: action to add." }, { "code": "def rolling_window_sequences(X, index, window_size, target_size, target_column):\n out_X = list()\n out_y = list()\n X_index = list()\n y_index = list()\n target = X[:, target_column]\n for start in range(len(X) - window_size - target_size + 1):\n end = start + window_size\n out_X.append(X[start:end])\n out_y.append(target[end:end + target_size])\n X_index.append(index[start])\n y_index.append(index[end])\n return np.asarray(out_X), np.asarray(out_y), np.asarray(X_index), np.asarray(y_index)", "docstring": "Create rolling window sequences out of timeseries data." }, { "code": "def redirect_logging(tqdm_obj, logger=logging.getLogger()):\n assert(len(logger.handlers) == 1)\n prev_handler = logger.handlers[0]\n logger.removeHandler(prev_handler)\n tqdm_handler = TqdmLoggingHandler(tqdm_obj)\n if prev_handler.formatter is not None:\n tqdm_handler.setFormatter(prev_handler.formatter)\n logger.addHandler(tqdm_handler)\n try:\n yield\n finally:\n logger.removeHandler(tqdm_handler)\n logger.addHandler(prev_handler)", "docstring": "Context manager to redirect logging to a TqdmLoggingHandler object and then restore the original." }, { "code": "def horizon_dashboard_nav(context):\n if 'request' not in context:\n return {}\n dashboard = context['request'].horizon['dashboard']\n panel_groups = dashboard.get_panel_groups()\n non_empty_groups = []\n for group in panel_groups.values():\n allowed_panels = []\n for panel in group:\n if (callable(panel.nav) and panel.nav(context) and\n panel.can_access(context)):\n allowed_panels.append(panel)\n elif (not callable(panel.nav) and panel.nav and\n panel.can_access(context)):\n allowed_panels.append(panel)\n if allowed_panels:\n if group.name is None:\n non_empty_groups.append((dashboard.name, allowed_panels))\n else:\n non_empty_groups.append((group.name, allowed_panels))\n return {'components': OrderedDict(non_empty_groups),\n 'user': context['request'].user,\n 'current': context['request'].horizon['panel'].slug,\n 'request': context['request']}", "docstring": "Generates sub-navigation entries for the current dashboard." }, { "code": "def lookup_function(val):\n\t\"Look-up and return a pretty-printer that can print va.\"\n\ttype = val.type\n\tif type.code == gdb.TYPE_CODE_REF:\n\t\ttype = type.target()\n\ttype = type.unqualified().strip_typedefs()\n\ttypename = type.tag\n\tif typename == None:\n\t\treturn None\n\tfor function in pretty_printers_dict:\n\t\tif function.search(typename):\n\t\t\treturn pretty_printers_dict[function](val)\n\treturn None", "docstring": "Look-up and return a pretty-printer that can print va." }, { "code": "def start(self):\n self.parse_opt()\n self.parse_cfg()\n if self.options.browse or self.options.browse_big or self.options.progress:\n self.browse()\n raise SystemExit\n paramlist = []\n for exp in self.cfgparser.sections():\n if not self.options.experiments or exp in self.options.experiments:\n params = self.items_to_params(self.cfgparser.items(exp))\n params['name'] = exp\n paramlist.append(params)\n self.do_experiment(paramlist)", "docstring": "starts the experiments as given in the config file." }, { "code": "def date_to_datetime(self, time_input, tz=None):\n dt = None\n try:\n dt = parser.parse(time_input)\n if tz is not None and tz != dt.tzname():\n if dt.tzinfo is None:\n dt = self._replace_timezone(dt)\n dt = dt.astimezone(timezone(tz))\n except IndexError:\n pass\n except TypeError:\n pass\n except ValueError:\n pass\n return dt", "docstring": "Convert ISO 8601 and other date strings to datetime.datetime type.\n\n Args:\n time_input (string): The time input string (see formats above).\n tz (string): The time zone for the returned data.\n\n Returns:\n (datetime.datetime): Python datetime.datetime object." }, { "code": "def _on_wheel_event(self, event):\n try:\n delta = event.angleDelta().y()\n except AttributeError:\n delta = event.delta()\n if int(event.modifiers()) & QtCore.Qt.ControlModifier > 0:\n if delta < self.prev_delta:\n self.editor.zoom_out()\n event.accept()\n else:\n self.editor.zoom_in()\n event.accept()", "docstring": "Increments or decrements editor fonts settings on mouse wheel event\n if ctrl modifier is on.\n\n :param event: wheel event\n :type event: QWheelEvent" }, { "code": "def display_exc(self):\n errmsg = self.get_error()\n if errmsg is not None:\n if self.path is not None:\n errmsg_lines = [\"in \" + self.path + \":\"]\n for line in errmsg.splitlines():\n if line:\n line = \" \" * taberrfmt + line\n errmsg_lines.append(line)\n errmsg = \"\\n\".join(errmsg_lines)\n printerr(errmsg)", "docstring": "Properly prints an exception in the exception context." }, { "code": "def load_event_list(filename, **kwargs):\n return dcase_util.containers.MetaDataContainer().load(filename=filename, **kwargs)", "docstring": "Load event list from csv formatted text-file\n\n Supported formats (see more `dcase_util.containers.MetaDataContainer.load()` method):\n\n - [event onset (float >= 0)][delimiter][event offset (float >= 0)]\n - [event onset (float >= 0)][delimiter][event offset (float >= 0)][delimiter][label]\n - [filename][delimiter][event onset (float >= 0)][delimiter][event offset (float >= 0)][delimiter][event label]\n - [filename][delimiter][scene_label][delimiter][event onset (float >= 0)][delimiter][event offset (float >= 0)][delimiter][event label]\n - [filename]\n\n Supported delimiters: ``,``, ``;``, ``tab``\n\n Example of event list file::\n\n 21.64715\t23.00552\talert\n 36.91184\t38.27021\talert\n 69.72575\t71.09029\talert\n 63.53990\t64.89827\talert\n 84.25553\t84.83920\talert\n 20.92974\t21.82661\tclearthroat\n 28.39992\t29.29679\tclearthroat\n 80.47837\t81.95937\tclearthroat\n 44.48363\t45.96463\tclearthroat\n 78.13073\t79.05953\tclearthroat\n 15.17031\t16.27235\tcough\n 20.54931\t21.65135\tcough\n 27.79964\t28.90168\tcough\n 75.45959\t76.32490\tcough\n 70.81708\t71.91912\tcough\n 21.23203\t22.55902\tdoorslam\n 7.546220\t9.014880\tdoorslam\n 34.11303\t35.04183\tdoorslam\n 45.86001\t47.32867\tdoorslam\n\n\n Parameters\n ----------\n filename : str\n Path to the csv-file\n\n Returns\n -------\n list of dict\n Event list" }, { "code": "def iiscgi(application):\n\ttry:\n\t\tfrom wsgiref.handlers import IISCGIHandler\n\texcept ImportError:\n\t\tprint(\"Python 3.2 or newer is required.\")\n\tif not __debug__:\n\t\twarnings.warn(\"Interactive debugging and other persistence-based processes will not work.\")\n\tIISCGIHandler().run(application)", "docstring": "A specialized version of the reference WSGI-CGI server to adapt to Microsoft IIS quirks.\n\t\n\tThis is not a production quality interface and will behave badly under load." }, { "code": "def emit_containers(self, containers, verbose=True):\n containers = sorted(containers, key=lambda c: c.get('name'))\n task_definition = {\n 'family': self.family,\n 'containerDefinitions': containers,\n 'volumes': self.volumes or []\n }\n if verbose:\n return json.dumps(task_definition, indent=4, sort_keys=True)\n else:\n return json.dumps(task_definition)", "docstring": "Emits the task definition and sorts containers by name\n\n :param containers: List of the container definitions\n :type containers: list of dict\n\n :param verbose: Print out newlines and indented JSON\n :type verbose: bool\n\n :returns: The text output\n :rtype: str" }, { "code": "def create_config(name=None,\n subvolume=None,\n fstype=None,\n template=None,\n extra_opts=None):\n def raise_arg_error(argname):\n raise CommandExecutionError(\n 'You must provide a \"{0}\" for the new configuration'.format(argname)\n )\n if not name:\n raise_arg_error(\"name\")\n if not subvolume:\n raise_arg_error(\"subvolume\")\n if not fstype:\n raise_arg_error(\"fstype\")\n if not template:\n template = \"\"\n try:\n snapper.CreateConfig(name, subvolume, fstype, template)\n if extra_opts:\n set_config(name, **extra_opts)\n return get_config(name)\n except dbus.DBusException as exc:\n raise CommandExecutionError(\n 'Error encountered while creating the new configuration: {0}'\n .format(_dbus_exception_to_reason(exc, locals()))\n )", "docstring": "Creates a new Snapper configuration\n\n name\n Name of the new Snapper configuration.\n subvolume\n Path to the related subvolume.\n fstype\n Filesystem type of the subvolume.\n template\n Configuration template to use. (Default: default)\n extra_opts\n Extra Snapper configuration opts dictionary. It will override the values provided\n by the given template (if any).\n\n CLI example:\n\n .. code-block:: bash\n\n salt '*' snapper.create_config name=myconfig subvolume=/foo/bar/ fstype=btrfs\n salt '*' snapper.create_config name=myconfig subvolume=/foo/bar/ fstype=btrfs template=\"default\"\n salt '*' snapper.create_config name=myconfig subvolume=/foo/bar/ fstype=btrfs extra_opts='{\"NUMBER_CLEANUP\": False}'" }, { "code": "def register_components(self):\n unregistered_components = []\n for path in self.paths:\n for file in foundations.walkers.files_walker(path, (\"\\.{0}$\".format(self.__extension),), (\"\\._\",)):\n if not self.register_component(file):\n unregistered_components.append(file)\n if not unregistered_components:\n return True\n else:\n raise manager.exceptions.ComponentRegistrationError(\n \"{0} | '{1}' Components failed to register!\".format(self.__class__.__name__,\n \", \".join(unregistered_components)))", "docstring": "Registers the Components.\n\n Usage::\n\n >>> manager = Manager((\"./manager/tests/tests_manager/resources/components/core\",))\n >>> manager.register_components()\n True\n >>> manager.components.keys()\n [u'core.tests_component_a', u'core.tests_component_b']\n\n :return: Method success.\n :rtype: bool" }, { "code": "def get_all_external_accounts(resource_root, type_name, view=None):\n return call(resource_root.get,\n EXTERNAL_ACCOUNT_FETCH_PATH % (\"type\", type_name,),\n ApiExternalAccount, True, params=view and dict(view=view) or None)", "docstring": "Lookup all external accounts of a particular type, by type name.\n @param resource_root: The root Resource object.\n @param type_name: Type name\n @param view: View\n @return: An ApiList of ApiExternalAccount objects matching the specified type" }, { "code": "def addUnexpectedSuccess(self, test):\n result = self._handle_result(\n test, TestCompletionStatus.unexpected_success)\n self.unexpectedSuccesses.append(result)", "docstring": "Register a test that passed unexpectedly.\n\n Parameters\n ----------\n test : unittest.TestCase\n The test that has completed." }, { "code": "def get_what_follows_raw(s: str,\n prefix: str,\n onlyatstart: bool = True,\n stripwhitespace: bool = True) -> Tuple[bool, str]:\n prefixstart = s.find(prefix)\n if ((prefixstart == 0 and onlyatstart) or\n (prefixstart != -1 and not onlyatstart)):\n resultstart = prefixstart + len(prefix)\n result = s[resultstart:]\n if stripwhitespace:\n result = result.strip()\n return True, result\n return False, \"\"", "docstring": "Find the part of ``s`` that is after ``prefix``.\n\n Args:\n s: string to analyse\n prefix: prefix to find\n onlyatstart: only accept the prefix if it is right at the start of\n ``s``\n stripwhitespace: remove whitespace from the result\n\n Returns:\n tuple: ``(found, result)``" }, { "code": "def get_all():\n info_dir = _get_info_dir()\n results = []\n for filename in os.listdir(info_dir):\n filepath = os.path.join(info_dir, filename)\n try:\n with open(filepath) as infile:\n contents = infile.read()\n except IOError as e:\n if e.errno == errno.EACCES:\n continue\n else:\n raise\n try:\n info = _info_from_string(contents)\n except ValueError:\n tb_logging.get_logger().warning(\n \"invalid info file: %r\",\n filepath,\n exc_info=True,\n )\n else:\n results.append(info)\n return results", "docstring": "Return TensorBoardInfo values for running TensorBoard processes.\n\n This function may not provide a perfect snapshot of the set of running\n processes. Its result set may be incomplete if the user has cleaned\n their /tmp/ directory while TensorBoard processes are running. It may\n contain extraneous entries if TensorBoard processes exited uncleanly\n (e.g., with SIGKILL or SIGQUIT).\n\n Returns:\n A fresh list of `TensorBoardInfo` objects." }, { "code": "def drop_columns(self, colnames, **kwargs):\n new_arr = rfn.drop_fields(\n self, colnames, usemask=False, asrecarray=True, **kwargs\n )\n return self.__class__(\n new_arr,\n h5loc=self.h5loc,\n split_h5=self.split_h5,\n name=self.name,\n h5singleton=self.h5singleton\n )", "docstring": "Drop columns from the table.\n\n See the docs for ``numpy.lib.recfunctions.drop_fields`` for an\n explanation of the remaining options." }, { "code": "def reference(self):\n if self.__reference is None:\n self.__reference = _ConstructReference(self.__class__,\n pairs=self.__pairs,\n app=self.__app,\n namespace=self.__namespace)\n return self.__reference", "docstring": "Return the Reference object for this Key.\n\n This is a entity_pb.Reference instance -- a protocol buffer class\n used by the lower-level API to the datastore.\n\n NOTE: The caller should not mutate the return value." }, { "code": "def add_relationship(self, term1, relationship, term2):\n url = self.base_path + 'term/add-relationship'\n data = {'term1_id': term1['id'],\n 'relationship_tid': relationship['id'],\n 'term2_id': term2['id'],\n 'term1_version': term1['version'],\n 'relationship_term_version': relationship['version'],\n 'term2_version': term2['version']}\n return self.post(url, data)", "docstring": "Creates a relationship between 3 entities in database" }, { "code": "def step(self, provided_inputs):\n for wire, value in provided_inputs.items():\n wire = self.block.get_wirevector_by_name(wire) if isinstance(wire, str) else wire\n if value > wire.bitmask or value < 0:\n raise PyrtlError(\"Wire {} has value {} which cannot be represented\"\n \" using its bitwidth\".format(wire, value))\n ins = {self._to_name(wire): value for wire, value in provided_inputs.items()}\n ins.update(self.regs)\n ins.update(self.mems)\n self.regs, self.outs, mem_writes = self.sim_func(ins)\n for mem, addr, value in mem_writes:\n self.mems[mem][addr] = value\n self.context = self.outs.copy()\n self.context.update(ins)\n if self.tracer is not None:\n self.tracer.add_fast_step(self)\n check_rtl_assertions(self)", "docstring": "Run the simulation for a cycle\n\n :param provided_inputs: a dictionary mapping WireVectors (or their names)\n to their values for this step\n eg: {wire: 3, \"wire_name\": 17}" }, { "code": "def get_background_sids(self, src_filter):\n branch_key = self.idx_set[\"grid_key\"]\n idist = src_filter.integration_distance(DEFAULT_TRT)\n with h5py.File(self.source_file, 'r') as hdf5:\n bg_locations = hdf5[\"Grid/Locations\"].value\n distances = min_geodetic_distance(\n src_filter.sitecol.xyz,\n (bg_locations[:, 0], bg_locations[:, 1]))\n mmax_areas = self.msr.get_median_area(\n hdf5[\"/\".join([\"Grid\", branch_key, \"MMax\"])].value, 0.0)\n mmax_lengths = numpy.sqrt(mmax_areas / self.aspect)\n ok = distances <= (0.5 * mmax_lengths + idist)\n return numpy.where(ok)[0].tolist()", "docstring": "We can apply the filtering of the background sites as a pre-processing\n step - this is done here rather than in the sampling of the ruptures\n themselves" }, { "code": "def get(self, key, fallback=None):\n value = None\n if key in self._config:\n value = self._config[key]\n if isinstance(value, Section):\n value = None\n if value is None:\n value = fallback\n return value", "docstring": "look up global config values from alot's config\n\n :param key: key to look up\n :type key: str\n :param fallback: fallback returned if key is not present\n :type fallback: str\n :returns: config value with type as specified in the spec-file" }, { "code": "def delete(self, db_session=None):\n db_session = get_db_session(db_session, self)\n db_session.delete(self)", "docstring": "Deletes the object via session, this will permanently delete the\n object from storage on commit\n\n :param db_session:\n :return:" }, { "code": "def _range_along_dimension(range_dim, shape):\n rank = len(shape)\n if range_dim >= rank:\n raise ValueError(\"Cannot calculate range along non-existent index.\")\n indices = tf.range(start=0, limit=shape[range_dim])\n indices = tf.reshape(\n indices,\n shape=[1 if i != range_dim else shape[range_dim] for i in range(rank)])\n return tf.tile(indices,\n [shape[i] if i != range_dim else 1 for i in range(rank)])", "docstring": "Construct a Tensor whose values are the index along a dimension.\n\n Construct a Tensor that counts the distance along a single dimension. This is\n useful, for example, when constructing an identity matrix,\n\n >>> x = _range_along_dimension(0, [2, 2]).eval()\n >>> x\n array([[0, 0],\n [1, 1]], dtype=int32)\n\n >>> y = _range_along_dimension(1, [2, 2]).eval()\n >>> y\n array([[0, 1],\n [0, 1]], dtype=int32)\n\n >>> tf.cast(tf.equal(x, y), dtype=tf.int32).eval()\n array([[1, 0],\n [0, 1]], dtype=int32)\n\n Args:\n range_dim: int. Dimension to count indices on.\n shape: 1D Tensor of ints. Shape of Tensor to construct.\n\n Returns:\n A Tensor whose values are the same as the range along dimension range_dim.\n\n Raises:\n ValueError: If range_dim isn't a valid dimension." }, { "code": "def toggle(path_or_id, badge_kind):\n if exists(path_or_id):\n with open(path_or_id) as open_file:\n for id_or_slug in open_file.readlines():\n toggle_badge(id_or_slug.strip(), badge_kind)\n else:\n toggle_badge(path_or_id, badge_kind)", "docstring": "Toggle a `badge_kind` for a given `path_or_id`\n\n The `path_or_id` is either an id, a slug or a file containing a list\n of ids or slugs." }, { "code": "def GetName(obj):\n precondition.AssertType(obj, (type, types.FunctionType))\n if PY2:\n return obj.__name__.decode(\"ascii\")\n else:\n return obj.__name__", "docstring": "A compatibility wrapper for getting object's name.\n\n In Python 2 class names are returned as `bytes` (since class names can contain\n only ASCII characters) whereas in Python 3 they are `unicode` (since class\n names can contain arbitrary unicode characters).\n\n This function makes this behaviour consistent and always returns class name as\n an unicode string.\n\n Once support for Python 2 is dropped all invocations of this call can be\n replaced with ordinary `__name__` access.\n\n Args:\n obj: A type or function object to get the name for.\n\n Returns:\n Name of the specified class as unicode string." }, { "code": "def drop_namespaces(self):\n self.session.query(NamespaceEntry).delete()\n self.session.query(Namespace).delete()\n self.session.commit()", "docstring": "Drop all namespaces." }, { "code": "def load_file(self, file):\n if not foundations.common.path_exists(file):\n raise foundations.exceptions.FileExistsError(\n \"{0} | '{1}' file doesn't exists!\".format(self.__class__.__name__,\n file))\n LOGGER.debug(\"> Loading '{0}' file.\".format(file))\n reader = foundations.io.File(file)\n self.setPlainText(reader.read())\n self.set_file(file)\n self.__set_document_signals()\n self.file_loaded.emit()\n return True", "docstring": "Reads and loads given file into the editor.\n\n :param File: File to load.\n :type File: unicode\n :return: Method success.\n :rtype: bool" }, { "code": "def deserialize(self, data, status_code):\n if status_code == 204:\n return data\n return serializer.Serializer().deserialize(\n data)['body']", "docstring": "Deserializes a JSON string into a dictionary." }, { "code": "def _get_bmu(self, activations):\n if self.argfunc == 'argmax':\n activations = -activations\n sort = np.argsort(activations, 1)\n return sort.argsort()", "docstring": "Get indices of bmus, sorted by their distance from input." }, { "code": "def imread(path, grayscale=False, size=None, interpolate=\"bilinear\",\n channel_first=False, as_uint16=False, num_channels=-1):\n _imread_before(grayscale, num_channels)\n r_mode = cv2.IMREAD_GRAYSCALE if grayscale else cv2.IMREAD_UNCHANGED\n img = _imread_helper(path, r_mode)\n if as_uint16 and img.dtype != np.uint16:\n if img.dtype == np.uint8:\n logger.warning(\"You want to read image as uint16, but the original bit-depth is 8 bit.\"\n \"All pixel values are simply increased by 256 times.\")\n img = img.astype(np.uint16) * 256\n else:\n raise ValueError(\n \"casting {} to uint16 is not safe.\".format(img.dtype))\n img = _cvtColor_helper(img, num_channels)\n img = _imread_after(img, size, interpolate, channel_first, imresize)\n return img", "docstring": "Read image by cv2 module.\n\n Args:\n path (str or 'file object'): File path or object to read.\n grayscale (bool):\n size (tupple of int):\n (width, height).\n If None, output img shape depends on the files to read.\n channel_first (bool):\n This argument specifies the shape of img is whether (height, width, channel) or (channel, height, width).\n Default value is False, which means the img shape is (height, width, channel).\n interpolate (str):\n must be one of [\"nearest\", \"box\", \"bilinear\", \"hamming\", \"bicubic\", \"lanczos\"].\n as_uint16 (bool):\n If True, this function reads image as uint16.\n num_channels (int):\n channel size of output array.\n Default is -1 which preserves raw image shape.\n\n Returns:\n numpy.ndarray" }, { "code": "def create_primary_zone_by_axfr(self, account_name, zone_name, master, tsig_key=None, key_value=None):\n zone_properties = {\"name\": zone_name, \"accountName\": account_name, \"type\": \"PRIMARY\"}\n if tsig_key is not None and key_value is not None:\n name_server_info = {\"ip\": master, \"tsigKey\": tsig_key, \"tsigKeyValue\": key_value}\n else:\n name_server_info = {\"ip\": master}\n primary_zone_info = {\"forceImport\": True, \"createType\": \"TRANSFER\", \"nameServer\": name_server_info}\n zone_data = {\"properties\": zone_properties, \"primaryCreateInfo\": primary_zone_info}\n return self.rest_api_connection.post(\"/v1/zones\", json.dumps(zone_data))", "docstring": "Creates a new primary zone by zone transferring off a master.\n\n Arguments:\n account_name -- The name of the account that will contain this zone.\n zone_name -- The name of the zone. It must be unique.\n master -- Primary name server IP address.\n\n Keyword Arguments:\n tsig_key -- For TSIG-enabled zones: The transaction signature key.\n NOTE: Requires key_value.\n key_value -- TSIG key secret." }, { "code": "def coinc(self, s0, s1, slide, step):\n loglr = - s0 - s1\n threshes = [self.fits_by_tid[i]['thresh'] for i in self.ifos]\n loglr += sum([t**2. / 2. for t in threshes])\n return (2. * loglr) ** 0.5", "docstring": "Calculate the final coinc ranking statistic" }, { "code": "def expect(instr, expected, context):\n if not isinstance(instr, expected):\n raise DecompilationError(\n \"Expected a {expected} instruction {context}. Got {instr}.\".format(\n instr=instr, expected=expected, context=context,\n )\n )\n return instr", "docstring": "Check that an instruction is of the expected type." }, { "code": "def annotatedcore(self):\n logging.info('Calculating annotated core')\n self.total_core()\n for sample in self.metadata:\n if sample.general.bestassemblyfile != 'NA':\n sample[self.analysistype].coreset = set()\n if sample.general.referencegenus == 'Escherichia':\n self.runmetadata.samples.append(sample)\n try:\n report = sample[self.analysistype].report\n self.blastparser(report=report,\n sample=sample,\n fieldnames=self.fieldnames)\n except KeyError:\n sample[self.analysistype].coreset = list()\n self.reporter()", "docstring": "Calculates the core genome of organisms using custom databases" }, { "code": "def attach(self, engine, start=Events.STARTED, pause=Events.COMPLETED, resume=None, step=None):\n engine.add_event_handler(start, self.reset)\n engine.add_event_handler(pause, self.pause)\n if resume is not None:\n engine.add_event_handler(resume, self.resume)\n if step is not None:\n engine.add_event_handler(step, self.step)\n return self", "docstring": "Register callbacks to control the timer.\n\n Args:\n engine (Engine):\n Engine that this timer will be attached to.\n start (Events):\n Event which should start (reset) the timer.\n pause (Events):\n Event which should pause the timer.\n resume (Events, optional):\n Event which should resume the timer.\n step (Events, optional):\n Event which should call the `step` method of the counter.\n\n Returns:\n self (Timer)" }, { "code": "def reactivate(self):\n self._protocol.connectionLost(None)\n self._protocol = None\n self.terminal.reset()\n self._window.filthy()\n self._window.repaint()", "docstring": "Called when a sub-protocol is finished. This disconnects the\n sub-protocol and redraws the main menu UI." }, { "code": "def generate_sigv4_auth_request(header_value=None):\n request = requests.Request(\n method='POST',\n url='https://sts.amazonaws.com/',\n headers={'Content-Type': 'application/x-www-form-urlencoded; charset=utf-8', 'Host': 'sts.amazonaws.com'},\n data='Action=GetCallerIdentity&Version=2011-06-15',\n )\n if header_value:\n request.headers['X-Vault-AWS-IAM-Server-ID'] = header_value\n prepared_request = request.prepare()\n return prepared_request", "docstring": "Helper function to prepare a AWS API request to subsequently generate a \"AWS Signature Version 4\" header.\n\n :param header_value: Vault allows you to require an additional header, X-Vault-AWS-IAM-Server-ID, to be present\n to mitigate against different types of replay attacks. Depending on the configuration of the AWS auth\n backend, providing a argument to this optional parameter may be required.\n :type header_value: str\n :return: A PreparedRequest instance, optionally containing the provided header value under a\n 'X-Vault-AWS-IAM-Server-ID' header name pointed to AWS's simple token service with action \"GetCallerIdentity\"\n :rtype: requests.PreparedRequest" }, { "code": "def get_descriptions(self, description_type):\n (desc_type, max_units) = description_type\n results = [None] * max_units\n self.elk._descriptions_in_progress[desc_type] = (max_units,\n results,\n self._got_desc)\n self.elk.send(sd_encode(desc_type=desc_type, unit=0))", "docstring": "Gets the descriptions for specified type.\n When complete the callback is called with a list of descriptions" }, { "code": "def enter_room(self, sid, namespace, room):\n if namespace not in self.rooms:\n self.rooms[namespace] = {}\n if room not in self.rooms[namespace]:\n self.rooms[namespace][room] = {}\n self.rooms[namespace][room][sid] = True", "docstring": "Add a client to a room." }, { "code": "def hangup(self):\n if self.active:\n self._gsmModem.write('ATH')\n self.answered = False\n self.active = False\n if self.id in self._gsmModem.activeCalls:\n del self._gsmModem.activeCalls[self.id]", "docstring": "End the phone call.\n \n Does nothing if the call is already inactive." }, { "code": "def check(self, feature):\n found = False\n for handler in self.handlers:\n try:\n if handler(feature):\n return True\n except StopCheckingFeatureFlags:\n return False\n except NoFeatureFlagFound:\n pass\n else:\n found = True\n if not found:\n message = u\"No feature flag defined for {feature}\".format(feature=feature)\n if current_app.debug and current_app.config.get(RAISE_ERROR_ON_MISSING_FEATURES, False):\n raise KeyError(message)\n else:\n log.info(message)\n missing_feature.send(self, feature=feature)\n return False", "docstring": "Loop through all our feature flag checkers and return true if any of them are true.\n\n The order of handlers matters - we will immediately return True if any handler returns true.\n\n If you want to a handler to return False and stop the chain, raise the StopCheckingFeatureFlags exception." }, { "code": "def ordered(self, ord='desc'):\n if ord not in ('asc', 'desc', ):\n raise\n ord_f = getattr(PIDRelation.index, ord)()\n return self.order_by(ord_f)", "docstring": "Order the query result on the relations' indexes." }, { "code": "def get_settings(config_file):\n default_settings = {\n 'general': {\n 'endpoint': 'http://guacamole.antojitos.io/files/',\n 'shortener': 'http://t.antojitos.io/api/v1/urls',\n }\n }\n settings = configparser.ConfigParser()\n try:\n settings.read_dict(default_settings)\n except AttributeError:\n for section, options in default_settings.items():\n settings.add_section(section)\n for option, value in options.items():\n settings.set(section, option, value)\n if config_file is not None and os.path.exists(config_file):\n settings.read(config_file)\n return settings\n if os.path.exists(CONFIG_FILE):\n settings.read(CONFIG_FILE)\n return settings\n return settings", "docstring": "Search and load a configuration file." }, { "code": "def get_colormap(name, *args, **kwargs):\n if isinstance(name, BaseColormap):\n cmap = name\n else:\n if not isinstance(name, string_types):\n raise TypeError('colormap must be a Colormap or string name')\n if name not in _colormaps:\n raise KeyError('colormap name %s not found' % name)\n cmap = _colormaps[name]\n if inspect.isclass(cmap):\n cmap = cmap(*args, **kwargs)\n return cmap", "docstring": "Obtain a colormap\n\n Some colormaps can have additional configuration parameters. Refer to\n their corresponding documentation for more information.\n\n Parameters\n ----------\n name : str | Colormap\n Colormap name. Can also be a Colormap for pass-through.\n\n Examples\n --------\n\n >>> get_colormap('autumn')\n >>> get_colormap('single_hue', hue=10)" }, { "code": "def rm(pattern):\n paths = glob.glob(pattern)\n for path in paths:\n if path.startswith('.git/'):\n continue\n if os.path.isdir(path):\n def onerror(fun, path, excinfo):\n exc = excinfo[1]\n if exc.errno != errno.ENOENT:\n raise\n safe_print(\"rmdir -f %s\" % path)\n shutil.rmtree(path, onerror=onerror)\n else:\n safe_print(\"rm %s\" % path)\n os.remove(path)", "docstring": "Recursively remove a file or dir by pattern." }, { "code": "def create_and_configure_wrapper(context_or_world):\n context_or_world.driver_wrapper = DriverWrappersPool.get_default_wrapper()\n context_or_world.utils = context_or_world.driver_wrapper.utils\n try:\n behave_properties = context_or_world.config.userdata\n except AttributeError:\n behave_properties = None\n context_or_world.driver_wrapper.configure(context_or_world.config_files, behave_properties=behave_properties)\n context_or_world.toolium_config = context_or_world.driver_wrapper.config\n context_or_world.logger = logging.getLogger(__name__)", "docstring": "Create and configure driver wrapper in behave or lettuce tests\n\n :param context_or_world: behave context or lettuce world" }, { "code": "def iter(self, start=0, end=None):\n if end is None:\n end = self._index + 1\n elif end == 0:\n raise StopIteration()\n if start >= end:\n raise StopIteration()\n assert 0 <= end <= len(self._history)\n assert 0 <= start <= end - 1\n for i in range(start, end):\n yield self._history[i]", "docstring": "Iterate through successive history items.\n\n Parameters\n ----------\n end : int\n Index of the last item to loop through + 1.\n\n start : int\n Initial index for the loop (0 by default)." }, { "code": "def _write_to_datastore(self):\n roots_and_submissions = zip([ATTACKS_ENTITY_KEY,\n TARGET_ATTACKS_ENTITY_KEY,\n DEFENSES_ENTITY_KEY],\n [self._attacks,\n self._targeted_attacks,\n self._defenses])\n client = self._datastore_client\n with client.no_transact_batch() as batch:\n for root_key, submissions in roots_and_submissions:\n batch.put(client.entity(client.key(*root_key)))\n for k, v in iteritems(submissions):\n entity = client.entity(client.key(\n *(root_key + [KIND_SUBMISSION, k])))\n entity['submission_path'] = v.path\n entity.update(participant_from_submission_path(v.path))\n batch.put(entity)", "docstring": "Writes all submissions to datastore." }, { "code": "def list_to_bytes_list(strList):\n pList = c_char_p * len(strList)\n if isinstance(strList, (pList, type(None))):\n return strList\n if not isinstance(strList, (list, set, tuple)):\n raise TypeError(\"strList must be list, set or tuple, not \" +\n str(type(strList)))\n pList = pList()\n for i, elem in enumerate(strList):\n pList[i] = str_to_bytes(elem)\n return pList", "docstring": "This function turns an array of strings into a pointer array\n with pointers pointing to the encodings of those strings\n Possibly contained bytes are kept as they are.\n\n :param strList: List of strings that shall be converted\n :type strList: List of strings\n :returns: Pointer array with pointers pointing to bytes\n :raises: TypeError if strList is not list, set or tuple" }, { "code": "def pop_scope(self):\n child_scope = self.stack.current.current.copy()\n self.stack.current.pop()\n parent_scope = self.stack.current.current.copy()\n self.stack.current.current = {\n key: child_scope[key] for key in child_scope if key in parent_scope\n }", "docstring": "Delete the current scope in the current scope." }, { "code": "def in_reply_to(self) -> Optional[UnstructuredHeader]:\n try:\n return cast(UnstructuredHeader, self[b'in-reply-to'][0])\n except (KeyError, IndexError):\n return None", "docstring": "The ``In-Reply-To`` header." }, { "code": "def is_console(self, users_text):\n if users_text is None:\n self.log(\"Console information not collected\")\n return None\n for line in users_text.split('\\n'):\n if '*' in line:\n match = re.search(self.vty_re, line)\n if match:\n self.log(\"Detected connection to vty\")\n return False\n else:\n match = re.search(self.console_re, line)\n if match:\n self.log(\"Detected connection to console\")\n return True\n self.log(\"Connection port unknown\")\n return None", "docstring": "Return if device is connected over console." }, { "code": "def _format_volume_string(self, volume_string):\n self.actual_volume = int(volume_string.split(self.volume_string)[1].split(',')[0].split()[0])\n return '[Vol: {}%] '.format(int(100 * self.actual_volume / self.max_volume))", "docstring": "format vlc's volume" }, { "code": "def vicinity(self):\n if self._vicinity == '' and self.details != None and 'vicinity' in self.details:\n self._vicinity = self.details['vicinity']\n return self._vicinity", "docstring": "Returns a feature name of a nearby location.\n\n Often this feature refers to a street or neighborhood within the given\n results." }, { "code": "def get_messages(self, page=0):\n endpoint = 'https://outlook.office.com/api/v2.0/me/messages'\n if page > 0:\n endpoint = endpoint + '/?%24skip=' + str(page) + '0'\n log.debug('Getting messages from endpoint: {} with Headers: {}'.format(endpoint, self._headers))\n r = requests.get(endpoint, headers=self._headers)\n check_response(r)\n return Message._json_to_messages(self, r.json())", "docstring": "Get first 10 messages in account, across all folders.\n\n Keyword Args:\n page (int): Integer representing the 'page' of results to fetch\n\n Returns:\n List[:class:`Message `]" }, { "code": "def mobile_template(template):\n def decorator(f):\n @functools.wraps(f)\n def wrapper(*args, **kwargs):\n ctx = stack.top\n if ctx is not None and hasattr(ctx, 'request'):\n request = ctx.request\n is_mobile = getattr(request, 'MOBILE', None)\n kwargs['template'] = re.sub(r'{(.+?)}',\n r'\\1' if is_mobile else '',\n template)\n return f(*args, **kwargs)\n return wrapper\n return decorator", "docstring": "Mark a function as mobile-ready and pass a mobile template if MOBILE.\n\n For example::\n\n @mobile_template('a/{mobile/}b.html')\n def view(template=None):\n ...\n\n\n if ``request.MOBILE=True`` the template will be `a/mobile/b.html`.\n if ``request.MOBILE=False`` the template will be `a/b.html`.\n\n This function is useful if the mobile view uses the same context but a\n different template." }, { "code": "def DisplayEstimate(message, min_estimate, max_estimate):\n mean_avg_cpc = (_CalculateMean(min_estimate['averageCpc']['microAmount'],\n max_estimate['averageCpc']['microAmount'])\n if 'averageCpc' in min_estimate\n and min_estimate['averageCpc'] else None)\n mean_avg_pos = (_CalculateMean(min_estimate['averagePosition'],\n max_estimate['averagePosition'])\n if 'averagePosition' in min_estimate\n and min_estimate['averagePosition'] else None)\n mean_clicks = _CalculateMean(min_estimate['clicksPerDay'],\n max_estimate['clicksPerDay'])\n mean_total_cost = _CalculateMean(min_estimate['totalCost']['microAmount'],\n max_estimate['totalCost']['microAmount'])\n print message\n print ' Estimated average CPC: %s' % _FormatMean(mean_avg_cpc)\n print ' Estimated ad position: %s' % _FormatMean(mean_avg_pos)\n print ' Estimated daily clicks: %s' % _FormatMean(mean_clicks)\n print ' Estimated daily cost: %s' % _FormatMean(mean_total_cost)", "docstring": "Displays mean average cpc, position, clicks, and total cost for estimate.\n\n Args:\n message: str message to display for the given estimate.\n min_estimate: sudsobject containing a minimum estimate from the\n TrafficEstimatorService response.\n max_estimate: sudsobject containing a maximum estimate from the\n TrafficEstimatorService response." }, { "code": "def show_tooltip(self, pos, tooltip, _sender_deco=None):\n if _sender_deco is not None and _sender_deco not in self.decorations:\n return\n QtWidgets.QToolTip.showText(pos, tooltip[0: 1024], self)", "docstring": "Show a tool tip at the specified position\n\n :param pos: Tooltip position\n :param tooltip: Tooltip text\n\n :param _sender_deco: TextDecoration which is the sender of the show\n tooltip request. (for internal use only)." }, { "code": "def load_reader_options():\n options = os.environ['PANDOC_READER_OPTIONS']\n options = json.loads(options, object_pairs_hook=OrderedDict)\n return options", "docstring": "Retrieve Pandoc Reader options from the environment" }, { "code": "def _make_minimal(dictionary):\n new_dict = {}\n for key, value in dictionary.items():\n if value is not None:\n if isinstance(value, dict):\n new_value = _make_minimal(value)\n if new_value:\n new_dict[key] = new_value\n else:\n new_dict[key] = value\n return new_dict", "docstring": "This function removes all the keys whose value is either None or an empty\n dictionary." }, { "code": "def is_valid_vpnv4_prefix(prefix):\n if not isinstance(prefix, str):\n return False\n tokens = prefix.split(':', 2)\n if len(tokens) != 3:\n return False\n if not is_valid_route_dist(':'.join([tokens[0], tokens[1]])):\n return False\n return is_valid_ipv4_prefix(tokens[2])", "docstring": "Returns True if given prefix is a string represent vpnv4 prefix.\n\n Vpnv4 prefix is made up of RD:Ipv4, where RD is represents route\n distinguisher and Ipv4 represents valid dot-decimal ipv4 notation string." }, { "code": "def start(self):\n if not self._done_event.is_set():\n return\n self._done_event.clear()\n nb_pending_tasks = self._queue.qsize()\n if nb_pending_tasks > self._max_threads:\n nb_threads = self._max_threads\n nb_pending_tasks = self._max_threads\n elif nb_pending_tasks < self._min_threads:\n nb_threads = self._min_threads\n else:\n nb_threads = nb_pending_tasks\n for _ in range(nb_pending_tasks):\n self.__nb_pending_task += 1\n self.__start_thread()\n for _ in range(nb_threads - nb_pending_tasks):\n self.__start_thread()", "docstring": "Starts the thread pool. Does nothing if the pool is already started." }, { "code": "def write(self, file_or_path, append=False, timeout=10):\n if isinstance(file_or_path, six.string_types):\n if self.coverage:\n file_or_path = get_smother_filename(\n file_or_path, self.coverage.config.parallel)\n outfile = Lock(\n file_or_path, mode='a+',\n timeout=timeout,\n fail_when_locked=False\n )\n else:\n outfile = noclose(file_or_path)\n with outfile as fh:\n if append:\n fh.seek(0)\n try:\n other = Smother.load(fh)\n except ValueError:\n pass\n else:\n self |= other\n fh.seek(0)\n fh.truncate()\n json.dump(self.data, fh)", "docstring": "Write Smother results to a file.\n\n Parameters\n ----------\n fiile_or_path : str\n Path to write report to\n append : bool\n If True, read an existing smother report from `outpath`\n and combine it with this file before writing.\n timeout : int\n Time in seconds to wait to acquire a file lock, before\n raising an error.\n\n Note\n ----\n Append mode is atomic when file_or_path is a path,\n and can be safely run in a multithreaded or\n multiprocess test environment.\n\n When using `parallel_mode`, file_or_path is given a unique\n suffix based on the machine name and process id." }, { "code": "def error_log(self, msg='', level=20, traceback=False):\n sys.stderr.write(msg + '\\n')\n sys.stderr.flush()\n if traceback:\n tblines = traceback_.format_exc()\n sys.stderr.write(tblines)\n sys.stderr.flush()", "docstring": "Write error message to log.\n\n Args:\n msg (str): error message\n level (int): logging level\n traceback (bool): add traceback to output or not" }, { "code": "def handleOneClientMsg(self, wrappedMsg):\n try:\n vmsg = self.validateClientMsg(wrappedMsg)\n if vmsg:\n self.unpackClientMsg(*vmsg)\n except BlowUp:\n raise\n except Exception as ex:\n msg, frm = wrappedMsg\n friendly = friendlyEx(ex)\n if isinstance(ex, SuspiciousClient):\n self.reportSuspiciousClient(frm, friendly)\n self.handleInvalidClientMsg(ex, wrappedMsg)", "docstring": "Validate and process a client message\n\n :param wrappedMsg: a message from a client" }, { "code": "def GetUserinfo(credentials, http=None):\n http = http or httplib2.Http()\n url = _GetUserinfoUrl(credentials)\n response, content = http.request(url)\n if response.status == http_client.BAD_REQUEST:\n credentials.refresh(http)\n url = _GetUserinfoUrl(credentials)\n response, content = http.request(url)\n return json.loads(content or '{}')", "docstring": "Get the userinfo associated with the given credentials.\n\n This is dependent on the token having either the userinfo.email or\n userinfo.profile scope for the given token.\n\n Args:\n credentials: (oauth2client.client.Credentials) incoming credentials\n http: (httplib2.Http, optional) http instance to use\n\n Returns:\n The email address for this token, or None if the required scopes\n aren't available." }, { "code": "def compute_colors_for_labels(self, labels):\n colors = labels[:, None] * self.palette\n colors = (colors % 255).numpy().astype(\"uint8\")\n return colors", "docstring": "Simple function that adds fixed colors depending on the class" }, { "code": "def _process_batch_write_response(request, response, table_crypto_config):\n try:\n unprocessed_items = response[\"UnprocessedItems\"]\n except KeyError:\n return response\n for table_name, unprocessed in unprocessed_items.items():\n original_items = request[table_name]\n crypto_config = table_crypto_config[table_name]\n if crypto_config.encryption_context.partition_key_name:\n items_match = partial(_item_keys_match, crypto_config)\n else:\n items_match = partial(_item_attributes_match, crypto_config)\n for pos, operation in enumerate(unprocessed):\n for request_type, item in operation.items():\n if request_type != \"PutRequest\":\n continue\n for plaintext_item in original_items:\n if plaintext_item.get(request_type) and items_match(\n plaintext_item[request_type][\"Item\"], item[\"Item\"]\n ):\n unprocessed[pos] = plaintext_item.copy()\n break\n return response", "docstring": "Handle unprocessed items in the response from a transparently encrypted write.\n\n :param dict request: The DynamoDB plaintext request dictionary\n :param dict response: The DynamoDB response from the batch operation\n :param Dict[Text, CryptoConfig] table_crypto_config: table level CryptoConfig used in encrypting the request items\n :return: DynamoDB response, with any unprocessed items reverted back to the original plaintext values\n :rtype: dict" }, { "code": "def publish_server_heartbeat_succeeded(self, connection_id, duration,\n reply):\n event = ServerHeartbeatSucceededEvent(duration, reply, connection_id)\n for subscriber in self.__server_heartbeat_listeners:\n try:\n subscriber.succeeded(event)\n except Exception:\n _handle_exception()", "docstring": "Publish a ServerHeartbeatSucceededEvent to all server heartbeat\n listeners.\n\n :Parameters:\n - `connection_id`: The address (host/port pair) of the connection.\n - `duration`: The execution time of the event in the highest possible\n resolution for the platform.\n - `reply`: The command reply." }, { "code": "def put(self, body, priority=DEFAULT_PRIORITY, delay=0, ttr=DEFAULT_TTR):\n assert isinstance(body, str), 'Job body must be a str instance'\n jid = self._interact_value('put %d %d %d %d\\r\\n%s\\r\\n' % (\n priority, delay, ttr, len(body), body),\n ['INSERTED'],\n ['JOB_TOO_BIG', 'BURIED', 'DRAINING'])\n return int(jid)", "docstring": "Put a job into the current tube. Returns job id." }, { "code": "def _char_density(self, c, font=ImageFont.load_default()):\n image = Image.new('1', font.getsize(c), color=255)\n draw = ImageDraw.Draw(image)\n draw.text((0, 0), c, fill=\"white\", font=font)\n return collections.Counter(image.getdata())[0]", "docstring": "Count the number of black pixels in a rendered character." }, { "code": "def _tile_ticks(self, frac, tickvec):\n origins = np.tile(self.axis._vec, (len(frac), 1))\n origins = self.axis.pos[0].T + (origins.T*frac).T\n endpoints = tickvec + origins\n return origins, endpoints", "docstring": "Tiles tick marks along the axis." }, { "code": "def _peek_buffer(self, i=0):\n while len(self._buffer) <= i:\n self._buffer.append(next(self._source))\n return self._buffer[i]", "docstring": "Get the next line without consuming it." }, { "code": "def filing_history(self, num, transaction=None, **kwargs):\n baseuri = self._BASE_URI + \"company/{}/filing-history\".format(num)\n if transaction is not None:\n baseuri += \"/{}\".format(transaction)\n res = self.session.get(baseuri, params=kwargs)\n self.handle_http_error(res)\n return res", "docstring": "Search for a company's filling history by company number.\n\n Args:\n num (str): Company number to search on.\n\n transaction (Optional[str]): Filing record number.\n kwargs (dict): additional keywords passed into\n requests.session.get params keyword." }, { "code": "def validate_reaction(self):\n if self.reaction not in self._reaction_valid_values:\n raise ValueError(\"reaction should be one of: {valid}\".format(\n valid=\", \".join(self._reaction_valid_values)\n ))", "docstring": "Ensure reaction is of a certain type.\n\n Mainly for future expansion." }, { "code": "def collection(name=None):\n if name is None:\n collection = Collection.query.get_or_404(1)\n else:\n collection = Collection.query.filter(\n Collection.name == name).first_or_404()\n return render_template([\n 'invenio_collections/collection_{0}.html'.format(collection.id),\n 'invenio_collections/collection_{0}.html'.format(slugify(name, '_')),\n current_app.config['COLLECTIONS_DEFAULT_TEMPLATE']\n ], collection=collection)", "docstring": "Render the collection page.\n\n It renders it either with a collection specific template (aka\n collection_{collection_name}.html) or with the default collection\n template (collection.html)." }, { "code": "def merge(cls, *others):\n for other in others:\n for k, v in other:\n setattr(cls, k, BoundValue(cls, k, v.value))", "docstring": "Merge the `others` schema into this instance.\n\n The values will all be read from the provider of the original object." }, { "code": "def extract_params(params):\n values = []\n if isinstance(params, dict):\n for key, value in params.items():\n values.extend(extract_params(value))\n elif isinstance(params, list):\n for value in params:\n values.extend(extract_params(value))\n else:\n values.append(params)\n return values", "docstring": "Extracts the values of a set of parameters, recursing into nested dictionaries." }, { "code": "def _check_list_minions(self, expr, greedy, ignore_missing=False):\n if isinstance(expr, six.string_types):\n expr = [m for m in expr.split(',') if m]\n minions = self._pki_minions()\n return {'minions': [x for x in expr if x in minions],\n 'missing': [] if ignore_missing else [x for x in expr if x not in minions]}", "docstring": "Return the minions found by looking via a list" }, { "code": "def create_password_reset(cls, email, valid_for=3600) -> str:\r\n user = cls.where_email(email)\r\n if user is None:\r\n return None\r\n PasswordResetModel.delete_where_user_id(user.id)\r\n token = JWT().create_token({\r\n 'code': Security.random_string(5),\n 'user_id': user.id},\r\n token_valid_for=valid_for)\r\n code = Security.generate_uuid(1) + \"-\" + Security.random_string(5)\r\n password_reset_model = PasswordResetModel()\r\n password_reset_model.token = token\r\n password_reset_model.code = code\r\n password_reset_model.user_id = user.id\r\n password_reset_model.save()\r\n return code", "docstring": "Create a password reset request in the user_password_resets\r\n database table. Hashed code gets stored in the database.\r\n Returns unhashed reset code" }, { "code": "def VerifyStructure(self, parser_mediator, lines):\n match_generator = self._VERIFICATION_GRAMMAR.scanString(lines, maxMatches=1)\n return bool(list(match_generator))", "docstring": "Verifies that this is a bash history file.\n\n Args:\n parser_mediator (ParserMediator): mediates interactions between\n parsers and other components, such as storage and dfvfs.\n lines (str): one or more lines from the text file.\n\n Returns:\n bool: True if this is the correct parser, False otherwise." }, { "code": "def link_sources(self):\n \"Returns potential Link or Stream sources.\"\n if isinstance(self, GenericOverlayPlot):\n zorders = []\n elif self.batched:\n zorders = list(range(self.zorder, self.zorder+len(self.hmap.last)))\n else:\n zorders = [self.zorder]\n if isinstance(self, GenericOverlayPlot) and not self.batched:\n sources = []\n elif not self.static or isinstance(self.hmap, DynamicMap):\n sources = [o for i, inputs in self.stream_sources.items()\n for o in inputs if i in zorders]\n else:\n sources = [self.hmap.last]\n return sources", "docstring": "Returns potential Link or Stream sources." }, { "code": "def visit_Call(self, node: AST, dfltChaining: bool = True) -> str:\n args = node.args\n try:\n kwds = node.keywords\n except AttributeError:\n kwds = []\n self.compact = True\n args_src = (self.visit(arg) for arg in args)\n kwds_src = (self.visit(kwd) for kwd in kwds)\n param_src = ', '.join(chain(args_src, kwds_src))\n src = f\"{self.visit(node.func)}({param_src})\"\n self.compact = False\n return src", "docstring": "Return `node`s representation as function call." }, { "code": "def abundances(self, ids=None):\n if ids is None:\n return self.table()\n else:\n res = self.table()\n return res[res[\"tax_id\"].isin(ids)]", "docstring": "Query the results table to get abundance data for all or some tax ids" }, { "code": "def add_external_reference_to_entity(self,entity_id, external_ref):\n if self.entity_layer is not None:\n self.entity_layer.add_external_reference_to_entity(entity_id,external_ref)", "docstring": "Adds an external reference to the given entity identifier in the entity layer\n @type entity_id: string\n @param entity_id: the entity identifier\n @param external_ref: an external reference object\n @type external_ref: L{CexternalReference}" }, { "code": "def binOp(op, indx, amap, bmap, fill_vec):\r\n def op_or_missing(id):\r\n va = amap.get(id, None)\r\n vb = bmap.get(id, None)\r\n if va is None or vb is None:\r\n result = fill_vec\r\n else:\r\n try:\r\n result = op(va, vb)\r\n except Exception:\r\n result = None\r\n if result is None:\r\n result = fill_vec\r\n return result\r\n seq_arys = map(op_or_missing, indx)\r\n data = np.vstack(seq_arys)\r\n return data", "docstring": "Combines the values from two map objects using the indx values\r\n using the op operator. In situations where there is a missing value\r\n it will use the callable function handle_missing" }, { "code": "def update_allowed(self):\n return self.update_action.allowed(self.column.table.request,\n self.datum,\n self)", "docstring": "Determines whether update of given cell is allowed.\n\n Calls allowed action of defined UpdateAction of the Column." }, { "code": "def get_delete_branch_command(self, branch_name, message, author):\n tokens = ['hg update --rev=%s && hg commit' % quote(branch_name)]\n if author:\n tokens.append('--user=%s' % quote(author.combined))\n tokens.append('--message=%s' % quote(message))\n tokens.append('--close-branch')\n return [' '.join(tokens)]", "docstring": "Get the command to delete or close a branch in the local repository." }, { "code": "def insert(self, index, value):\n return super(Collection, self).insert(\n index, self._ensure_value_is_valid(value))", "docstring": "Insert an item at a given position." }, { "code": "def cli(obj, ids, query, filters, tags):\n client = obj['client']\n if ids:\n total = len(ids)\n else:\n if query:\n query = [('q', query)]\n else:\n query = build_query(filters)\n total, _, _ = client.get_count(query)\n ids = [a.id for a in client.get_alerts(query)]\n with click.progressbar(ids, label='Untagging {} alerts'.format(total)) as bar:\n for id in bar:\n client.untag_alert(id, tags)", "docstring": "Remove tags from alerts." }, { "code": "def clean(self):\n if self.event not in HOOK_EVENTS.keys():\n raise ValidationError(\n \"Invalid hook event {evt}.\".format(evt=self.event)\n )", "docstring": "Validation for events." }, { "code": "def download_and_bootstrap(src, name, prereq=None):\n if prereq:\n prereq_cmd = '{0} -c \"{1}\"'.format(PY_EXE, prereq)\n rv = os.system(prereq_cmd)\n if rv == 0:\n return\n ulp = urllib2.urlopen(src)\n fp = open(name, \"wb\")\n fp.write(ulp.read())\n fp.close()\n cmdline = \"{0} {1}\".format(PY_EXE, name)\n rv = os.system(cmdline)\n assert rv == 0", "docstring": "Download and install something if 'prerequisite' fails" }, { "code": "def run(self, start_command_srv):\n if start_command_srv:\n self._command_server.start()\n self._drop_privs()\n self._task_runner.start()\n self._reg_sighandlers()\n while self.running:\n time.sleep(self._sleep_period)\n self.shutdown()", "docstring": "Setup daemon process, start child forks, and sleep until\n events are signalled.\n\n `start_command_srv`\n Set to ``True`` if command server should be started." }, { "code": "def _update_physical_disk_details(raid_config, server):\n raid_config['physical_disks'] = []\n physical_drives = server.get_physical_drives()\n for physical_drive in physical_drives:\n physical_drive_dict = physical_drive.get_physical_drive_dict()\n raid_config['physical_disks'].append(physical_drive_dict)", "docstring": "Adds the physical disk details to the RAID configuration passed." }, { "code": "def _load(self, scale=1.0):\n LOG.debug(\"File: %s\", str(self.requested_band_filename))\n ncf = Dataset(self.requested_band_filename, 'r')\n wvl = ncf.variables['wavelength'][:] * scale\n resp = ncf.variables['response'][:]\n self.rsr = {'wavelength': wvl, 'response': resp}", "docstring": "Load the SLSTR relative spectral responses" }, { "code": "def signRequest(self,\n req: Request,\n identifier: Identifier=None) -> Request:\n idr = self.requiredIdr(idr=identifier or req._identifier)\n req._identifier = idr\n req.reqId = req.gen_req_id()\n req.signature = self.signMsg(msg=req.signingPayloadState(identifier=idr),\n identifier=idr,\n otherIdentifier=req.identifier)\n return req", "docstring": "Signs request. Modifies reqId and signature. May modify identifier.\n\n :param req: request\n :param requestIdStore: request id generator\n :param identifier: signer identifier\n :return: signed request" }, { "code": "def matrixToMathTransform(matrix):\n if isinstance(matrix, ShallowTransform):\n return matrix\n off, scl, rot = MathTransform(matrix).decompose()\n return ShallowTransform(off, scl, rot)", "docstring": "Take a 6-tuple and return a ShallowTransform object." }, { "code": "def run_and_print_log(workflow, highlight=None):\n from noodles.run.threading.sqlite3 import run_parallel\n from noodles import serial\n import io\n import logging\n log = io.StringIO()\n log_handler = logging.StreamHandler(log)\n formatter = logging.Formatter('%(asctime)s - %(message)s')\n log_handler.setFormatter(formatter)\n logger = logging.getLogger('noodles')\n logger.setLevel(logging.INFO)\n logger.handlers = [log_handler]\n result = run_parallel(\n workflow, n_threads=4, registry=serial.base, db_file='tutorial.db',\n always_cache=True, echo_log=False)\n display_text(log.getvalue(), highlight or [], split_at=40)\n return result", "docstring": "Run workflow on multi-threaded worker cached with Sqlite3.\n\n :param workflow: workflow to evaluate.\n :param highlight: highlight these lines." }, { "code": "def process_management_config_section(config, management_config):\n if 'commands' in management_config:\n for command in management_config['commands']:\n config.management['commands'].append(command)", "docstring": "Processes the management section from a configuration data dict.\n\n :param config: The config reference of the object that will hold the\n configuration data from the config_data.\n :param management_config: Management section from a config data dict." }, { "code": "def tangent(obj, params, **kwargs):\n normalize = kwargs.get('normalize', True)\n if isinstance(obj, abstract.Curve):\n if isinstance(params, (list, tuple)):\n return ops.tangent_curve_single_list(obj, params, normalize)\n else:\n return ops.tangent_curve_single(obj, params, normalize)\n if isinstance(obj, abstract.Surface):\n if isinstance(params[0], float):\n return ops.tangent_surface_single(obj, params, normalize)\n else:\n return ops.tangent_surface_single_list(obj, params, normalize)", "docstring": "Evaluates the tangent vector of the curves or surfaces at the input parameter values.\n\n This function is designed to evaluate tangent vectors of the B-Spline and NURBS shapes at single or\n multiple parameter positions.\n\n :param obj: input shape\n :type obj: abstract.Curve or abstract.Surface\n :param params: parameters\n :type params: float, list or tuple\n :return: a list containing \"point\" and \"vector\" pairs\n :rtype: tuple" }, { "code": "def get(self, key): \n res = self.connection.get(key)\n print(res)\n return res", "docstring": "get a set of keys from redis" }, { "code": "def to_timezone(dt, tzinfo=None):\n if not dt:\n return dt\n tz = pick_timezone(tzinfo, __timezone__)\n if not tz:\n return dt\n dttz = getattr(dt, 'tzinfo', None)\n if not dttz:\n return dt.replace(tzinfo=tz)\n else:\n return dt.astimezone(tz)", "docstring": "Convert a datetime to timezone" }, { "code": "def use(module=None, decode=None, encode=None):\n global _decode, _encode, _initialized, _using\n if module is not None:\n if not isinstance(module, basestring):\n module = module.__name__\n if module not in ('cjson', 'json', 'simplejson'):\n raise ValueError('Unsupported JSON module %s' % module)\n _using = module\n _initialized = False\n else:\n assert decode is not None and encode is not None\n _using = 'custom'\n _decode = decode\n _encode = encode\n _initialized = True", "docstring": "Set the JSON library that should be used, either by specifying a known\n module name, or by providing a decode and encode function.\n\n The modules \"simplejson\", \"cjson\", and \"json\" are currently supported for\n the ``module`` parameter.\n\n If provided, the ``decode`` parameter must be a callable that accepts a\n JSON string and returns a corresponding Python data structure. The\n ``encode`` callable must accept a Python data structure and return the\n corresponding JSON string. Exceptions raised by decoding and encoding\n should be propagated up unaltered.\n\n @param module: the name of the JSON library module to use, or the module\n object itself\n @type module: str or module\n @param decode: a function for decoding JSON strings\n @type decode: callable\n @param encode: a function for encoding objects as JSON strings\n @type encode: callable" }, { "code": "def _copy_new_parent(self, parent):\n if self.parent == \"undefined\":\n param = copy.copy(self)\n param.parent = parent.uid\n return param\n else:\n raise ValueError(\"Cannot copy from non-dummy parent %s.\" % parent)", "docstring": "Copy the current param to a new parent, must be a dummy param." }, { "code": "def _format_char(char):\n if char is None:\n return -1\n if isinstance(char, _STRTYPES) and len(char) == 1:\n return ord(char)\n try:\n return int(char)\n except:\n raise TypeError('char single character string, integer, or None\\nReceived: ' + repr(char))", "docstring": "Prepares a single character for passing to ctypes calls, needs to return\n an integer but can also pass None which will keep the current character\n instead of overwriting it.\n\n This is called often and needs to be optimized whenever possible." }, { "code": "def _contigs_dict_to_file(self, contigs, fname):\n f = pyfastaq.utils.open_file_write(fname)\n for contig in sorted(contigs, key=lambda x:len(contigs[x]), reverse=True):\n print(contigs[contig], file=f)\n pyfastaq.utils.close(f)", "docstring": "Writes dictionary of contigs to file" }, { "code": "def patch(*args, **kwargs):\n from caliendo.patch import patch as p\n return p(*args, **kwargs)", "docstring": "Deprecated. Patch should now be imported from caliendo.patch.patch" }, { "code": "def transform(self, transform, desc=None):\n if desc is None:\n desc = u'transform({})'.format(getattr(transform, '__name__', ''))\n return self.replace(\n transforms=self.transforms + [transform],\n desc_stack=self.desc_stack + [desc]\n )", "docstring": "Create a copy of this query, transformed by `transform`.\n\n Args:\n transform (callable): Callable that takes an iterable of values and\n returns an iterable of transformed values.\n\n Keyword Args:\n desc (str): A description of the transform, to use in log messages.\n Defaults to the name of the `transform` function.\n\n Returns:\n Query" }, { "code": "def transform(self, X, y=None):\n insuffix = X._libsuffix\n cast_fn = utils.get_lib_fn('locallyBlurAntsImage%s' % (insuffix))\n casted_ptr = cast_fn(X.pointer, self.iters, self.conductance)\n return iio.ANTsImage(pixeltype=X.pixeltype, dimension=X.dimension,\n components=X.components, pointer=casted_ptr)", "docstring": "Locally blur an image by applying a gradient anisotropic diffusion filter.\n\n Arguments\n ---------\n X : ANTsImage\n image to transform\n\n y : ANTsImage (optional)\n another image to transform.\n\n Example\n -------\n >>> import ants\n >>> blur = ants.contrib.LocallyBlurIntensity(1,5)\n >>> img2d = ants.image_read(ants.get_data('r16'))\n >>> img2d_b = blur.transform(img2d)\n >>> ants.plot(img2d)\n >>> ants.plot(img2d_b)\n >>> img3d = ants.image_read(ants.get_data('mni'))\n >>> img3d_b = blur.transform(img3d)\n >>> ants.plot(img3d)\n >>> ants.plot(img3d_b)" }, { "code": "def has_roles(self, *requirements):\n user_manager = current_app.user_manager\n role_names = user_manager.db_manager.get_user_roles(self)\n for requirement in requirements:\n if isinstance(requirement, (list, tuple)):\n tuple_of_role_names = requirement\n authorized = False\n for role_name in tuple_of_role_names:\n if role_name in role_names:\n authorized = True\n break\n if not authorized:\n return False\n else:\n role_name = requirement\n if not role_name in role_names:\n return False\n return True", "docstring": "Return True if the user has all of the specified roles. Return False otherwise.\n\n has_roles() accepts a list of requirements:\n has_role(requirement1, requirement2, requirement3).\n\n Each requirement is either a role_name, or a tuple_of_role_names.\n role_name example: 'manager'\n tuple_of_role_names: ('funny', 'witty', 'hilarious')\n A role_name-requirement is accepted when the user has this role.\n A tuple_of_role_names-requirement is accepted when the user has ONE of these roles.\n has_roles() returns true if ALL of the requirements have been accepted.\n\n For example:\n has_roles('a', ('b', 'c'), d)\n Translates to:\n User has role 'a' AND (role 'b' OR role 'c') AND role 'd" }, { "code": "def value(self):\n if self.filter_.get('field') is not None:\n try:\n result = getattr(self.model, self.filter_['field'])\n except AttributeError:\n raise InvalidFilters(\"{} has no attribute {}\".format(self.model.__name__, self.filter_['field']))\n else:\n return result\n else:\n if 'val' not in self.filter_:\n raise InvalidFilters(\"Can't find value or field in a filter\")\n return self.filter_['val']", "docstring": "Get the value to filter on\n\n :return: the value to filter on" }, { "code": "def results( self ):\n return self.report(self.parameters(),\n self.metadata(),\n self.experimentalResults())", "docstring": "Return a complete results dict. Only really makes sense for\n recently-executed experimental runs.\n\n :returns: the results dict" }, { "code": "def setupMovie(self):\n if self.state == self.INIT:\n self.sendRtspRequest(self.SETUP)", "docstring": "Setup button handler." }, { "code": "def transform_dot(self, node, results):\n module_dot = results.get(\"bare_with_attr\")\n member = results.get(\"member\")\n new_name = None\n if isinstance(member, list):\n member = member[0]\n for change in MAPPING[module_dot.value]:\n if member.value in change[1]:\n new_name = change[0]\n break\n if new_name:\n module_dot.replace(Name(new_name,\n prefix=module_dot.prefix))\n else:\n self.cannot_convert(node, \"This is an invalid module element\")", "docstring": "Transform for calls to module members in code." }, { "code": "def release_value_set(self):\n if self._remotelib:\n self._remotelib.run_keyword('release_value_set', [self._my_id], {})\n else:\n _PabotLib.release_value_set(self, self._my_id)", "docstring": "Release a reserved value set so that other executions can use it also." }, { "code": "def connect_discussion_signals():\n post_save.connect(\n count_discussions_handler, sender=comment_model,\n dispatch_uid=COMMENT_PS_COUNT_DISCUSSIONS)\n post_delete.connect(\n count_discussions_handler, sender=comment_model,\n dispatch_uid=COMMENT_PD_COUNT_DISCUSSIONS)\n comment_was_flagged.connect(\n count_discussions_handler, sender=comment_model,\n dispatch_uid=COMMENT_WF_COUNT_DISCUSSIONS)\n comment_was_posted.connect(\n count_comments_handler, sender=comment_model,\n dispatch_uid=COMMENT_WP_COUNT_COMMENTS)\n pingback_was_posted.connect(\n count_pingbacks_handler, sender=comment_model,\n dispatch_uid=PINGBACK_WF_COUNT_PINGBACKS)\n trackback_was_posted.connect(\n count_trackbacks_handler, sender=comment_model,\n dispatch_uid=TRACKBACK_WF_COUNT_TRACKBACKS)", "docstring": "Connect all the signals on the Comment model to\n maintains a valid discussion count on each entries\n when an action is done with the comments." }, { "code": "def pop_context(self):\n processor = getattr(self, 'processor', None)\n if processor is not None:\n pop_context = getattr(processor, 'pop_context', None)\n if pop_context is None:\n pop_context = getattr(processor, 'pop', None)\n if pop_context is not None:\n return pop_context()\n if self._pop_next:\n self._pop_next = False", "docstring": "Pops the last set of keyword arguments provided to the processor." }, { "code": "def add_title(self, title, subtitle=None, source=None):\n title_entry = self._sourced_dict(\n source,\n title=title,\n )\n if subtitle is not None:\n title_entry['subtitle'] = subtitle\n self._append_to('titles', title_entry)", "docstring": "Add title.\n\n :param title: title for the current document\n :type title: string\n\n :param subtitle: subtitle for the current document\n :type subtitle: string\n\n :param source: source for the given title\n :type source: string" }, { "code": "def get_cardinality(self, node=None):\n if node:\n for factor in self.factors:\n for variable, cardinality in zip(factor.scope(), factor.cardinality):\n if node == variable:\n return cardinality\n else:\n cardinalities = defaultdict(int)\n for factor in self.factors:\n for variable, cardinality in zip(factor.scope(), factor.cardinality):\n cardinalities[variable] = cardinality\n return cardinalities", "docstring": "Returns the cardinality of the node\n\n Parameters\n ----------\n node: any hashable python object (optional)\n The node whose cardinality we want. If node is not specified returns a\n dictionary with the given variable as keys and their respective cardinality\n as values.\n\n Returns\n -------\n int or dict : If node is specified returns the cardinality of the node.\n If node is not specified returns a dictionary with the given\n variable as keys and their respective cardinality as values.\n\n\n Examples\n --------\n >>> from pgmpy.models import ClusterGraph\n >>> from pgmpy.factors.discrete import DiscreteFactor\n >>> student = ClusterGraph()\n >>> factor = DiscreteFactor(['Alice', 'Bob'], cardinality=[2, 2],\n ... values=np.random.rand(4))\n >>> student.add_node(('Alice', 'Bob'))\n >>> student.add_factors(factor)\n >>> student.get_cardinality()\n defaultdict(, {'Bob': 2, 'Alice': 2})\n\n >>> student.get_cardinality(node='Alice')\n 2" }, { "code": "def _channel_exists_and_not_settled(\n self,\n participant1: Address,\n participant2: Address,\n block_identifier: BlockSpecification,\n channel_identifier: ChannelID = None,\n ) -> bool:\n try:\n channel_state = self._get_channel_state(\n participant1=participant1,\n participant2=participant2,\n block_identifier=block_identifier,\n channel_identifier=channel_identifier,\n )\n except RaidenRecoverableError:\n return False\n exists_and_not_settled = (\n channel_state > ChannelState.NONEXISTENT and\n channel_state < ChannelState.SETTLED\n )\n return exists_and_not_settled", "docstring": "Returns if the channel exists and is in a non-settled state" }, { "code": "def tableiswritable(tablename):\n result = True\n try:\n t = table(tablename, readonly=False, ack=False)\n result = t.iswritable()\n except:\n result = False\n return result", "docstring": "Test if a table is writable." }, { "code": "def save(self, path):\n writer = csv.writer(open(path, 'w', newline=''), delimiter=' ')\n rows = list(self.items())\n rows.sort(key=lambda x: x[0])\n writer.writerows(rows)", "docstring": "Saves this catalogue's data to `path`.\n\n :param path: file path to save catalogue data to\n :type path: `str`" }, { "code": "def verify_firebase_token(id_token, request, audience=None):\n return verify_token(\n id_token, request, audience=audience, certs_url=_GOOGLE_APIS_CERTS_URL)", "docstring": "Verifies an ID Token issued by Firebase Authentication.\n\n Args:\n id_token (Union[str, bytes]): The encoded token.\n request (google.auth.transport.Request): The object used to make\n HTTP requests.\n audience (str): The audience that this token is intended for. This is\n typically your Firebase application ID. If None then the audience\n is not verified.\n\n Returns:\n Mapping[str, Any]: The decoded token." }, { "code": "def _get_serv(ret=None):\n _options = _get_options(ret)\n host = _options.get('host')\n port = _options.get('port')\n database = _options.get('db')\n user = _options.get('user')\n password = _options.get('password')\n version = _get_version(host, port, user, password)\n if version and \"v0.8\" in version:\n return influxdb.influxdb08.InfluxDBClient(host=host,\n port=port,\n username=user,\n password=password,\n database=database\n )\n else:\n return influxdb.InfluxDBClient(host=host,\n port=port,\n username=user,\n password=password,\n database=database\n )", "docstring": "Return an influxdb client object" }, { "code": "def authentication(self, username, password):\n _auth_text = '{}:{}'.format(username, password)\n if int(sys.version[0]) > 2:\n _auth_bin = base64.encodebytes(_auth_text.encode())\n _auth = _auth_bin.decode()\n _auth = _auth.replace('\\n', '')\n self._auth = _auth\n else:\n _auth = base64.encodestring(_auth_text)\n self._auth = str(_auth).replace('\\n', '')\n _LOGGER.debug('Autentication string is: {}:***'.format(username))", "docstring": "Configures the user authentication for eAPI\n\n This method configures the username and password combination to use\n for authenticating to eAPI.\n\n Args:\n username (str): The username to use to authenticate the eAPI\n connection with\n password (str): The password in clear text to use to authenticate\n the eAPI connection with" }, { "code": "def _cfactory(attr, func, argtypes, restype, errcheck=None):\n meth = getattr(attr, func)\n meth.argtypes = argtypes\n meth.restype = restype\n if errcheck:\n meth.errcheck = errcheck", "docstring": "Factory to create a ctypes function and automatically manage errors." }, { "code": "def unlink(self, key, *keys):\n return wait_convert(self.execute(b'UNLINK', key, *keys), int)", "docstring": "Delete a key asynchronously in another thread." }, { "code": "def run(self):\n salt.utils.process.appendproctitle(self.__class__.__name__)\n salt.daemons.masterapi.clean_fsbackend(self.opts)\n for interval in self.buckets:\n self.update_threads[interval] = threading.Thread(\n target=self.update_fileserver,\n args=(interval, self.buckets[interval]),\n )\n self.update_threads[interval].start()\n while True:\n time.sleep(60)", "docstring": "Start the update threads" }, { "code": "def day_publications_card(date):\n d = date.strftime(app_settings.DATE_FORMAT)\n card_title = 'Reading on {}'.format(d)\n return {\n 'card_title': card_title,\n 'publication_list': day_publications(date=date),\n }", "docstring": "Displays Publications that were being read on `date`.\n `date` is a date tobject." }, { "code": "def clone(self):\n clone = copy(self)\n clone.variables = {k: v.clone() for (k, v) in self.variables.items()}\n return clone", "docstring": "Returns a shallow copy of the current instance, except that all\n variables are deep-cloned." }, { "code": "def single_node_env(args):\n if isinstance(args, list):\n sys.argv = args\n elif args.argv:\n sys.argv = args.argv\n num_gpus = args.num_gpus if 'num_gpus' in args else 1\n util.single_node_env(num_gpus)", "docstring": "Sets up environment for a single-node TF session.\n\n Args:\n :args: command line arguments as either argparse args or argv list" }, { "code": "def get_version():\n reg = re.compile(r'__version__ = [\\'\"]([^\\'\"]*)[\\'\"]')\n with open('requests_kerberos/__init__.py') as fd:\n matches = list(filter(lambda x: x, map(reg.match, fd)))\n if not matches:\n raise RuntimeError(\n 'Could not find the version information for requests_kerberos'\n )\n return matches[0].group(1)", "docstring": "Simple function to extract the current version using regular expressions." }, { "code": "def swo_start(self, swo_speed=9600):\n if self.swo_enabled():\n self.swo_stop()\n info = structs.JLinkSWOStartInfo()\n info.Speed = swo_speed\n res = self._dll.JLINKARM_SWO_Control(enums.JLinkSWOCommands.START,\n ctypes.byref(info))\n if res < 0:\n raise errors.JLinkException(res)\n self._swo_enabled = True\n return None", "docstring": "Starts collecting SWO data.\n\n Note:\n If SWO is already enabled, it will first stop SWO before enabling it\n again.\n\n Args:\n self (JLink): the ``JLink`` instance\n swo_speed (int): the frequency in Hz used by the target to communicate\n\n Returns:\n ``None``\n\n Raises:\n JLinkException: on error" }, { "code": "def _parse_tag(self, el):\n ns = None\n tag = el.tag\n if tag[0] == '{':\n ns, tag = tag[1:].split('}', 1)\n if self.ns_map and ns in self.ns_map:\n ns = self.ns_map[ns]\n return ns, tag", "docstring": "Extract the namespace and tag from an element." }, { "code": "def download(self, file_name, save_as=None):\n self._check_session()\n try:\n if save_as:\n save_as = os.path.normpath(save_as)\n save_dir = os.path.dirname(save_as)\n if save_dir:\n if not os.path.exists(save_dir):\n os.makedirs(save_dir)\n elif not os.path.isdir(save_dir):\n raise RuntimeError(save_dir + \" is not a directory\")\n status, save_path, bytes = self._rest.download_file(\n 'files', file_name, save_as, 'application/octet-stream')\n except resthttp.RestHttpError as e:\n raise RuntimeError('failed to download \"%s\": %s' % (file_name, e))\n return save_path, bytes", "docstring": "Download the specified file from the server.\n\n Arguments:\n file_name -- Name of file resource to save.\n save_as -- Optional path name to write file to. If not specified,\n then file named by the last part of the resource path is\n downloaded to current directory.\n\n Return: (save_path, bytes)\n save_path -- Path where downloaded file was saved.\n bytes -- Bytes downloaded." }, { "code": "def _peek(self, chars=1):\n line = self._socket.recv(chars, socket.MSG_PEEK)\n logger.debug('Server sent (peek): ' + line.rstrip())\n return line", "docstring": "Peek at the data in the server response.\n\n Peeking should only be done when the response can be predicted.\n Make sure that the socket will not block by requesting too\n much data from it while peeking.\n\n Args:\n chars -- the number of characters to peek." }, { "code": "def good_port_ranges(ports=None, min_range_len=20, border=3):\n min_range_len += border*2\n if ports is None:\n ports = available_ports()\n ranges = utils.to_ranges(list(ports))\n lenghts = sorted([(r[1]-r[0], r) for r in ranges], reverse=True)\n long_ranges = [l[1] for l in lenghts if l[0] >= min_range_len]\n without_borders = [(low+border, high-border) for low, high in long_ranges]\n return without_borders", "docstring": "Returns a list of 'good' port ranges.\n Such ranges are large and don't contain ephemeral or well-known ports.\n Ranges borders are also excluded." }, { "code": "def locate(self, pattern):\n top_matches = self.top.locate(pattern)\n bottom_matches = self.bottom.locate(pattern)\n return [top_matches, bottom_matches]", "docstring": "Find sequences matching a pattern. For a circular sequence, the\n search extends over the origin.\n\n :param pattern: str or NucleicAcidSequence for which to find matches.\n :type pattern: str or coral.DNA\n :returns: A list of top and bottom strand indices of matches.\n :rtype: list of lists of indices (ints)\n :raises: ValueError if the pattern is longer than either the input\n sequence (for linear DNA) or twice as long as the input\n sequence (for circular DNA)." }, { "code": "def get_multiple_devices(self, rids):\n headers = {\n 'User-Agent': self.user_agent(),\n 'Content-Type': self.content_type()\n }\n headers.update(self.headers())\n url = self.portals_url()+'/users/_this/devices/' + str(rids).replace(\"'\", \"\").replace(' ','')\n r = requests.get( url,\n headers=headers,\n auth=self.auth())\n if HTTP_STATUS.OK == r.status_code:\n return r.json()\n else:\n print(\"get_multiple_devices: Something went wrong: <{0}>: {1}\".format(\n r.status_code, r.reason))\n r.raise_for_status()", "docstring": "Implements the 'Get Multiple Devices' API.\n\n Param rids: a python list object of device rids.\n\n http://docs.exosite.com/portals/#get-multiple-devices" }, { "code": "def _update_record_with_id(self, identifier, rtype, content):\n record = self._create_request_record(identifier, rtype, None, content,\n self._get_lexicon_option('ttl'),\n self._get_lexicon_option('priority'))\n self._request_modify_dns_record(record)", "docstring": "Updates existing record with no sub-domain name changes" }, { "code": "def is1d(a:Collection)->bool:\n \"Return `True` if `a` is one-dimensional\"\n return len(a.shape) == 1 if hasattr(a, 'shape') else True", "docstring": "Return `True` if `a` is one-dimensional" }, { "code": "def get_ips_from_string(ip_str):\n ip_list = []\n for ip in ip_str.split(','):\n clean_ip = ip.strip().lower()\n if clean_ip:\n ip_list.append(clean_ip)\n ip_count = len(ip_list)\n if ip_count > 0:\n if is_valid_ip(ip_list[0]) and is_valid_ip(ip_list[-1]):\n return ip_list, ip_count\n return [], 0", "docstring": "Given a string, it returns a list of one or more valid IP addresses" }, { "code": "def content_status(self, content_status):\n if content_status is None:\n raise ValueError(\"Invalid value for `content_status`, must not be `None`\")\n allowed_values = [\"INVALID\", \"NOT_LOADED\", \"HIDDEN\", \"VISIBLE\"]\n if content_status not in allowed_values:\n raise ValueError(\n \"Invalid value for `content_status` ({0}), must be one of {1}\"\n .format(content_status, allowed_values)\n )\n self._content_status = content_status", "docstring": "Sets the content_status of this IntegrationStatus.\n\n Status of integration content, e.g. dashboards # noqa: E501\n\n :param content_status: The content_status of this IntegrationStatus. # noqa: E501\n :type: str" }, { "code": "def sanitize(s, strict=True):\n allowed = ''.join(\n [\n 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',\n 'abcdefghijklmnopqrstuvwxyz',\n '0123456789',\n ]\n )\n if not strict:\n allowed += '-_.'\n s = str(s).replace(' ', '_')\n return ''.join([i for i in s if i in allowed])", "docstring": "Sanitize a string.\n\n Spaces are converted to underscore; if strict=True they are then removed.\n\n Parameters\n ----------\n s : str\n String to sanitize\n\n strict : bool\n If True, only alphanumeric characters are allowed. If False, a limited\n set of additional characters (-._) will be allowed." }, { "code": "def get_tag(self, name):\n res = self.get_request('/tag/' + name)\n return Tag(cloud_manager=self, **res['tag'])", "docstring": "Return the tag as Tag object." }, { "code": "def profile_list(**kwargs):\n ctx = Context(**kwargs)\n ctx.execute_action('profile:list', **{\n 'storage': ctx.repo.create_secure_service('storage'),\n })", "docstring": "Show uploaded profiles." }, { "code": "def _select_in_voltage_range(self, min_voltage=None, max_voltage=None):\n min_voltage = min_voltage if min_voltage is not None \\\n else self.min_voltage\n max_voltage = max_voltage if max_voltage is not None \\\n else self.max_voltage\n return list(filter(lambda p: min_voltage <= p.voltage <= max_voltage,\n self.voltage_pairs))", "docstring": "Selects VoltagePairs within a certain voltage range.\n\n Args:\n min_voltage (float): The minimum allowable voltage for a given\n step.\n max_voltage (float): The maximum allowable voltage allowable for a\n given step.\n\n Returns:\n A list of VoltagePair objects" }, { "code": "def runSharedFeatures(noiseLevel=None, profile=False):\n exp = L4L2Experiment(\n \"shared_features\",\n enableLateralSP=True,\n enableFeedForwardSP=True\n )\n pairs = createThreeObjects()\n objects = createObjectMachine(\n machineType=\"simple\",\n numInputBits=20,\n sensorInputSize=1024,\n externalInputSize=1024\n )\n for object in pairs:\n objects.addObject(object)\n exp.learnObjects(objects.provideObjectsToLearn())\n if profile:\n exp.printProfile()\n inferConfig = {\n \"numSteps\": 10,\n \"noiseLevel\": noiseLevel,\n \"pairs\": {\n 0: zip(range(10), range(10))\n }\n }\n exp.infer(objects.provideObjectToInfer(inferConfig), objectName=0)\n if profile:\n exp.printProfile()\n exp.plotInferenceStats(\n fields=[\"L2 Representation\",\n \"Overlap L2 with object\",\n \"L4 Representation\"],\n )", "docstring": "Runs a simple experiment where three objects share a number of location,\n feature pairs.\n\n Parameters:\n ----------------------------\n @param noiseLevel (float)\n Noise level to add to the locations and features during inference\n\n @param profile (bool)\n If True, the network will be profiled after learning and inference" }, { "code": "def search_user(self, user_name, quiet=False, limit=9):\n result = self.search(user_name, search_type=1002, limit=limit)\n if result['result']['userprofileCount'] <= 0:\n LOG.warning('User %s not existed!', user_name)\n raise SearchNotFound('user {} not existed'.format(user_name))\n else:\n users = result['result']['userprofiles']\n if quiet:\n user_id, user_name = users[0]['userId'], users[0]['nickname']\n user = User(user_id, user_name)\n return user\n else:\n return self.display.select_one_user(users)", "docstring": "Search user by user name.\n\n :params user_name: user name.\n :params quiet: automatically select the best one.\n :params limit: user count returned by weapi.\n :return: a User object." }, { "code": "def controlled(self, control_qubit):\n control_qubit = unpack_qubit(control_qubit)\n self.modifiers.insert(0, \"CONTROLLED\")\n self.qubits.insert(0, control_qubit)\n return self", "docstring": "Add the CONTROLLED modifier to the gate with the given control qubit." }, { "code": "def get_group_usage_link(self):\n first_element = self.group_list[0]\n usage_link = getattr(first_element.form, 'usage_link', None)\n return usage_link", "docstring": "Get the usage link for the group element." }, { "code": "def rename(self, src_basename, dest_basename, datadir=\"outdir\"):\n directory = {\n \"indir\": self.indir,\n \"outdir\": self.outdir,\n \"tmpdir\": self.tmpdir,\n }[datadir]\n src = directory.path_in(src_basename)\n dest = directory.path_in(dest_basename)\n os.rename(src, dest)", "docstring": "Rename a file located in datadir.\n\n src_basename and dest_basename are the basename of the source file\n and of the destination file, respectively." }, { "code": "def parse_number(self):\n value = self.current_token.value\n suffix = value[-1].lower()\n try:\n if suffix in NUMBER_SUFFIXES:\n return NUMBER_SUFFIXES[suffix](value[:-1])\n return Double(value) if '.' in value else Int(value)\n except (OutOfRange, ValueError):\n return String(value)", "docstring": "Parse a number from the token stream." }, { "code": "def recalculate(self, amount, billing_info):\n order = Order(pk=-1)\n order.amount = amount\n order.currency = self.get_currency()\n country = getattr(billing_info, 'country', None)\n if not country is None:\n country = country.code\n tax_number = getattr(billing_info, 'tax_number', None)\n tax_session_key = \"tax_%s_%s\" % (tax_number, country)\n tax = self.request.session.get(tax_session_key)\n if tax is None:\n taxation_policy = getattr(settings, 'PLANS_TAXATION_POLICY', None)\n if not taxation_policy:\n raise ImproperlyConfigured('PLANS_TAXATION_POLICY is not set')\n taxation_policy = import_name(taxation_policy)\n tax = str(taxation_policy.get_tax_rate(tax_number, country))\n self.request.session[tax_session_key] = tax\n order.tax = Decimal(tax) if tax != 'None' else None\n return order", "docstring": "Calculates and return pre-filled Order" }, { "code": "def remove_entry(data, entry):\n file_field = entry['fields'].get('file')\n if file_field:\n try:\n os.remove(file_field)\n except IOError:\n click.echo('This entry\\'s file was missing')\n data.remove(entry)", "docstring": "Remove an entry in place." }, { "code": "def cast2theano_var(self, array_like, name=None):\n array = np.asarray(array_like)\n args = (name, array.dtype)\n ndim = array.ndim\n if ndim == 0:\n return T.scalar(*args)\n elif ndim == 1:\n return T.vector(*args)\n elif ndim == 2:\n return T.matrix(*args)\n elif ndim == 3:\n return T.tensor3(*args)\n elif ndim == 4:\n return T.tensor4(*args)\n else:\n raise ValueError('extheano.jit.Compiler: Unsupported type or shape')", "docstring": "Cast `numpy.ndarray` into `theano.tensor` keeping `dtype` and `ndim`\n compatible" }, { "code": "def copy(self, extra=None):\n if extra is None:\n extra = dict()\n newTVS = Params.copy(self, extra)\n if self.isSet(self.estimator):\n newTVS.setEstimator(self.getEstimator().copy(extra))\n if self.isSet(self.evaluator):\n newTVS.setEvaluator(self.getEvaluator().copy(extra))\n return newTVS", "docstring": "Creates a copy of this instance with a randomly generated uid\n and some extra params. This copies creates a deep copy of\n the embedded paramMap, and copies the embedded and extra parameters over.\n\n :param extra: Extra parameters to copy to the new instance\n :return: Copy of this instance" }, { "code": "def estimate(phenotype, G=None, K=None, covariates=None, overdispersion=True):\n logger = logging.getLogger(__name__)\n logger.info('Heritability estimation has started.')\n G, K = _background_standardize(G, K)\n if G is None and K is None:\n raise Exception('G and K cannot be all None.')\n Q0, Q1, S0 = _background_decomposition(G, K)\n if covariates is None:\n logger.debug('Inserting offset covariate.')\n covariates = ones((phenotype.sample_size, 1))\n logger.debug('Constructing EP.')\n from limix_inference.glmm import ExpFamEP\n ep = ExpFamEP(phenotype.to_likelihood(), covariates, Q0, Q1, S0,\n overdispersion)\n logger.debug('EP optimization.')\n ep.learn()\n h2 = ep.heritability\n logger.info('Found heritability before correction: %.5f.', h2)\n return h2", "docstring": "Estimate the so-called narrow-sense heritability.\n\n It supports Bernoulli and Binomial phenotypes (see `outcome_type`).\n The user must specifiy only one of the parameters G, K, and QS for\n defining the genetic background.\n\n Let :math:`N` be the sample size, :math:`S` the number of covariates, and\n :math:`P_b` the number of genetic markers used for Kinship estimation.\n\n :param numpy.ndarray y: Phenotype. The domain has be the non-negative\n integers. Dimension (:math:`N\\\\times 0`).\n :param numpy.ndarray G: Genetic markers matrix used internally for kinship\n estimation. Dimension (:math:`N\\\\times P_b`).\n :param numpy.ndarray K: Kinship matrix. Dimension (:math:`N\\\\times N`).\n :param tuple QS: Economic eigen decomposition of the Kinship matrix.\n :param numpy.ndarray covariate: Covariates. Default is an offset.\n Dimension (:math:`N\\\\times S`).\n :param object oucome_type: Either :class:`limix_qep.Bernoulli` (default)\n or a :class:`limix_qep.Binomial` instance.\n :param float prevalence: Population rate of cases for dichotomous\n phenotypes. Typically useful for case-control\n studies.\n :return: a tuple containing the estimated heritability and additional\n information, respectively." }, { "code": "def checkout_deploy_branch(deploy_branch, canpush=True):\n create_deploy_branch(deploy_branch, push=canpush)\n remote_branch = \"doctr_remote/{}\".format(deploy_branch)\n print(\"Checking out doctr working branch tracking\", remote_branch)\n clear_working_branch()\n if run(['git', 'rev-parse', '--verify', remote_branch], exit=False) == 0:\n extra_args = ['--track', remote_branch]\n else:\n extra_args = []\n run(['git', 'checkout', '-b', DOCTR_WORKING_BRANCH] + extra_args)\n print(\"Done\")\n return canpush", "docstring": "Checkout the deploy branch, creating it if it doesn't exist." }, { "code": "def get_hour_dirs(root=None):\n root = root or selfplay_dir()\n return list(filter(lambda s: re.match(r\"\\d{4}-\\d{2}-\\d{2}-\\d{2}\", s),\n gfile.ListDirectory(root)))", "docstring": "Gets the directories under selfplay_dir that match YYYY-MM-DD-HH." }, { "code": "def _find(self, id_):\n cur = self._connection.cursor()\n cur.execute(\n 'SELECT fileNumber, offset FROM sequences WHERE id = ?', (id_,))\n row = cur.fetchone()\n if row is None:\n return None\n else:\n return self._getFilename(row[0]), row[1]", "docstring": "Find the filename and offset of a sequence, given its id.\n\n @param id_: A C{str} sequence id.\n @return: A 2-tuple, containing the C{str} file name and C{int} offset\n within that file of the sequence." }, { "code": "def cast_scalar_to_array(shape, value, dtype=None):\n if dtype is None:\n dtype, fill_value = infer_dtype_from_scalar(value)\n else:\n fill_value = value\n values = np.empty(shape, dtype=dtype)\n values.fill(fill_value)\n return values", "docstring": "create np.ndarray of specified shape and dtype, filled with values\n\n Parameters\n ----------\n shape : tuple\n value : scalar value\n dtype : np.dtype, optional\n dtype to coerce\n\n Returns\n -------\n ndarray of shape, filled with value, of specified / inferred dtype" }, { "code": "def get_dict_from_response(response):\n if getattr(response, '_resp') and response._resp.code > 400:\n raise OAuthResponseError(\n 'Application mis-configuration in Globus', None, response\n )\n return response.data", "docstring": "Check for errors in the response and return the resulting JSON." }, { "code": "def request_finished(key):\n with event_lock:\n threads[key] = threads[key][1:]\n if threads[key]:\n threads[key][0].run()", "docstring": "Remove finished Thread from queue.\n\n :param key: data source key" }, { "code": "def _safemembers(members):\n base = _resolved(\".\")\n for finfo in members:\n if _badpath(finfo.name, base):\n print(finfo.name, \"is blocked (illegal path)\")\n elif finfo.issym() and _badlink(finfo, base):\n print(finfo.name, \"is blocked: Hard link to\", finfo.linkname)\n elif finfo.islnk() and _badlink(finfo, base):\n print(finfo.name, \"is blocked: Symlink to\", finfo.linkname)\n else:\n yield finfo", "docstring": "Check members of a tar archive for safety.\n Ensure that they do not contain paths or links outside of where we\n need them - this would only happen if the archive wasn't made by\n eqcorrscan.\n\n :type members: :class:`tarfile.TarFile`\n :param members: an open tarfile." }, { "code": "def get_pdos(dos, lm_orbitals=None, atoms=None, elements=None):\n if not elements:\n symbols = dos.structure.symbol_set\n elements = dict(zip(symbols, [None] * len(symbols)))\n pdos = {}\n for el in elements:\n if atoms and el not in atoms:\n continue\n element_sites = [site for site in dos.structure.sites\n if site.specie == get_el_sp(el)]\n sites = [site for i, site in enumerate(element_sites)\n if not atoms or (el in atoms and i in atoms[el])]\n lm = lm_orbitals[el] if (lm_orbitals and el in lm_orbitals) else None\n orbitals = elements[el] if elements and el in elements else None\n pdos[el] = get_element_pdos(dos, el, sites, lm, orbitals)\n return pdos", "docstring": "Extract the projected density of states from a CompleteDos object.\n\n Args:\n dos (:obj:`~pymatgen.electronic_structure.dos.CompleteDos`): The\n density of states.\n elements (:obj:`dict`, optional): The elements and orbitals to extract\n from the projected density of states. Should be provided as a\n :obj:`dict` with the keys as the element names and corresponding\n values as a :obj:`tuple` of orbitals. For example, the following\n would extract the Bi s, px, py and d orbitals::\n\n {'Bi': ('s', 'px', 'py', 'd')}\n\n If an element is included with an empty :obj:`tuple`, all orbitals\n for that species will be extracted. If ``elements`` is not set or\n set to ``None``, all elements for all species will be extracted.\n lm_orbitals (:obj:`dict`, optional): The orbitals to decompose into\n their lm contributions (e.g. p -> px, py, pz). Should be provided\n as a :obj:`dict`, with the elements names as keys and a\n :obj:`tuple` of orbitals as the corresponding values. For example,\n the following would be used to decompose the oxygen p and d\n orbitals::\n\n {'O': ('p', 'd')}\n\n atoms (:obj:`dict`, optional): Which atomic sites to use when\n calculating the projected density of states. Should be provided as\n a :obj:`dict`, with the element names as keys and a :obj:`tuple` of\n :obj:`int` specifying the atomic indices as the corresponding\n values. The elemental projected density of states will be summed\n only over the atom indices specified. If an element is included\n with an empty :obj:`tuple`, then all sites for that element will\n be included. The indices are 0 based for each element specified in\n the POSCAR. For example, the following will calculate the density\n of states for the first 4 Sn atoms and all O atoms in the\n structure::\n\n {'Sn': (1, 2, 3, 4), 'O': (, )}\n\n If ``atoms`` is not set or set to ``None`` then all atomic sites\n for all elements will be considered.\n\n Returns:\n dict: The projected density of states. Formatted as a :obj:`dict` of\n :obj:`dict` mapping the elements and their orbitals to\n :obj:`~pymatgen.electronic_structure.dos.Dos` objects. For example::\n\n {\n 'Bi': {'s': Dos, 'p': Dos ... },\n 'S': {'s': Dos}\n }" }, { "code": "def _convert_dict_inputs(inputs, tensor_info_map):\n dict_inputs = _prepare_dict_inputs(inputs, tensor_info_map)\n return tensor_info.convert_dict_to_compatible_tensor(dict_inputs,\n tensor_info_map)", "docstring": "Converts from inputs into dict of input tensors.\n\n This handles:\n - putting inputs into a dict, per _prepare_dict_inputs(),\n - converting all input values into tensors compatible with the\n expected input tensor (dtype, shape).\n - check sparse/non-sparse tensor types.\n\n Args:\n inputs: inputs fed to Module.__call__().\n tensor_info_map: A map from string to `tensor_info.ParsedTensorInfo`\n describing the signature inputs.\n\n Returns:\n A dict of tensors to feed to the signature instantiation.\n\n Raises:\n TypeError: If it fails to convert the input values into a dict of tensors\n to feed to the signature instantiation." }, { "code": "def run_type(self):\n METAGGA_TYPES = {\"TPSS\", \"RTPSS\", \"M06L\", \"MBJL\", \"SCAN\", \"MS0\", \"MS1\", \"MS2\"}\n if self.parameters.get(\"LHFCALC\", False):\n rt = \"HF\"\n elif self.parameters.get(\"METAGGA\", \"\").strip().upper() in METAGGA_TYPES:\n rt = self.parameters[\"METAGGA\"].strip().upper()\n elif self.parameters.get(\"LUSE_VDW\", False):\n vdw_gga = {\"RE\": \"DF\", \"OR\": \"optPBE\", \"BO\": \"optB88\",\n \"MK\": \"optB86b\", \"ML\": \"DF2\"}\n gga = self.parameters.get(\"GGA\").upper()\n rt = \"vdW-\" + vdw_gga[gga]\n elif self.potcar_symbols[0].split()[0] == 'PAW':\n rt = \"LDA\"\n else:\n rt = \"GGA\"\n if self.is_hubbard:\n rt += \"+U\"\n return rt", "docstring": "Returns the run type. Currently supports LDA, GGA, vdW-DF and HF calcs.\n\n TODO: Fix for other functional types like PW91, other vdW types, etc." }, { "code": "def _process_input_wcs_single(fname, wcskey, updatewcs):\n if wcskey in ['', ' ', 'INDEF', None]:\n if updatewcs:\n uw.updatewcs(fname, checkfiles=False)\n else:\n numext = fileutil.countExtn(fname)\n extlist = []\n for extn in range(1, numext + 1):\n extlist.append(('SCI', extn))\n if wcskey in string.ascii_uppercase:\n wkey = wcskey\n wname = ' '\n else:\n wname = wcskey\n wkey = ' '\n altwcs.restoreWCS(fname, extlist, wcskey=wkey, wcsname=wname)\n if wcskey not in ['', ' ', 'INDEF', None] or updatewcs:\n wcscorr.init_wcscorr(fname)", "docstring": "See docs for _process_input_wcs.\n This is separated to be spawned in parallel." }, { "code": "def run_once(function, state={}, errors={}):\n @six.wraps(function)\n def _wrapper(*args, **kwargs):\n if function in errors:\n six.reraise(*errors[function])\n try:\n return state[function]\n except KeyError:\n try:\n state[function] = result = function(*args, **kwargs)\n return result\n except Exception:\n errors[function] = sys.exc_info()\n raise\n return _wrapper", "docstring": "A memoization decorator, whose purpose is to cache calls." }, { "code": "def preview(self):\n if self._preview is None:\n from twilio.rest.preview import Preview\n self._preview = Preview(self)\n return self._preview", "docstring": "Access the Preview Twilio Domain\n\n :returns: Preview Twilio Domain\n :rtype: twilio.rest.preview.Preview" }, { "code": "def _create_local_agent_channel(self, io_loop):\n logger.info('Initializing Jaeger Tracer with UDP reporter')\n return LocalAgentSender(\n host=self.local_agent_reporting_host,\n sampling_port=self.local_agent_sampling_port,\n reporting_port=self.local_agent_reporting_port,\n throttling_port=self.throttler_port,\n io_loop=io_loop\n )", "docstring": "Create an out-of-process channel communicating to local jaeger-agent.\n Spans are submitted as SOCK_DGRAM Thrift, sampling strategy is polled\n via JSON HTTP.\n\n :param self: instance of Config" }, { "code": "def _time_request(self, uri, method, **kwargs):\n start_time = time.time()\n resp, body = self.request(uri, method, **kwargs)\n self.times.append((\"%s %s\" % (method, uri),\n start_time, time.time()))\n return resp, body", "docstring": "Wraps the request call and records the elapsed time." }, { "code": "def get_lon_variable(nc):\n if 'longitude' in nc.variables:\n return 'longitude'\n longitudes = nc.get_variables_by_attributes(standard_name=\"longitude\")\n if longitudes:\n return longitudes[0].name\n return None", "docstring": "Returns the variable for longitude\n\n :param netCDF4.Dataset nc: netCDF dataset" }, { "code": "def delete(self, uri, default_response=None):\n url = self.api_url + uri\n response = requests.delete(\n url, headers=self.headers, verify=self.verify_ssl,\n auth=self.auth, timeout=self.timeout)\n return self.success_or_raise(response, default_response=default_response)", "docstring": "Call DELETE on the Gitlab server\n\n >>> gitlab = Gitlab(host='http://localhost:10080', verify_ssl=False)\n >>> gitlab.login(user='root', password='5iveL!fe')\n >>> gitlab.delete('/users/5')\n\n :param uri: String with the URI you wish to delete\n :param default_response: Return value if JSONDecodeError\n :return: Dictionary containing response data\n :raise: HttpError: If invalid response returned" }, { "code": "def authorized(remote_app=None):\n if remote_app not in current_oauthclient.handlers:\n return abort(404)\n state_token = request.args.get('state')\n try:\n assert state_token\n state = serializer.loads(state_token)\n assert state['sid'] == _create_identifier()\n assert state['app'] == remote_app\n set_session_next_url(remote_app, state['next'])\n except (AssertionError, BadData):\n if current_app.config.get('OAUTHCLIENT_STATE_ENABLED', True) or (\n not(current_app.debug or current_app.testing)):\n abort(403)\n try:\n handler = current_oauthclient.handlers[remote_app]()\n except OAuthException as e:\n if e.type == 'invalid_response':\n abort(500)\n else:\n raise\n return handler", "docstring": "Authorized handler callback." }, { "code": "def process_associations(self, limit):\n myfile = '/'.join((self.rawdir, self.files['data']['file']))\n f = gzip.open(myfile, 'rb')\n filereader = io.TextIOWrapper(f, newline=\"\")\n filereader.readline()\n for event, elem in ET.iterparse(filereader):\n self.process_xml_table(\n elem, 'Article_Breed', self._process_article_breed_row, limit)\n self.process_xml_table(\n elem, 'Article_Phene', self._process_article_phene_row, limit)\n self.process_xml_table(\n elem, 'Breed_Phene', self._process_breed_phene_row, limit)\n self.process_xml_table(\n elem, 'Lida_Links', self._process_lida_links_row, limit)\n self.process_xml_table(\n elem, 'Phene_Gene', self._process_phene_gene_row, limit)\n self.process_xml_table(\n elem, 'Group_MPO', self._process_group_mpo_row, limit)\n f.close()\n return", "docstring": "Loop through the xml file and process the article-breed, article-phene,\n breed-phene, phene-gene associations, and the external links to LIDA.\n\n :param limit:\n :return:" }, { "code": "def upgrade(self, package, force=False):\n self.install(package, upgrade=True, force=force)", "docstring": "Shortcut method to upgrade a package. If `force` is set to True,\n the package and all of its dependencies will be reinstalled, otherwise\n if the package is up to date, this command is a no-op." }, { "code": "def offset(self, offset):\n span = self\n if offset > 0:\n for i in iter_range(offset):\n span = span.next_period()\n elif offset < 0:\n for i in iter_range(-offset):\n span = span.prev_period()\n return span", "docstring": "Offset the date range by the given amount of periods.\n\n This differs from :meth:`~spans.types.OffsetableRangeMixin.offset` on\n :class:`spans.types.daterange` by not accepting a ``timedelta`` object.\n Instead it expects an integer to adjust the typed date range by. The\n given value may be negative as well.\n\n :param offset: Number of periods to offset this range by. A period is\n either a day, week, american week, month, quarter or\n year, depending on this range's period type.\n :return: New offset :class:`~spans.types.PeriodRange`" }, { "code": "def state_size(self) -> Sequence[Shape]:\n return self._sizes(self._compiler.rddl.state_size)", "docstring": "Returns the MDP state size." }, { "code": "def fill_n(self, values, weights=None, dropna: bool = True):\n values = np.asarray(values)\n if dropna:\n values = values[~np.isnan(values)]\n if self._binning.is_adaptive():\n map = self._binning.force_bin_existence(values)\n self._reshape_data(self._binning.bin_count, map)\n if weights:\n weights = np.asarray(weights)\n self._coerce_dtype(weights.dtype)\n (frequencies, errors2, underflow, overflow, stats) = \\\n calculate_frequencies(values, self._binning, dtype=self.dtype,\n weights=weights, validate_bins=False)\n self._frequencies += frequencies\n self._errors2 += errors2\n if self.keep_missed:\n self.underflow += underflow\n self.overflow += overflow\n if self._stats:\n for key in self._stats:\n self._stats[key] += stats.get(key, 0.0)", "docstring": "Update histograms with a set of values.\n\n Parameters\n ----------\n values: array_like\n weights: Optional[array_like]\n drop_na: Optional[bool]\n If true (default), all nan's are skipped." }, { "code": "def get_queue_acl(self, queue_name, timeout=None):\n _validate_not_none('queue_name', queue_name)\n request = HTTPRequest()\n request.method = 'GET'\n request.host = self._get_host()\n request.path = _get_path(queue_name)\n request.query = [\n ('comp', 'acl'),\n ('timeout', _int_to_str(timeout)),\n ]\n response = self._perform_request(request)\n return _convert_xml_to_signed_identifiers(response.body)", "docstring": "Returns details about any stored access policies specified on the\n queue that may be used with Shared Access Signatures.\n\n :param str queue_name:\n The name of an existing queue.\n :param int timeout:\n The server timeout, expressed in seconds.\n :return: A dictionary of access policies associated with the queue.\n :rtype: dict of str to :class:`~azure.storage.models.AccessPolicy`" }, { "code": "def wait_until_element_has_focus(self, locator, timeout=None):\n\t\tself._info(\"Waiting for focus on '%s'\" % (locator))\n\t\tself._wait_until_no_error(timeout, self._check_element_focus_exp, True, locator, timeout)", "docstring": "Waits until the element identified by `locator` has focus.\n\t\tYou might rather want to use `Element Focus Should Be Set`\n\n\t\t| *Argument* | *Description* | *Example* |\n\t\t| locator | Selenium 2 element locator | id=my_id |\n\t\t| timeout | maximum time to wait before the function throws an element not found error (default=None) | 5s |" }, { "code": "def distinct(iterable, keyfunc=None):\n seen = set()\n for item in iterable:\n key = item if keyfunc is None else keyfunc(item)\n if key not in seen:\n seen.add(key)\n yield item", "docstring": "Yields distinct items from `iterable` in the order that they appear." }, { "code": "def get_resources(self):\n json_resources = self.rest_client.make_request(self.resource_url)['resources']\n return [RestResource(resource, self.rest_client) for resource in json_resources]", "docstring": "Retrieves a list of all known Streams high-level REST resources.\n\n Returns:\n :py:obj:`list` of :py:class:`~.rest_primitives.RestResource`: List of all Streams high-level REST resources." }, { "code": "def to_pascal_case(s):\n return re.sub(r'(?!^)_([a-zA-Z])', lambda m: m.group(1).upper(), s.capitalize())", "docstring": "Transform underscore separated string to pascal case" }, { "code": "def argset(name, *args, **kwargs):\n def _arg(f):\n if not hasattr(f, '_subcommand_argsets'):\n f._subcommand_argsets = {}\n f._subcommand_argsets.setdefault(name, []).append((args, kwargs))\n return f\n return _arg", "docstring": "Decorator to add sets of required mutually exclusive args to subcommands." }, { "code": "def read_features_and_groups(features_path, groups_path):\n \"Reader for data and groups\"\n try:\n if not pexists(features_path):\n raise ValueError('non-existent features file')\n if not pexists(groups_path):\n raise ValueError('non-existent groups file')\n if isinstance(features_path, str):\n features = np.genfromtxt(features_path, dtype=float)\n else:\n raise ValueError('features input must be a file path ')\n if isinstance(groups_path, str):\n groups = np.genfromtxt(groups_path, dtype=str)\n else:\n raise ValueError('groups input must be a file path ')\n except:\n raise IOError('error reading the specified features and/or groups.')\n if len(features) != len(groups):\n raise ValueError(\"lengths of features and groups do not match!\")\n return features, groups", "docstring": "Reader for data and groups" }, { "code": "def get_method_name(method):\n name = get_object_name(method)\n if name.startswith(\"__\") and not name.endswith(\"__\"):\n name = \"_{0}{1}\".format(get_object_name(method.im_class), name)\n return name", "docstring": "Returns given method name.\n\n :param method: Method to retrieve the name.\n :type method: object\n :return: Method name.\n :rtype: unicode" }, { "code": "def setup(addr, user, remote_path, local_key=None):\n port = find_port(addr, user)\n if not port or not is_alive(addr, user):\n port = new_port()\n scp(addr, user, __file__, '~/unixpipe', local_key)\n ssh_call = ['ssh', '-fL%d:127.0.0.1:12042' % port,\n '-o', 'ExitOnForwardFailure=yes',\n '-o', 'ControlPath=~/.ssh/unixpipe_%%r@%%h_%d' % port,\n '-o', 'ControlMaster=auto',\n '%s@%s' % (user, addr,), 'python', '~/unixpipe',\n 'server', remote_path]\n if local_key:\n ssh_call.insert(1, local_key)\n ssh_call.insert(1, '-i')\n subprocess.call(ssh_call)\n time.sleep(1)\n return port", "docstring": "Setup the tunnel" }, { "code": "def stamp_allowing_unusual_version_table(\n config: Config,\n revision: str,\n sql: bool = False,\n tag: str = None,\n version_table: str = DEFAULT_ALEMBIC_VERSION_TABLE) -> None:\n script = ScriptDirectory.from_config(config)\n starting_rev = None\n if \":\" in revision:\n if not sql:\n raise CommandError(\"Range revision not allowed\")\n starting_rev, revision = revision.split(':', 2)\n def do_stamp(rev: str, context):\n return script._stamp_revs(revision, rev)\n with EnvironmentContext(config,\n script,\n fn=do_stamp,\n as_sql=sql,\n destination_rev=revision,\n starting_rev=starting_rev,\n tag=tag,\n version_table=version_table):\n script.run_env()", "docstring": "Stamps the Alembic version table with the given revision; don't run any\n migrations.\n\n This function is a clone of ``alembic.command.stamp()``, but allowing\n ``version_table`` to change. See\n http://alembic.zzzcomputing.com/en/latest/api/commands.html#alembic.command.stamp" }, { "code": "def from_file(cls, path, format='infer'):\n format = _infer_format(path, format=format)\n origin = os.path.abspath(os.path.dirname(path))\n with open(path) as f:\n data = f.read()\n if format == 'json':\n obj = json.loads(data)\n else:\n obj = yaml.safe_load(data)\n return cls.from_dict(obj, _origin=origin)", "docstring": "Create an instance from a json or yaml file.\n\n Parameters\n ----------\n path : str\n The path to the file to load.\n format : {'infer', 'json', 'yaml'}, optional\n The file format. By default the format is inferred from the file\n extension." }, { "code": "def _register_bounds_validator_if_needed(parser, name, flag_values):\n if parser.lower_bound is not None or parser.upper_bound is not None:\n def checker(value):\n if value is not None and parser.is_outside_bounds(value):\n message = '%s is not %s' % (value, parser.syntactic_help)\n raise _exceptions.ValidationError(message)\n return True\n _validators.register_validator(name, checker, flag_values=flag_values)", "docstring": "Enforces lower and upper bounds for numeric flags.\n\n Args:\n parser: NumericParser (either FloatParser or IntegerParser), provides lower\n and upper bounds, and help text to display.\n name: str, name of the flag\n flag_values: FlagValues." }, { "code": "def _set_int(self, commands, name):\n if name in commands:\n try:\n value = int(commands[name])\n setattr(self, name, value)\n except ValueError:\n pass", "docstring": "set integer value from commands" }, { "code": "def list_source_code(self, context: int = 5) -> None:\n self._verify_entrypoint_selected()\n current_trace_frame = self.trace_tuples[\n self.current_trace_frame_index\n ].trace_frame\n filename = os.path.join(self.repository_directory, current_trace_frame.filename)\n file_lines: List[str] = []\n try:\n with open(filename, \"r\") as file:\n file_lines = file.readlines()\n except FileNotFoundError:\n self.warning(f\"Couldn't open {filename}.\")\n return\n self._output_file_lines(current_trace_frame, file_lines, context)", "docstring": "Show source code around the current trace frame location.\n\n Parameters:\n context: int number of lines to show above and below trace location\n (default: 5)" }, { "code": "def complete_server(self, text, line, begidx, endidx):\n return [i for i in PsiturkShell.server_commands if i.startswith(text)]", "docstring": "Tab-complete server command" }, { "code": "def contexts(self):\n if not hasattr(self, \"_contexts\"):\n cs = {}\n for cr in self.doc[\"contexts\"]:\n cs[cr[\"name\"]] = copy.deepcopy(cr[\"context\"])\n self._contexts = cs\n return self._contexts", "docstring": "Returns known contexts by exposing as a read-only property." }, { "code": "def valid_hash_value(hashname):\n custom_hash_prefix_re = re.compile(r\"^x_\")\n if hashname in enums.HASH_ALGO_OV or custom_hash_prefix_re.match(hashname):\n return True\n else:\n return False", "docstring": "Return true if given value is a valid, recommended hash name according\n to the STIX 2 specification." }, { "code": "def number_of_statements(self, n):\n stmt_type = n.type\n if stmt_type == syms.compound_stmt:\n return 1\n elif stmt_type == syms.stmt:\n return self.number_of_statements(n.children[0])\n elif stmt_type == syms.simple_stmt:\n return len(n.children) // 2\n else:\n raise AssertionError(\"non-statement node\")", "docstring": "Compute the number of AST statements contained in a node." }, { "code": "def describe_processors(cls):\n for processor in cls.post_processors(cls):\n yield {'name': processor.__name__,\n 'description': processor.__doc__,\n 'processor': processor}", "docstring": "List all postprocessors and their description" }, { "code": "def inspect(self):\n timeout_manager = future_timeout_manager(self.sync_timeout)\n sensor_index_before = copy.copy(self._sensors_index)\n request_index_before = copy.copy(self._requests_index)\n try:\n request_changes = yield self.inspect_requests(\n timeout=timeout_manager.remaining())\n sensor_changes = yield self.inspect_sensors(\n timeout=timeout_manager.remaining())\n except Exception:\n self._sensors_index = sensor_index_before\n self._requests_index = request_index_before\n raise\n model_changes = AttrDict()\n if request_changes:\n model_changes.requests = request_changes\n if sensor_changes:\n model_changes.sensors = sensor_changes\n if model_changes:\n raise Return(model_changes)", "docstring": "Inspect device requests and sensors, update model\n\n Returns\n -------\n\n Tornado future that resolves with:\n\n model_changes : Nested AttrDict or None\n Contains sets of added/removed request/sensor names\n\n Example structure:\n\n {'requests': {\n 'added': set(['req1', 'req2']),\n 'removed': set(['req10', 'req20'])}\n 'sensors': {\n 'added': set(['sens1', 'sens2']),\n 'removed': set(['sens10', 'sens20'])}\n }\n\n If there are no changes keys may be omitted. If an item is in both\n the 'added' and 'removed' sets that means that it changed.\n\n If neither request not sensor changes are present, None is returned\n instead of a nested structure." }, { "code": "def make_certificate_authority(**name):\n key = make_pkey()\n csr = make_certificate_signing_request(key, **name)\n crt = make_certificate(csr, key, csr, make_serial(), 0, 10 * 365 * 24 * 60 * 60, exts=[crypto.X509Extension(b'basicConstraints', True, b'CA:TRUE')])\n return key, crt", "docstring": "Make a certificate authority.\n\n A certificate authority can sign certificates. For clients to be able to\n validate certificates signed by your certificate authorithy, they must trust\n the certificate returned by this function.\n\n :param name: Key word arguments containing subject name parts: C, ST, L, O,\n OU, CN.\n :return: A root self-signed certificate to act as an authority.\n :rtype: :class:`OpenSSL.crypto.X509`" }, { "code": "def create(self, key=None, label=None):\n key = '%s' % key\n url = self.bitbucket.url('SET_SSH_KEY')\n return self.bitbucket.dispatch('POST', url, auth=self.bitbucket.auth, key=key, label=label)", "docstring": "Associate an ssh key with your account and return it." }, { "code": "def exec_task(task_path, data):\n if not data:\n data = {'data': None, 'path': task_path}\n elif not isinstance(data, (str, bytes)):\n data = {'data': json.dumps(data, cls=RequestJSONEncoder),\n 'path': task_path}\n else:\n if data is not None and data.startswith(\"file://\"):\n with open(data[len(\"file://\"):]) as f:\n data = f.read()\n data = {'data': data, 'path': task_path}\n job = Job(data)\n (task, task_callable) = create_task(task_path)\n with delegating_job_context(job, task, task_callable) as jc:\n return jc.task_callable(jc.task_data)", "docstring": "Execute task.\n\n :param task_path: task path\n :type task_path: str|Callable\n :param data: task's data\n :type data: Any\n :return:" }, { "code": "def _validate_folder(self, folder=None):\n from expfactory.experiment import load_experiment\n if folder is None:\n folder=os.path.abspath(os.getcwd())\n config = load_experiment(folder, return_path=True)\n if not config:\n return notvalid(\"%s is not an experiment.\" %(folder))\n return self._validate_config(folder)", "docstring": "validate folder takes a cloned github repo, ensures\n the existence of the config.json, and validates it." }, { "code": "def set_sequestered(self, sequestered):\n if sequestered is None:\n raise errors.NullArgument()\n if self.get_sequestered_metadata().is_read_only():\n raise errors.NoAccess()\n if not isinstance(sequestered, bool):\n raise errors.InvalidArgument()\n self._my_map['sequestered'] = sequestered", "docstring": "Sets the sequestered flag.\n\n arg: sequestered (boolean): the new sequestered flag\n raise: InvalidArgument - ``sequestered`` is invalid\n raise: NoAccess - ``Metadata.isReadOnly()`` is ``true``\n *compliance: mandatory -- This method must be implemented.*" }, { "code": "def flatten(self):\n def _flatten(d):\n if isinstance(d, dict):\n for v in d.values():\n for nested_v in _flatten(v):\n yield nested_v\n elif isinstance(d, list):\n for list_v in d:\n for nested_v in _flatten(list_v):\n yield nested_v\n else:\n yield d\n return self.__class__(list(_flatten(self.items)))", "docstring": "Get a flattened list of the items in the collection.\n\n :rtype: Collection" }, { "code": "def extracturls(mesg):\n lines = NLRE.split(mesg)\n linechunks = [parse_text_urls(l) for l in lines]\n return extract_with_context(linechunks,\n lambda chunk: len(chunk) > 1 or\n (len(chunk) == 1 and chunk[0].url is not None),\n 1, 1)", "docstring": "Given a text message, extract all the URLs found in the message, along\n with their surrounding context. The output is a list of sequences of Chunk\n objects, corresponding to the contextual regions extracted from the string." }, { "code": "def render(self, request, instance, **kwargs):\n if instance.get_item():\n return super(LinkPlugin, self).render(request, instance, **kwargs)\n return \"\"", "docstring": "Only render the plugin if the item can be shown to the user" }, { "code": "def _GenerateZipInfo(self, arcname=None, compress_type=None, st=None):\n if st is None:\n st = os.stat_result((0o100644, 0, 0, 0, 0, 0, 0, 0, 0, 0))\n mtime = time.localtime(st.st_mtime or time.time())\n date_time = mtime[0:6]\n if arcname is None:\n raise ValueError(\"An arcname must be provided.\")\n zinfo = zipfile.ZipInfo(arcname, date_time)\n zinfo.external_attr = (st[0] & 0xFFFF) << 16\n if compress_type is None:\n zinfo.compress_type = self._compression\n else:\n zinfo.compress_type = compress_type\n zinfo.file_size = 0\n zinfo.compress_size = 0\n zinfo.flag_bits = 0x08\n zinfo.CRC = 0x08074b50\n zinfo.extra = struct.pack(\n \"= 5:\n print(\"QRY => %s\\nSOLR_PARAMS => %s\" % (self.compiled_query, solr_params))\n except riak.RiakError as err:\n err.value += self._get_debug_data()\n raise\n self._solr_locked = True\n return self._solr_cache['docs']", "docstring": "Executes solr query if it hasn't already executed.\n\n Returns:\n Self." }, { "code": "def clean(self, *args, **kwargs):\n if not self.pk:\n if self.node.participation_settings.voting_allowed is not True:\n raise ValidationError(\"Voting not allowed for this node\")\n if 'nodeshot.core.layers' in settings.INSTALLED_APPS:\n layer = self.node.layer\n if layer.participation_settings.voting_allowed is not True:\n raise ValidationError(\"Voting not allowed for this layer\")", "docstring": "Check if votes can be inserted for parent node or parent layer" }, { "code": "def PlaceSOffsetT(self, x):\n N.enforce_number(x, N.SOffsetTFlags)\n self.head = self.head - N.SOffsetTFlags.bytewidth\n encode.Write(packer.soffset, self.Bytes, self.Head(), x)", "docstring": "PlaceSOffsetT prepends a SOffsetT to the Builder, without checking\n for space." }, { "code": "def send(self, msg):\n if self._conn:\n self._conn.write_data(msg.message, msg.response_command)", "docstring": "Send a message to Elk panel." }, { "code": "def _first_of_quarter(self, day_of_week=None):\n return self.on(self.year, self.quarter * 3 - 2, 1).first_of(\n \"month\", day_of_week\n )", "docstring": "Modify to the first occurrence of a given day of the week\n in the current quarter. If no day_of_week is provided,\n modify to the first day of the quarter. Use the supplied consts\n to indicate the desired day_of_week, ex. DateTime.MONDAY.\n\n :type day_of_week: int or None\n\n :rtype: DateTime" }, { "code": "def _spherical_to_cartesian(cls, coord, center):\n r, theta, phi, r_dot, theta_dot, phi_dot = coord\n x = r * cos(phi) * cos(theta)\n y = r * cos(phi) * sin(theta)\n z = r * sin(phi)\n vx = r_dot * x / r - y * theta_dot - z * phi_dot * cos(theta)\n vy = r_dot * y / r + x * theta_dot - z * phi_dot * sin(theta)\n vz = r_dot * z / r + r * phi_dot * cos(phi)\n return np.array([x, y, z, vx, vy, vz], dtype=float)", "docstring": "Spherical to cartesian conversion" }, { "code": "def get(self, namespace, key):\n cfg = self.dbconfig.get(key, namespace, as_object=True)\n return self.make_response({\n 'message': None,\n 'config': cfg\n })", "docstring": "Get a specific configuration item" }, { "code": "def investment_term(self, investment_term):\n try:\n if isinstance(investment_term, (str, int)):\n self._investment_term = int(investment_term)\n except Exception:\n raise ValueError('invalid input of investment type %s, cannot be converted to an int' %\n investment_term)", "docstring": "This investment term is in months. This might change to a relative delta." }, { "code": "def run(self):\n LOGGER.debug('Initializing process')\n self.logging_config = self.setup_logging()\n self.setup_signal_handlers()\n try:\n self.app = self.create_application()\n except exceptions.NoRoutesException:\n return\n self.http_server = self.create_http_server()\n self.ioloop = ioloop.IOLoop.instance()\n try:\n self.ioloop.start()\n except KeyboardInterrupt:\n pass", "docstring": "Called when the process has started\n\n :param int port: The HTTP Server port" }, { "code": "def check_robotstxt(url, session):\n roboturl = get_roboturl(url)\n rp = get_robotstxt_parser(roboturl, session=session)\n if not rp.can_fetch(UserAgent, str(url)):\n raise IOError(\"%s is disallowed by %s\" % (url, roboturl))", "docstring": "Check if robots.txt allows our user agent for the given URL.\n @raises: IOError if URL is not allowed" }, { "code": "def receiveds_not_parsed(receiveds):\n log.debug(\"Receiveds for this email are not parsed\")\n output = []\n counter = Counter()\n for i in receiveds[::-1]:\n j = {\"raw\": i.strip()}\n j[\"hop\"] = counter[\"hop\"] + 1\n counter[\"hop\"] += 1\n output.append(j)\n else:\n return output", "docstring": "If receiveds are not parsed, makes a new structure with raw\n field. It's useful to have the same structure of receiveds\n parsed.\n\n Args:\n receiveds (list): list of raw receiveds headers\n\n Returns:\n a list of not parsed receiveds headers with first hop in first position" }, { "code": "def limit_x(\n self,\n limit_lower = None,\n limit_upper = None\n ):\n if limit_lower is None and limit_upper is None:\n return self._limit_x\n elif hasattr(limit_lower, \"__iter__\"):\n self._limit_x = limit_lower[:2]\n else:\n self._limit_x = [limit_lower, limit_upper]\n if self._limit_x[0] == self._limit_x[1]:\n self._limit_x[1] += 1\n self._limit_x[0] -= self.mod_x\n self._limit_x[1] += self.mod_x", "docstring": "get or set x limits of the current axes\n\n x_min, x_max = limit_x() # return the current limit_x\n limit_x(x_min, x_max) # set the limit_x to x_min, x_max" }, { "code": "def _unbytes(bytestr):\n return ''.join(chr(int(bytestr[k:k + 2], 16))\n for k in range(0, len(bytestr), 2))", "docstring": "Returns a bytestring from the human-friendly string returned by `_bytes`.\n\n >>> _unbytes('123456')\n '\\x12\\x34\\x56'" }, { "code": "def _properties_model_to_dict(properties):\n result = {}\n for attr in properties.__dict__:\n value = getattr(properties, attr)\n if hasattr(value, '__module__') and 'models' in value.__module__:\n value = _properties_model_to_dict(value)\n if not (value is None or (isinstance(value, dict) and not value)):\n result[attr] = value\n return result", "docstring": "Convert properties model to dict.\n\n Args:\n properties: Properties model.\n\n Returns:\n dict: Converted model." }, { "code": "def _get_datasets(dataset_ids):\n dataset_dict = {}\n datasets = []\n if len(dataset_ids) > qry_in_threshold:\n idx = 0\n extent =qry_in_threshold\n while idx < len(dataset_ids):\n log.info(\"Querying %s datasets\", len(dataset_ids[idx:extent]))\n rs = db.DBSession.query(Dataset).filter(Dataset.id.in_(dataset_ids[idx:extent])).all()\n datasets.extend(rs)\n idx = idx + qry_in_threshold\n if idx + qry_in_threshold > len(dataset_ids):\n extent = len(dataset_ids)\n else:\n extent = extent + qry_in_threshold\n else:\n datasets = db.DBSession.query(Dataset).filter(Dataset.id.in_(dataset_ids))\n for r in datasets:\n dataset_dict[r.id] = r\n log.info(\"Retrieved %s datasets\", len(dataset_dict))\n return dataset_dict", "docstring": "Get all the datasets in a list of dataset IDS. This must be done in chunks of 999,\n as sqlite can only handle 'in' with < 1000 elements." }, { "code": "def parse_template(template_str):\n try:\n return json.loads(template_str, object_pairs_hook=OrderedDict)\n except ValueError:\n yaml.SafeLoader.add_constructor(yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG, _dict_constructor)\n yaml.SafeLoader.add_multi_constructor('!', intrinsics_multi_constructor)\n return yaml.safe_load(template_str)", "docstring": "Parse the SAM template.\n\n :param template_str: A packaged YAML or json CloudFormation template\n :type template_str: str\n :return: Dictionary with keys defined in the template\n :rtype: dict" }, { "code": "def wait_for(self, wait_for, timeout_ms):\n if not isinstance(wait_for, baseinteger):\n raise TypeError(\"wait_for can only be an instance of type baseinteger\")\n if not isinstance(timeout_ms, baseinteger):\n raise TypeError(\"timeout_ms can only be an instance of type baseinteger\")\n reason = self._call(\"waitFor\",\n in_p=[wait_for, timeout_ms])\n reason = ProcessWaitResult(reason)\n return reason", "docstring": "Waits for one or more events to happen.\n\n in wait_for of type int\n Specifies what to wait for;\n see :py:class:`ProcessWaitForFlag` for more information.\n\n in timeout_ms of type int\n Timeout (in ms) to wait for the operation to complete.\n Pass 0 for an infinite timeout.\n\n return reason of type :class:`ProcessWaitResult`\n The overall wait result;\n see :py:class:`ProcessWaitResult` for more information." }, { "code": "def _update_justification(self, justification):\n states = {\"left\": 2, \"center\": 0, \"right\": 1}\n self.justify_tb.state = states[justification]\n self.justify_tb.toggle(None)\n self.justify_tb.Refresh()", "docstring": "Updates horizontal text justification button\n\n Parameters\n ----------\n\n justification: String in [\"left\", \"center\", \"right\"]\n \\tSwitches button to untoggled if False and toggled if True" }, { "code": "def make_choice_validator(\n choices, default_key=None, normalizer=None):\n def normalize_all(_choices):\n if normalizer:\n _choices = [(normalizer(key), value) for key, value in choices]\n return _choices\n choices = normalize_all(choices)\n def choice_validator(value):\n if normalizer:\n value = normalizer(value)\n if not value and default_key:\n value = choices[default_key][0]\n results = []\n for choice, mapped in choices:\n if value == choice:\n return mapped\n if choice.startswith(value):\n results.append((choice, mapped))\n if len(results) == 1:\n return results[0][1]\n elif not results:\n raise ValueError('Invalid choice.')\n else:\n raise ValueError(\n 'Choice ambiguous between (%s)' % ', '.join(\n k for k, v in normalize_all(results))\n )\n return choice_validator", "docstring": "Returns a callable that accepts the choices provided.\n\n Choices should be provided as a list of 2-tuples, where the first\n element is a string that should match user input (the key); the\n second being the value associated with the key.\n\n The callable by default will match, upon complete match the first\n value associated with the result will be returned. Partial matches\n are supported.\n\n If a default is provided, that value will be returned if the user\n provided input is empty, i.e. the value that is mapped to the empty\n string.\n\n Finally, a normalizer function can be passed. This normalizes all\n keys and validation value." }, { "code": "def ProcessMessages(self, active_notifications, queue_manager, time_limit=0):\n now = time.time()\n processed = 0\n for notification in active_notifications:\n if notification.session_id not in self.queued_flows:\n if time_limit and time.time() - now > time_limit:\n break\n processed += 1\n self.queued_flows.Put(notification.session_id, 1)\n self.thread_pool.AddTask(\n target=self._ProcessMessages,\n args=(notification, queue_manager.Copy()),\n name=self.__class__.__name__)\n return processed", "docstring": "Processes all the flows in the messages.\n\n Precondition: All tasks come from the same queue.\n\n Note that the server actually completes the requests in the\n flow when receiving the messages from the client. We do not really\n look at the messages here at all any more - we just work from the\n completed messages in the flow RDFValue.\n\n Args:\n active_notifications: The list of notifications.\n queue_manager: QueueManager object used to manage notifications,\n requests and responses.\n time_limit: If set return as soon as possible after this many seconds.\n\n Returns:\n The number of processed flows." }, { "code": "def create_tree(self):\n feature_indices = []\n for i in self.estimator.tree_.feature:\n n_features = self.n_features\n if self.n_features > 1 or (self.n_features == 1 and i >= 0):\n feature_indices.append([str(j) for j in range(n_features)][i])\n indentation = 1 if self.target_language in ['java', 'js',\n 'php', 'ruby'] else 0\n return self.create_branches(\n self.estimator.tree_.children_left,\n self.estimator.tree_.children_right,\n self.estimator.tree_.threshold,\n self.estimator.tree_.value,\n feature_indices, 0, indentation)", "docstring": "Parse and build the tree branches.\n\n Returns\n -------\n :return : string\n The tree branches as string." }, { "code": "def yaml_to_str(data: Mapping) -> str:\n return yaml.dump(data, Dumper=ruamel.yaml.RoundTripDumper)", "docstring": "Return the given given config as YAML str.\n\n :param data: configuration dict\n :return: given configuration as yaml str" }, { "code": "async def create(self, token):\n token = encode_token(token)\n response = await self._api.put(\"/v1/acl/create\", data=token)\n return response.body", "docstring": "Creates a new token with a given policy\n\n Parameters:\n token (Object): Token specification\n Returns:\n Object: token ID\n\n The create endpoint is used to make a new token.\n A token has a name, a type, and a set of ACL rules.\n\n The request body may take the form::\n\n {\n \"Name\": \"my-app-token\",\n \"Type\": \"client\",\n \"Rules\": \"\"\n }\n\n None of the fields are mandatory. The **Name** and **Rules** fields\n default to being blank, and the **Type** defaults to \"client\".\n\n **Name** is opaque to Consul. To aid human operators, it should\n be a meaningful indicator of the ACL's purpose.\n\n **Type** is either **client** or **management**. A management token\n is comparable to a root user and has the ability to perform any action\n including creating, modifying and deleting ACLs.\n\n **ID** field may be provided, and if omitted a random UUID will be\n generated.\n\n The format of **Rules** is\n `documented here `_.\n\n A successful response body will return the **ID** of the newly\n created ACL, like so::\n\n {\n \"ID\": \"adf4238a-882b-9ddc-4a9d-5b6758e4159e\"\n }" }, { "code": "def _get_groups(network_id, template_id=None):\n extras = {'types':[], 'attributes':[]}\n group_qry = db.DBSession.query(ResourceGroup).filter(\n ResourceGroup.network_id==network_id,\n ResourceGroup.status=='A').options(\n noload('network')\n )\n if template_id is not None:\n group_qry = group_qry.filter(ResourceType.group_id==ResourceGroup.id,\n TemplateType.id==ResourceType.type_id,\n TemplateType.template_id==template_id)\n group_res = db.DBSession.execute(group_qry.statement).fetchall()\n groups = []\n for g in group_res:\n groups.append(JSONObject(g, extras=extras))\n return groups", "docstring": "Get all the resource groups in a network" }, { "code": "def add_child_hash(self, child_hash):\n if not (isinstance(child_hash,PCABinaryProjections) or isinstance(child_hash,RandomBinaryProjections) or isinstance(child_hash,RandomBinaryProjectionTree)):\n raise ValueError('Child hashes must generate binary keys')\n self.child_hashes.append(child_hash)", "docstring": "Adds specified child hash.\n\n The hash must be one of the binary types." }, { "code": "def convertfields_old(key_comm, obj, inblock=None):\n convinidd = ConvInIDD()\n typefunc = dict(integer=convinidd.integer, real=convinidd.real)\n types = []\n for comm in key_comm:\n types.append(comm.get('type', [None])[0])\n convs = [typefunc.get(typ, convinidd.no_type) for typ in types]\n try:\n inblock = list(inblock)\n except TypeError as e:\n inblock = ['does not start with N'] * len(obj)\n for i, (val, conv, avar) in enumerate(zip(obj, convs, inblock)):\n if i == 0:\n pass\n else:\n val = conv(val, inblock[i])\n obj[i] = val\n return obj", "docstring": "convert the float and interger fields" }, { "code": "def to_sa_pair_form(self, sparse=True):\n if self._sa_pair:\n return self\n else:\n s_ind, a_ind = np.where(self.R > - np.inf)\n RL = self.R[s_ind, a_ind]\n if sparse:\n QL = sp.csr_matrix(self.Q[s_ind, a_ind])\n else:\n QL = self.Q[s_ind, a_ind]\n return DiscreteDP(RL, QL, self.beta, s_ind, a_ind)", "docstring": "Convert this instance of `DiscreteDP` to SA-pair form\n\n Parameters\n ----------\n sparse : bool, optional(default=True)\n Should the `Q` matrix be stored as a sparse matrix?\n If true the CSR format is used\n\n Returns\n -------\n ddp_sa : DiscreteDP\n The correspnoding DiscreteDP instance in SA-pair form\n\n Notes\n -----\n If this instance is already in SA-pair form then it is returned\n un-modified" }, { "code": "def write_to(self, f):\n f.write(self.version + \"\\r\\n\")\n for name, value in self.items():\n name = name.title()\n name = name.replace(\"Warc-\", \"WARC-\").replace(\"-Ip-\", \"-IP-\").replace(\"-Id\", \"-ID\").replace(\"-Uri\", \"-URI\")\n f.write(name)\n f.write(\": \")\n f.write(value)\n f.write(\"\\r\\n\")\n f.write(\"\\r\\n\")", "docstring": "Writes this header to a file, in the format specified by WARC." }, { "code": "def get_most_recent_network_by_name(self, name: str) -> Optional[Network]:\n return self.session.query(Network).filter(Network.name == name).order_by(Network.created.desc()).first()", "docstring": "Get the most recently created network with the given name." }, { "code": "def fileInfo(self, index):\n return self._fs_model_source.fileInfo(\n self._fs_model_proxy.mapToSource(index))", "docstring": "Gets the file info of the item at the specified ``index``.\n\n :param index: item index - QModelIndex\n :return: QFileInfo" }, { "code": "def indication(self, *args, **kwargs):\n if not self.current_terminal:\n raise RuntimeError(\"no active terminal\")\n if not isinstance(self.current_terminal, Server):\n raise RuntimeError(\"current terminal not a server\")\n self.current_terminal.indication(*args, **kwargs)", "docstring": "Downstream packet, send to current terminal." }, { "code": "def labels(self):\n labels = self._properties.get(\"labels\")\n if labels is None:\n return {}\n return copy.deepcopy(labels)", "docstring": "Retrieve or set labels assigned to this bucket.\n\n See\n https://cloud.google.com/storage/docs/json_api/v1/buckets#labels\n\n .. note::\n\n The getter for this property returns a dict which is a *copy*\n of the bucket's labels. Mutating that dict has no effect unless\n you then re-assign the dict via the setter. E.g.:\n\n >>> labels = bucket.labels\n >>> labels['new_key'] = 'some-label'\n >>> del labels['old_key']\n >>> bucket.labels = labels\n >>> bucket.update()\n\n :setter: Set labels for this bucket.\n :getter: Gets the labels for this bucket.\n\n :rtype: :class:`dict`\n :returns: Name-value pairs (string->string) labelling the bucket." }, { "code": "def group_add(self, name='Ungrouped'):\n if not hasattr(self, name):\n self.__dict__[name] = Group(self, name)\n self.loaded_groups.append(name)", "docstring": "Dynamically add a group instance to the system if not exist.\n\n Parameters\n ----------\n name : str, optional ('Ungrouped' as default)\n Name of the group\n\n Returns\n -------\n None" }, { "code": "def process(self, document):\n content = json.dumps(document)\n versions = {}\n versions.update({'Spline': Version(VERSION)})\n versions.update(self.get_version(\"Bash\", self.BASH_VERSION))\n if content.find('\"docker(container)\":') >= 0 or content.find('\"docker(image)\":') >= 0:\n versions.update(VersionsCheck.get_version(\"Docker\", self.DOCKER_VERSION))\n if content.find('\"packer\":') >= 0:\n versions.update(VersionsCheck.get_version(\"Packer\", self.PACKER_VERSION))\n if content.find('\"ansible(simple)\":') >= 0:\n versions.update(VersionsCheck.get_version('Ansible', self.ANSIBLE_VERSION))\n return versions", "docstring": "Logging versions of required tools." }, { "code": "def write_metadata(self, fp):\n fp.attrs['model'] = self.name\n fp.attrs['variable_params'] = list(self.variable_params)\n fp.attrs['sampling_params'] = list(self.sampling_params)\n fp.write_kwargs_to_attrs(fp.attrs, static_params=self.static_params)", "docstring": "Writes metadata to the given file handler.\n\n Parameters\n ----------\n fp : pycbc.inference.io.BaseInferenceFile instance\n The inference file to write to." }, { "code": "def build_synchronize_decorator():\n lock = threading.Lock()\n def lock_decorator(fn):\n @functools.wraps(fn)\n def lock_decorated(*args, **kwargs):\n with lock:\n return fn(*args, **kwargs)\n return lock_decorated\n return lock_decorator", "docstring": "Returns a decorator which prevents concurrent calls to functions.\n\n Usage:\n synchronized = build_synchronize_decorator()\n\n @synchronized\n def read_value():\n ...\n\n @synchronized\n def write_value(x):\n ...\n\n Returns:\n make_threadsafe (fct): The decorator which lock all functions to which it\n is applied under a same lock" }, { "code": "def read_colorscale(cmap_file):\n assert isinstance(cmap_file, str)\n cm = np.loadtxt(cmap_file, delimiter='\\t', dtype=np.float64)\n rgb = np.int64(cm[:, 1:])\n n = cm.shape[0]\n colorscale = []\n for i in range(n):\n colorscale.append(\n [i / float(n - 1),\n 'rgb(%d, %d, %d)' % (rgb[i, 0], rgb[i, 1], rgb[i, 2])]\n )\n return colorscale", "docstring": "Return a colorscale in the format expected by plotly.\n\n Parameters\n ----------\n cmap_file : str\n Path of a plain-text file containing the colorscale. \n\n Returns\n -------\n list\n The colorscale.\n \n Notes\n -----\n A plotly colorscale is a list where each item is a pair\n (i.e., a list with two elements) consisting of\n a decimal number x between 0 and 1 and a corresponding \"rgb(r,g,b)\" string,\n where r, g, and b are integers between 0 and 255.\n\n The `cmap_file` is a tab-separated text file containing four columns\n (x,r,g,b), so that each row corresponds to an entry in the list\n described above." }, { "code": "def recent_photos(request):\n imgs = []\n for obj in Image_File.objects.filter(is_image=True).order_by(\"-date_created\"):\n upurl = \"/\" + obj.upload.url\n thumburl = \"\"\n if obj.thumbnail:\n thumburl = \"/\" + obj.thumbnail.url\n imgs.append({'src': upurl, 'thumb': thumburl, 'is_image': True})\n return render_to_response('dashboard/browse.html', {'files': imgs})", "docstring": "returns all the images from the data base" }, { "code": "def solveConsKinkyPref(solution_next,IncomeDstn,PrefShkDstn,\n LivPrb,DiscFac,CRRA,Rboro,Rsave,PermGroFac,BoroCnstArt,\n aXtraGrid,vFuncBool,CubicBool):\n solver = ConsKinkyPrefSolver(solution_next,IncomeDstn,PrefShkDstn,LivPrb,\n DiscFac,CRRA,Rboro,Rsave,PermGroFac,BoroCnstArt,\n aXtraGrid,vFuncBool,CubicBool)\n solver.prepareToSolve()\n solution = solver.solve()\n return solution", "docstring": "Solves a single period of a consumption-saving model with preference shocks\n to marginal utility and a different interest rate on saving vs borrowing.\n Problem is solved using the method of endogenous gridpoints.\n\n Parameters\n ----------\n solution_next : ConsumerSolution\n The solution to the succeeding one period problem.\n IncomeDstn : [np.array]\n A list containing three arrays of floats, representing a discrete\n approximation to the income process between the period being solved\n and the one immediately following (in solution_next). Order: event\n probabilities, permanent shocks, transitory shocks.\n PrefShkDstn : [np.array]\n Discrete distribution of the multiplicative utility shifter. Order:\n probabilities, preference shocks.\n LivPrb : float\n Survival probability; likelihood of being alive at the beginning of\n the succeeding period.\n DiscFac : float\n Intertemporal discount factor for future utility.\n CRRA : float\n Coefficient of relative risk aversion.\n Rboro: float\n Interest factor on assets between this period and the succeeding\n period when assets are negative.\n Rsave: float\n Interest factor on assets between this period and the succeeding\n period when assets are positive.\n PermGroGac : float\n Expected permanent income growth factor at the end of this period.\n BoroCnstArt: float or None\n Borrowing constraint for the minimum allowable assets to end the\n period with. If it is less than the natural borrowing constraint,\n then it is irrelevant; BoroCnstArt=None indicates no artificial bor-\n rowing constraint.\n aXtraGrid: np.array\n Array of \"extra\" end-of-period asset values-- assets above the\n absolute minimum acceptable level.\n vFuncBool: boolean\n An indicator for whether the value function should be computed and\n included in the reported solution.\n CubicBool: boolean\n An indicator for whether the solver should use cubic or linear inter-\n polation.\n\n Returns\n -------\n solution: ConsumerSolution\n The solution to the single period consumption-saving problem. Includes\n a consumption function cFunc (using linear splines), a marginal value\n function vPfunc, a minimum acceptable level of normalized market re-\n sources mNrmMin, normalized human wealth hNrm, and bounding MPCs MPCmin\n and MPCmax. It might also have a value function vFunc. The consumption\n function is defined over normalized market resources and the preference\n shock, c = cFunc(m,PrefShk), but the (marginal) value function is defined\n unconditionally on the shock, just before it is revealed." }, { "code": "def grant(args):\n try:\n role = resources.iam.Role(args.iam_role_or_instance)\n role.load()\n except ClientError:\n role = get_iam_role_for_instance(args.iam_role_or_instance)\n role.attach_policy(PolicyArn=ensure_deploy_iam_policy().arn)\n for private_repo in [args.repo] + list(private_submodules(args.repo)):\n gh_owner_name, gh_repo_name = parse_repo_name(private_repo)\n secret = secrets.put(argparse.Namespace(secret_name=\"deploy.{}.{}\".format(gh_owner_name, gh_repo_name),\n iam_role=role.name,\n instance_profile=None,\n iam_group=None,\n iam_user=None,\n generate_ssh_key=True))\n get_repo(private_repo).create_key(__name__ + \".\" + role.name, secret[\"ssh_public_key\"])\n logger.info(\"Created deploy key %s for IAM role %s to access GitHub repo %s\",\n secret[\"ssh_key_fingerprint\"], role.name, private_repo)", "docstring": "Given an IAM role or instance name, attach an IAM policy granting\n appropriate permissions to subscribe to deployments. Given a\n GitHub repo URL, create and record deployment keys for the repo\n and any of its private submodules, making the keys accessible to\n the IAM role." }, { "code": "def _create_table(self, table_name):\n if self.fieldnames:\n sql_fields = []\n for field in self._fields:\n if field != '_id':\n if 'dblite' in self._fields[field]:\n sql_fields.append(' '.join([field, self._fields[field]['dblite']]))\n else:\n sql_fields.append(field)\n sql_fields = ','.join(sql_fields)\n SQL = 'CREATE TABLE IF NOT EXISTS %s (%s);' % (table_name, sql_fields)\n try:\n self._cursor.execute(SQL)\n except sqlite3.OperationalError, err:\n raise RuntimeError('Create table error, %s, SQL: %s' % (err, SQL))", "docstring": "create sqlite's table for storing simple dictionaries" }, { "code": "def on_frame(self, frame_in):\n if self.rpc.on_frame(frame_in):\n return\n if frame_in.name in CONTENT_FRAME:\n self._inbound.append(frame_in)\n elif frame_in.name == 'Basic.Cancel':\n self._basic_cancel(frame_in)\n elif frame_in.name == 'Basic.CancelOk':\n self.remove_consumer_tag(frame_in.consumer_tag)\n elif frame_in.name == 'Basic.ConsumeOk':\n self.add_consumer_tag(frame_in['consumer_tag'])\n elif frame_in.name == 'Basic.Return':\n self._basic_return(frame_in)\n elif frame_in.name == 'Channel.Close':\n self._close_channel(frame_in)\n elif frame_in.name == 'Channel.Flow':\n self.write_frame(specification.Channel.FlowOk(frame_in.active))\n else:\n LOGGER.error(\n '[Channel%d] Unhandled Frame: %s -- %s',\n self.channel_id, frame_in.name, dict(frame_in)\n )", "docstring": "Handle frame sent to this specific channel.\n\n :param pamqp.Frame frame_in: Amqp frame.\n :return:" }, { "code": "def transpose(self, permutation: Optional[List[int]] = None) -> 'TensorFluent':\n if permutation == []:\n return self\n t = tf.transpose(self.tensor, permutation) if permutation != [] else self.tensor\n scope = self.scope.as_list()\n batch = self.batch\n return TensorFluent(t, scope, batch=batch)", "docstring": "Returns a TensorFluent for the transpose operation with given `permutation`.\n\n Args:\n permutation: The output's shape permutation.\n\n Returns:\n A TensorFluent wrapping the transpose operation." }, { "code": "def get_maya_location(self, ):\n import _winreg\n for ver in MAYA_VERSIONS:\n try:\n key = _winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,\n MAYA_REG_KEY.format(mayaversion=ver), 0,\n _winreg.KEY_READ | _winreg.KEY_WOW64_64KEY)\n value = _winreg.QueryValueEx(key, \"MAYA_INSTALL_LOCATION\")[0]\n except WindowsError:\n log.debug('Maya %s installation not found in registry!' % ver)\n if not value:\n raise errors.SoftwareNotFoundError('Maya %s installation not found in registry!' % MAYA_VERSIONS)\n return value", "docstring": "Return the installation path to maya\n\n :returns: path to maya\n :rtype: str\n :raises: errors.SoftwareNotFoundError" }, { "code": "async def async_get_api_key(session, host, port, username=None, password=None, **kwargs):\n url = 'http://{host}:{port}/api'.format(host=host, port=str(port))\n auth = None\n if username and password:\n auth = aiohttp.BasicAuth(username, password=password)\n data = b'{\"devicetype\": \"pydeconz\"}'\n response = await async_request(session.post, url, auth=auth, data=data)\n api_key = response[0]['success']['username']\n _LOGGER.info(\"API key: %s\", api_key)\n return api_key", "docstring": "Get a new API key for devicetype." }, { "code": "def take_data_triggered(self, trigger, edge, stop):\n param = {\n ('curve', 'rising', 'buffer'): 0,\n ('point', 'rising', 'buffer'): 1,\n ('curve', 'falling', 'buffer'): 2,\n ('point', 'falling', 'buffer'): 3,\n ('curve', 'rising', 'halt'): 4,\n ('point', 'rising', 'halt'): 5,\n ('curve', 'falling', 'halt'): 6,\n ('point', 'falling', 'halt'): 7,\n ('curve', 'rising', 'trigger'): 8,\n ('curve', 'falling', 'trigger'): 9,\n }\n self._write(('TDT', Integer), param[(trigger, edge, stop)])", "docstring": "Configures data acquisition to start on various trigger conditions.\n\n :param trigger: The trigger condition, either 'curve' or 'point'.\n\n ======= =======================================================\n Value Description\n ======= =======================================================\n 'curve' Each trigger signal starts a curve acquisition.\n 'point' A point is stored for each trigger signal. The max\n trigger frequency in this mode is 1 kHz.\n ======= =======================================================\n\n :param edge: Defines wether a 'rising' or 'falling' edge is interpreted\n as a trigger signal.\n :param stop: The stop condition. Valid are 'buffer', 'halt',\n 'rising' and 'falling'.\n\n ========= ==========================================================\n Value Description\n ========= ==========================================================\n 'buffer' Data acquisition stops when the number of point\n specified in :attr:`~.Buffer.length` is acquired.\n 'halt' Data acquisition stops when the halt command is issued.\n 'trigger' Takes data for the period of a trigger event. If edge is\n 'rising' then teh acquisition starts on the rising edge of\n the trigger signal and stops on the falling edge and vice\n versa\n ========= ==========================================================" }, { "code": "def temporary_dir(root_dir=None, cleanup=True, suffix='', permissions=None, prefix=tempfile.template):\n path = tempfile.mkdtemp(dir=root_dir, suffix=suffix, prefix=prefix)\n try:\n if permissions is not None:\n os.chmod(path, permissions)\n yield path\n finally:\n if cleanup:\n shutil.rmtree(path, ignore_errors=True)", "docstring": "A with-context that creates a temporary directory.\n\n :API: public\n\n You may specify the following keyword args:\n :param string root_dir: The parent directory to create the temporary directory.\n :param bool cleanup: Whether or not to clean up the temporary directory.\n :param int permissions: If provided, sets the directory permissions to this mode." }, { "code": "def _decompress(self, cmd, s3_snap):\n compressor = COMPRESSORS.get(s3_snap.compressor)\n if compressor is None:\n return cmd\n decompress_cmd = compressor['decompress']\n return \"{} | {}\".format(decompress_cmd, cmd)", "docstring": "Adds the appropriate command to decompress the zfs stream\n This is determined from the metadata of the s3_snap." }, { "code": "def __get_attribute(node, name, default_value=''):\n if node.hasAttribute(name):\n return node.attributes[name].value.strip()\n else:\n return default_value", "docstring": "Retrieves the attribute of the given name from the node.\n\n If not present then the default_value is used." }, { "code": "def partition_payload(data, key, thresh):\n data = data[key]\n for i in range(0, len(data), thresh):\n yield {key: data[i:i + thresh]}", "docstring": "Yield partitions of a payload\n\n e.g. with a threshold of 2:\n\n { \"dataElements\": [1, 2, 3] }\n -->\n { \"dataElements\": [1, 2] }\n and\n { \"dataElements\": [3] }\n\n :param data: the payload\n :param key: the key of the dict to partition\n :param thresh: the maximum value of a chunk\n :return: a generator where __next__ is a partition of the payload" }, { "code": "def grouper(iterable: Iterable, size: int) -> Iterable:\n it = iter(iterable)\n while True:\n chunk = list(itertools.islice(it, size))\n if not chunk:\n return\n yield chunk", "docstring": "Collect data into fixed-length chunks or blocks without discarding underfilled chunks or padding them.\n\n :param iterable: A sequence of inputs.\n :param size: Chunk size.\n :return: Sequence of chunks." }, { "code": "def use(self, key, value):\n old_value = self[key]\n try:\n self[key] = value\n yield self\n finally:\n self[key] = old_value", "docstring": "Temporarily set a parameter value using the with statement.\n Aliasing allowed." }, { "code": "def charges(self, num, charge_id=None, **kwargs):\n baseuri = self._BASE_URI + \"company/{}/charges\".format(num)\n if charge_id is not None:\n baseuri += \"/{}\".format(charge_id)\n res = self.session.get(baseuri, params=kwargs)\n else:\n res = self.session.get(baseuri, params=kwargs)\n self.handle_http_error(res)\n return res", "docstring": "Search for charges against a company by company number.\n\n Args:\n num (str): Company number to search on.\n transaction (Optional[str]): Filing record number.\n kwargs (dict): additional keywords passed into\n requests.session.get params keyword." }, { "code": "def define(self):\n self.collections = []\n self.camera_collection = \\\n SimpleCollection(filename=os.path.join(self.directory, \"devices.dat\"),\n row_classes=[\n DataModel.EmptyRow,\n DataModel.RTSPCameraRow,\n DataModel.USBCameraRow\n ]\n )\n self.collections.append(self.camera_collection)\n self.config_collection = \\\n SimpleCollection(filename=os.path.join(self.directory, \"config.dat\"),\n row_classes=[\n DataModel.MemoryConfigRow\n ]\n )\n self.collections.append(self.config_collection)", "docstring": "Define column patterns and collections" }, { "code": "def get_prediction(self, u=0):\n return dot(self.F, self.x) + dot(self.B, u)", "docstring": "Predicts the next state of the filter and returns it. Does not\n alter the state of the filter.\n\n Parameters\n ----------\n u : ndarray\n optional control input\n\n Returns\n -------\n x : ndarray\n State vector of the prediction." }, { "code": "def call_script(self, script_dict, keys=None, args=None):\n if keys is None:\n keys = []\n if args is None:\n args = []\n if 'script_object' not in script_dict:\n script_dict['script_object'] = self.connection.register_script(script_dict['lua'])\n return script_dict['script_object'](keys=keys, args=args, client=self.connection)", "docstring": "Call a redis script with keys and args\n\n The first time we call a script, we register it to speed up later calls.\n We expect a dict with a ``lua`` key having the script, and the dict will be\n updated with a ``script_object`` key, with the content returned by the\n the redis-py ``register_script`` command.\n\n Parameters\n ----------\n script_dict: dict\n A dict with a ``lua`` entry containing the lua code. A new key, ``script_object``\n will be added after that.\n keys: list of str\n List of the keys that will be read/updated by the lua script\n args: list of str\n List of all the args expected by the script.\n\n Returns\n -------\n Anything that will be returned by the script" }, { "code": "def check_var_units(self, ds):\n results = []\n for variable in self.get_applicable_variables(ds):\n msgs = []\n unit_check = hasattr(ds.variables[variable], 'units')\n no_dim_check = (getattr(ds.variables[variable], 'dimensions') == tuple())\n if no_dim_check:\n continue\n if not unit_check:\n msgs.append(\"units\")\n results.append(Result(BaseCheck.HIGH, unit_check, self._var_header.format(variable), msgs))\n return results", "docstring": "Checks each applicable variable for the units attribute\n\n :param netCDF4.Dataset ds: An open netCDF dataset" }, { "code": "def modifyReject(LowLayerCompatibility_presence=0,\n HighLayerCompatibility_presence=0):\n a = TpPd(pd=0x3)\n b = MessageType(mesType=0x13)\n c = BearerCapability()\n d = Cause()\n packet = a / b / c / d\n if LowLayerCompatibility_presence is 1:\n e = LowLayerCompatibilityHdr(ieiLLC=0x7C, eightBitLLC=0x0)\n packet = packet / e\n if HighLayerCompatibility_presence is 1:\n f = HighLayerCompatibilityHdr(ieiHLC=0x7D, eightBitHLC=0x0)\n packet = packet / f\n return packet", "docstring": "MODIFY REJECT Section 9.3.15" }, { "code": "def options(self, section):\n if not self.has_section(section):\n raise NoSectionError(section) from None\n return self.__getitem__(section).options()", "docstring": "Returns list of configuration options for the named section.\n\n Args:\n section (str): name of section\n\n Returns:\n list: list of option names" }, { "code": "def build_mock_repository(conn_, file_path_list, verbose):\n for file_path in file_path_list:\n ext = _os.path.splitext(file_path)[1]\n if not _os.path.exists(file_path):\n raise ValueError('File name %s does not exist' % file_path)\n if ext == '.mof':\n conn_.compile_mof_file(file_path)\n elif ext == '.py':\n try:\n with open(file_path) as fp:\n globalparams = {'CONN': conn_, 'VERBOSE': verbose}\n exec(fp.read(), globalparams, None)\n except Exception as ex:\n exc_type, exc_value, exc_traceback = _sys.exc_info()\n tb = repr(traceback.format_exception(exc_type, exc_value,\n exc_traceback))\n raise ValueError(\n 'Exception failure of \"--mock-server\" python script %r '\n 'with conn %r Exception: %r\\nTraceback\\n%s' %\n (file_path, conn, ex, tb))\n else:\n raise ValueError('Invalid suffix %s on \"--mock-server\" '\n 'global parameter %s. Must be \"py\" or \"mof\".'\n % (ext, file_path))\n if verbose:\n conn_.display_repository()", "docstring": "Build the mock repository from the file_path list and fake connection\n instance. This allows both mof files and python files to be used to\n build the repository.\n\n If verbose is True, it displays the respository after it is build as\n mof." }, { "code": "def _addPub(self, stem, source):\n key = re.sub(\"[^A-Za-z0-9&]+\", \" \", source).strip().upper()\n self.sourceDict[key] = stem\n self.bibstemWords.setdefault(stem, set()).update(\n key.lower().split())", "docstring": "Enters stem as value for source." }, { "code": "def to_html(self):\n id, classes, kvs = self.id, self.classes, self.kvs\n id_str = 'id=\"{}\"'.format(id) if id else ''\n class_str = 'class=\"{}\"'.format(' '.join(classes)) if classes else ''\n key_str = ' '.join('{}={}'.format(k, v) for k, v in kvs.items())\n return ' '.join((id_str, class_str, key_str)).strip()", "docstring": "Returns attributes formatted as html." }, { "code": "def validate(self,\n asset,\n amount,\n portfolio,\n algo_datetime,\n algo_current_data):\n algo_date = algo_datetime.date()\n if self.current_date and self.current_date != algo_date:\n self.orders_placed = 0\n self.current_date = algo_date\n if self.orders_placed >= self.max_count:\n self.handle_violation(asset, amount, algo_datetime)\n self.orders_placed += 1", "docstring": "Fail if we've already placed self.max_count orders today." }, { "code": "def _find_reasonable_stepsize(self, position, stepsize_app=1):\n momentum = np.reshape(np.random.normal(0, 1, len(position)), position.shape)\n position_bar, momentum_bar, _ =\\\n self.simulate_dynamics(self.model, position, momentum,\n stepsize_app, self.grad_log_pdf).get_proposed_values()\n acceptance_prob = self._acceptance_prob(position, position_bar, momentum, momentum_bar)\n a = 2 * (acceptance_prob > 0.5) - 1\n condition = self._get_condition(acceptance_prob, a)\n while condition:\n stepsize_app = (2 ** a) * stepsize_app\n position_bar, momentum_bar, _ =\\\n self.simulate_dynamics(self.model, position, momentum,\n stepsize_app, self.grad_log_pdf).get_proposed_values()\n acceptance_prob = self._acceptance_prob(position, position_bar, momentum, momentum_bar)\n condition = self._get_condition(acceptance_prob, a)\n return stepsize_app", "docstring": "Method for choosing initial value of stepsize\n\n References\n -----------\n Matthew D. Hoffman, Andrew Gelman, The No-U-Turn Sampler: Adaptively\n Setting Path Lengths in Hamiltonian Monte Carlo. Journal of\n Machine Learning Research 15 (2014) 1351-1381\n Algorithm 4 : Heuristic for choosing an initial value of epsilon" }, { "code": "def map(self,\n internalize: Callable[[TExternalQubit], TInternalQubit],\n externalize: Callable[[TInternalQubit], TExternalQubit]\n ) -> 'QubitOrder':\n def func(qubits):\n unwrapped_qubits = [internalize(q) for q in qubits]\n unwrapped_result = self.order_for(unwrapped_qubits)\n return tuple(externalize(q) for q in unwrapped_result)\n return QubitOrder(func)", "docstring": "Transforms the Basis so that it applies to wrapped qubits.\n\n Args:\n externalize: Converts an internal qubit understood by the underlying\n basis into an external qubit understood by the caller.\n internalize: Converts an external qubit understood by the caller\n into an internal qubit understood by the underlying basis.\n\n Returns:\n A basis that transforms qubits understood by the caller into qubits\n understood by an underlying basis, uses that to order the qubits,\n then wraps the ordered qubits back up for the caller." }, { "code": "def apply_to_field_if_exists(effect, field_name, fn, default):\n value = getattr(effect, field_name, None)\n if value is None:\n return default\n else:\n return fn(value)", "docstring": "Apply function to specified field of effect if it is not None,\n otherwise return default." }, { "code": "def aer2ecef(az: float, el: float, srange: float,\n lat0: float, lon0: float, alt0: float,\n ell=None, deg: bool = True) -> Tuple[float, float, float]:\n x0, y0, z0 = geodetic2ecef(lat0, lon0, alt0, ell, deg=deg)\n e1, n1, u1 = aer2enu(az, el, srange, deg=deg)\n dx, dy, dz = enu2uvw(e1, n1, u1, lat0, lon0, deg=deg)\n return x0 + dx, y0 + dy, z0 + dz", "docstring": "converts target azimuth, elevation, range from observer at lat0,lon0,alt0 to ECEF coordinates.\n\n Parameters\n ----------\n az : float or numpy.ndarray of float\n azimuth to target\n el : float or numpy.ndarray of float\n elevation to target\n srange : float or numpy.ndarray of float\n slant range [meters]\n lat0 : float\n Observer geodetic latitude\n lon0 : float\n Observer geodetic longitude\n h0 : float\n observer altitude above geodetic ellipsoid (meters)\n ell : Ellipsoid, optional\n reference ellipsoid\n deg : bool, optional\n degrees input/output (False: radians in/out)\n\n Returns\n -------\n\n ECEF (Earth centered, Earth fixed) x,y,z\n\n x : float or numpy.ndarray of float\n ECEF x coordinate (meters)\n y : float or numpy.ndarray of float\n ECEF y coordinate (meters)\n z : float or numpy.ndarray of float\n ECEF z coordinate (meters)\n\n\n Notes\n ------\n if srange==NaN, z=NaN" }, { "code": "def find_subdomains(domain):\n result = set()\n response = get('https://findsubdomains.com/subdomains-of/' + domain).text\n matches = findall(r'(?s)
(.*?)
', response)\n for match in matches:\n result.add(match.replace(' ', '').replace('\\n', ''))\n return list(result)", "docstring": "Find subdomains according to the TLD." }, { "code": "def getCityUsers(self, numberOfThreads=20):\n if not self.__intervals:\n self.__logger.debug(\"Calculating best intervals\")\n self.calculateBestIntervals()\n self.__end = False\n self.__threads = set()\n comprobationURL = self.__getURL()\n self.__readAPI(comprobationURL)\n self.__launchThreads(numberOfThreads)\n self.__logger.debug(\"Launching threads\")\n for i in self.__intervals:\n self.__getPeriodUsers(i[0], i[1])\n self.__end = True\n for t in self.__threads:\n t.join()\n self.__logger.debug(\"Threads joined\")", "docstring": "Get all the users from the city.\n\n :param numberOfThreads: number of threads to run.\n :type numberOfThreads: int." }, { "code": "def start(self):\n run_by_ui = False\n if not self.current_user.algo:\n self._job = Job(self._project.id, self._software.id).save()\n user_job = User().fetch(self._job.userJob)\n self.set_credentials(user_job.publicKey, user_job.privateKey)\n else:\n self._job = Job().fetch(self.current_user.job)\n run_by_ui = True\n self._job.status = Job.RUNNING\n self._job.update()\n if not run_by_ui and self._parameters is not None:\n parameters = vars(self._parameters)\n for software_param in self._software.parameters:\n name = software_param[\"name\"]\n if name in parameters:\n value = parameters[name]\n else:\n value = software_param[\"defaultParamValue\"]\n JobParameter(self._job.id, software_param[\"id\"], value).save()", "docstring": "Connect to the Cytomine server and switch to job connection\n Incurs dataflows" }, { "code": "def all_successors(self, node, skip_reached_fixedpoint=False):\n successors = set()\n stack = [ node ]\n while stack:\n n = stack.pop()\n successors.add(n)\n stack.extend(succ for succ in self.successors(n) if\n succ not in successors and\n (not skip_reached_fixedpoint or succ not in self._reached_fixedpoint)\n )\n return successors", "docstring": "Returns all successors to the specific node.\n\n :param node: A node in the graph.\n :return: A set of nodes that are all successors to the given node.\n :rtype: set" }, { "code": "def save_to_temp(content, file_name=None):\n temp_dir = tempfile.gettempdir()\n out_file = os.path.join(temp_dir, file_name)\n file = open(out_file, 'w')\n file.write(content)\n file.close()\n return out_file", "docstring": "Save the contents into a temp file." }, { "code": "async def scp_to(self, source, destination, user='ubuntu', proxy=False,\n scp_opts=''):\n if proxy:\n raise NotImplementedError('proxy option is not implemented')\n address = self.dns_name\n destination = '%s@%s:%s' % (user, address, destination)\n await self._scp(source, destination, scp_opts)", "docstring": "Transfer files to this machine.\n\n :param str source: Local path of file(s) to transfer\n :param str destination: Remote destination of transferred files\n :param str user: Remote username\n :param bool proxy: Proxy through the Juju API server\n :param scp_opts: Additional options to the `scp` command\n :type scp_opts: str or list" }, { "code": "def transformFromNative(obj):\n if not obj.isNative:\n return obj\n obj.isNative = False\n obj.value = timedeltaToString(obj.value)\n return obj", "docstring": "Replace the datetime.timedelta in obj.value with an RFC2445 string." }, { "code": "def convert(self, targetunits):\n nunits = units.Units(targetunits)\n if nunits.isFlux:\n self.fluxunits = nunits\n else:\n self.waveunits = nunits", "docstring": "Set new user unit, for either wavelength or flux.\n\n This effectively converts the spectrum wavelength or flux\n to given unit. Note that actual data are always kept in\n internal units (Angstrom and ``photlam``), and only converted\n to user units by :meth:`getArrays` during actual computation.\n User units are stored in ``self.waveunits`` and ``self.fluxunits``.\n\n Parameters\n ----------\n targetunits : str\n New unit name, as accepted by `~pysynphot.units.Units`." }, { "code": "def calc_qv_v1(self):\n con = self.parameters.control.fastaccess\n flu = self.sequences.fluxes.fastaccess\n for i in range(2):\n if (flu.av[i] > 0.) and (flu.uv[i] > 0.):\n flu.qv[i] = (con.ekv[i]*con.skv[i] *\n flu.av[i]**(5./3.)/flu.uv[i]**(2./3.)*con.gef**.5)\n else:\n flu.qv[i] = 0.", "docstring": "Calculate the discharge of both forelands after Manning-Strickler.\n\n Required control parameters:\n |EKV|\n |SKV|\n |Gef|\n\n Required flux sequence:\n |AV|\n |UV|\n\n Calculated flux sequence:\n |lstream_fluxes.QV|\n\n Examples:\n\n For appropriate strictly positive values:\n\n >>> from hydpy.models.lstream import *\n >>> parameterstep()\n >>> ekv(2.0)\n >>> skv(50.0)\n >>> gef(0.01)\n >>> fluxes.av = 3.0\n >>> fluxes.uv = 7.0\n >>> model.calc_qv_v1()\n >>> fluxes.qv\n qv(17.053102, 17.053102)\n\n For zero or negative values of the flown through surface or\n the wetted perimeter:\n\n >>> fluxes.av = -1.0, 3.0\n >>> fluxes.uv = 7.0, 0.0\n >>> model.calc_qv_v1()\n >>> fluxes.qv\n qv(0.0, 0.0)" }, { "code": "def esxcli(host, user, pwd, cmd, protocol=None, port=None, esxi_host=None, credstore=None):\n esx_cmd = salt.utils.path.which('esxcli')\n if not esx_cmd:\n log.error('Missing dependency: The salt.utils.vmware.esxcli function requires ESXCLI.')\n return False\n if port is None:\n port = 443\n if protocol is None:\n protocol = 'https'\n if credstore:\n esx_cmd += ' --credstore \\'{0}\\''.format(credstore)\n if not esxi_host:\n esx_cmd += ' -s {0} -u {1} -p \\'{2}\\' ' \\\n '--protocol={3} --portnumber={4} {5}'.format(host,\n user,\n pwd,\n protocol,\n port,\n cmd)\n else:\n esx_cmd += ' -s {0} -h {1} -u {2} -p \\'{3}\\' ' \\\n '--protocol={4} --portnumber={5} {6}'.format(host,\n esxi_host,\n user,\n pwd,\n protocol,\n port,\n cmd)\n ret = salt.modules.cmdmod.run_all(esx_cmd, output_loglevel='quiet')\n return ret", "docstring": "Shell out and call the specified esxcli commmand, parse the result\n and return something sane.\n\n :param host: ESXi or vCenter host to connect to\n :param user: User to connect as, usually root\n :param pwd: Password to connect with\n :param port: TCP port\n :param cmd: esxcli command and arguments\n :param esxi_host: If `host` is a vCenter host, then esxi_host is the\n ESXi machine on which to execute this command\n :param credstore: Optional path to the credential store file\n\n :return: Dictionary" }, { "code": "def get_bases(definition_dict, loader):\n bases = definition_dict.get('bases', ())\n if bases:\n bases = (loader.get_comp_dict(required_version=SPEC_VERSION_TUPLE[0],\n **b)\n for b in bases)\n return SimpleChainmap(definition_dict, *bases)\n else:\n return definition_dict", "docstring": "Collect dependencies." }, { "code": "def _string_from_ip_int(self, ip_int=None):\n if not ip_int and ip_int != 0:\n ip_int = int(self._ip)\n if ip_int > self._ALL_ONES:\n raise ValueError('IPv6 address is too large')\n hex_str = '%032x' % ip_int\n hextets = []\n for x in range(0, 32, 4):\n hextets.append('%x' % int(hex_str[x:x+4], 16))\n hextets = self._compress_hextets(hextets)\n return ':'.join(hextets)", "docstring": "Turns a 128-bit integer into hexadecimal notation.\n\n Args:\n ip_int: An integer, the IP address.\n\n Returns:\n A string, the hexadecimal representation of the address.\n\n Raises:\n ValueError: The address is bigger than 128 bits of all ones." }, { "code": "def _check_configure_args(configure_args: Dict[str, Any]) -> Dict[str, Any]:\n if not configure_args.get('ssid')\\\n or not isinstance(configure_args['ssid'], str):\n raise ConfigureArgsError(\"SSID must be specified\")\n if not configure_args.get('hidden'):\n configure_args['hidden'] = False\n elif not isinstance(configure_args['hidden'], bool):\n raise ConfigureArgsError('If specified, hidden must be a bool')\n configure_args['securityType'] = _deduce_security(configure_args)\n if configure_args['securityType'] == nmcli.SECURITY_TYPES.WPA_PSK:\n if not configure_args.get('psk'):\n raise ConfigureArgsError(\n 'If securityType is wpa-psk, psk must be specified')\n return configure_args\n if configure_args['securityType'] == nmcli.SECURITY_TYPES.WPA_EAP:\n if not configure_args.get('eapConfig'):\n raise ConfigureArgsError(\n 'If securityType is wpa-eap, eapConfig must be specified')\n configure_args['eapConfig']\\\n = _eap_check_config(configure_args['eapConfig'])\n return configure_args\n return configure_args", "docstring": "Check the arguments passed to configure.\n\n Raises an exception on failure. On success, returns a dict of\n configure_args with any necessary mutations." }, { "code": "def random_jpath(depth = 3):\n chunks = []\n while depth > 0:\n length = random.randint(5, 15)\n ident = ''.join(random.choice(string.ascii_uppercase + string.ascii_lowercase) for _ in range(length))\n if random.choice((True, False)):\n index = random.randint(0, 10)\n ident = \"{:s}[{:d}]\".format(ident, index)\n chunks.append(ident)\n depth -= 1\n return \".\".join(chunks)", "docstring": "Generate random JPath with given node depth." }, { "code": "def _process_cell(i, state, finite=False):\n op_1 = state[i - 1]\n op_2 = state[i]\n if i == len(state) - 1:\n if finite:\n op_3 = state[0]\n else:\n op_3 = 0\n else:\n op_3 = state[i + 1]\n result = 0\n for i, val in enumerate([op_3, op_2, op_1]):\n if val:\n result += 2**i\n return result", "docstring": "Process 3 cells and return a value from 0 to 7." }, { "code": "def check_is_an_array(var, allow_none=False):\n if not is_an_array(var, allow_none=allow_none):\n raise TypeError(\"var must be a NumPy array, however type(var) is {}\"\n .format(type(var)))", "docstring": "Calls is_an_array and raises a type error if the check fails." }, { "code": "def wait_for(func):\n def wrapped(*args, **kwargs):\n timeout = kwargs.pop('timeout', 15)\n start = time()\n result = None\n while time() - start < timeout:\n result = func(*args, **kwargs)\n if result:\n break\n sleep(0.2)\n return result\n return wrapped", "docstring": "A decorator to invoke a function periodically until it returns a truthy\n value." }, { "code": "def _store_token(self, token, remember=False):\n if token and remember:\n try:\n keyring.set_password('github', 'token', token)\n except Exception:\n if self._show_msgbox:\n QMessageBox.warning(self.parent_widget,\n _('Failed to store token'),\n _('It was not possible to securely '\n 'save your token. You will be '\n 'prompted for your Github token '\n 'next time you want to report '\n 'an issue.'))\n remember = False\n CONF.set('main', 'report_error/remember_token', remember)", "docstring": "Store token for future use." }, { "code": "def set_last_access(self, tag):\n import time\n self.buildstate.access.last = '{}-{}'.format(tag, time.time())\n self.buildstate.commit()", "docstring": "Mark the time that this bundle was last accessed" }, { "code": "def links(self):\n links = super(OffsetLimitPaginatedList, self).links\n if self._page.offset + self._page.limit < self.count:\n links[\"next\"] = Link.for_(\n self._operation,\n self._ns,\n qs=self._page.next_page.to_items(),\n **self._context\n )\n if self.offset > 0:\n links[\"prev\"] = Link.for_(\n self._operation,\n self._ns,\n qs=self._page.prev_page.to_items(),\n **self._context\n )\n return links", "docstring": "Include previous and next links." }, { "code": "def get_module_uuid(plpy, moduleid):\n plan = plpy.prepare(\"SELECT uuid FROM modules WHERE moduleid = $1;\",\n ('text',))\n result = plpy.execute(plan, (moduleid,), 1)\n if result:\n return result[0]['uuid']", "docstring": "Retrieve page uuid from legacy moduleid." }, { "code": "def write_to(self, group):\n items_group = group[self.name]\n nitems = items_group.shape[0]\n items_group.resize((nitems + len(self.data),))\n items_group[nitems:] = self.data", "docstring": "Write stored items to the given HDF5 group.\n\n We assume that self.create() has been called." }, { "code": "def _packet_loop(self):\n while self._is_running:\n if self.inbox.empty() \\\n and not self.new_packet.wait(self._packet_timeout):\n continue\n ip, port, packet = self.inbox.get()\n if self.inbox.empty():\n self.new_packet.clear()\n self.debug(u\"{}\".format(packet))\n if packet.header.message_type == MsgType.CONFIG:\n self._do_config_packet(packet, ip, port)\n elif packet.header.message_type == MsgType.UPDATE:\n self._do_update_packet(packet)", "docstring": "Packet processing loop\n\n :rtype: None" }, { "code": "def platform_detect():\n pi = pi_version()\n if pi is not None:\n return RASPBERRY_PI\n plat = platform.platform()\n if plat.lower().find('armv7l-with-debian') > -1:\n return BEAGLEBONE_BLACK\n elif plat.lower().find('armv7l-with-ubuntu') > -1:\n return BEAGLEBONE_BLACK\n elif plat.lower().find('armv7l-with-glibc2.4') > -1:\n return BEAGLEBONE_BLACK\n elif plat.lower().find('armv7l-with-arch') > -1:\n return BEAGLEBONE_BLACK\n return UNKNOWN", "docstring": "Detect if running on the Raspberry Pi or Beaglebone Black and return the\n platform type. Will return RASPBERRY_PI, BEAGLEBONE_BLACK, or UNKNOWN." }, { "code": "def send(self, data):\n if self._device:\n if isinstance(data, str):\n data = str.encode(data)\n if sys.version_info < (3,):\n if isinstance(data, unicode):\n data = bytes(data)\n self._device.write(data)", "docstring": "Sends data to the `AlarmDecoder`_ device.\n\n :param data: data to send\n :type data: string" }, { "code": "def url_unquote(string, charset='utf-8', errors='replace', unsafe=''):\n rv = _unquote_to_bytes(string, unsafe)\n if charset is not None:\n rv = rv.decode(charset, errors)\n return rv", "docstring": "URL decode a single string with a given encoding. If the charset\n is set to `None` no unicode decoding is performed and raw bytes\n are returned.\n\n :param s: the string to unquote.\n :param charset: the charset of the query string. If set to `None`\n no unicode decoding will take place.\n :param errors: the error handling for the charset decoding." }, { "code": "def push(self, el):\n count = next(self.counter)\n heapq.heappush(self._queue, (el, count))", "docstring": "Put a new element in the queue." }, { "code": "def autoencoder_residual_text():\n hparams = autoencoder_residual()\n hparams.bottleneck_bits = 32\n hparams.batch_size = 1024\n hparams.hidden_size = 64\n hparams.max_hidden_size = 512\n hparams.bottleneck_noise = 0.0\n hparams.bottom = {\n \"inputs\": modalities.identity_bottom,\n \"targets\": modalities.identity_bottom,\n }\n hparams.top = {\n \"targets\": modalities.identity_top,\n }\n hparams.autoregressive_mode = \"none\"\n hparams.sample_width = 1\n return hparams", "docstring": "Residual autoencoder model for text." }, { "code": "def isSet(self, param):\n param = self._resolveParam(param)\n return param in self._paramMap", "docstring": "Checks whether a param is explicitly set by user." }, { "code": "def get_hypo_location(self, mesh_spacing, hypo_loc=None):\n mesh = self.mesh\n centroid = mesh.get_middle_point()\n if hypo_loc is None:\n return centroid\n total_len_y = (len(mesh.depths) - 1) * mesh_spacing\n y_distance = hypo_loc[1] * total_len_y\n y_node = int(numpy.round(y_distance / mesh_spacing))\n total_len_x = (len(mesh.lons[y_node]) - 1) * mesh_spacing\n x_distance = hypo_loc[0] * total_len_x\n x_node = int(numpy.round(x_distance / mesh_spacing))\n hypocentre = Point(mesh.lons[y_node][x_node],\n mesh.lats[y_node][x_node],\n mesh.depths[y_node][x_node])\n return hypocentre", "docstring": "The method determines the location of the hypocentre within the rupture\n\n :param mesh:\n :class:`~openquake.hazardlib.geo.mesh.Mesh` of points\n :param mesh_spacing:\n The desired distance between two adjacent points in source's\n ruptures' mesh, in km. Mainly this parameter allows to balance\n the trade-off between time needed to compute the distance\n between the rupture surface and a site and the precision of that\n computation.\n :param hypo_loc:\n Hypocentre location as fraction of rupture plane, as a tuple of\n (Along Strike, Down Dip), e.g. a hypocentre located in the centroid\n of the rupture would be input as (0.5, 0.5), whereas a\n hypocentre located in a position 3/4 along the length, and 1/4 of\n the way down dip of the rupture plane would be entered as\n (0.75, 0.25).\n :returns:\n Hypocentre location as instance of\n :class:`~openquake.hazardlib.geo.point.Point`" }, { "code": "def plot_points(points, lattice=None, coords_are_cartesian=False, fold=False,\n ax=None, **kwargs):\n ax, fig, plt = get_ax3d_fig_plt(ax)\n if \"color\" not in kwargs:\n kwargs[\"color\"] = \"b\"\n if (not coords_are_cartesian or fold) and lattice is None:\n raise ValueError(\n \"coords_are_cartesian False or fold True require the lattice\")\n for p in points:\n if fold:\n p = fold_point(p, lattice,\n coords_are_cartesian=coords_are_cartesian)\n elif not coords_are_cartesian:\n p = lattice.get_cartesian_coords(p)\n ax.scatter(*p, **kwargs)\n return fig, ax", "docstring": "Adds Points to a matplotlib Axes\n\n Args:\n points: list of coordinates\n lattice: Lattice object used to convert from reciprocal to cartesian coordinates\n coords_are_cartesian: Set to True if you are providing\n coordinates in cartesian coordinates. Defaults to False.\n Requires lattice if False.\n fold: whether the points should be folded inside the first Brillouin Zone.\n Defaults to False. Requires lattice if True.\n ax: matplotlib :class:`Axes` or None if a new figure should be created.\n kwargs: kwargs passed to the matplotlib function 'scatter'. Color defaults to blue\n\n Returns:\n matplotlib figure and matplotlib ax" }, { "code": "def file_or_default(path, default, function = None):\n try:\n result = file_get_contents(path)\n if function != None: return function(result)\n return result\n except IOError as e:\n if e.errno == errno.ENOENT: return default\n raise", "docstring": "Return a default value if a file does not exist" }, { "code": "def datetime_parser(s):\n try:\n ts = arrow.get(s)\n if ts.tzinfo == arrow.get().tzinfo:\n ts = ts.replace(tzinfo='local')\n except:\n c = pdt.Calendar()\n result, what = c.parse(s)\n ts = None\n if what in (1, 2, 3):\n ts = datetime.datetime(*result[:6])\n ts = arrow.get(ts)\n ts = ts.replace(tzinfo='local')\n return ts\n if ts is None:\n raise ValueError(\"Cannot parse timestamp '\" + s + \"'\")\n return ts", "docstring": "Parse timestamp s in local time. First the arrow parser is used, if it fails, the parsedatetime parser is used.\n\n :param s:\n :return:" }, { "code": "def _isna_old(obj):\n if is_scalar(obj):\n return libmissing.checknull_old(obj)\n elif isinstance(obj, ABCMultiIndex):\n raise NotImplementedError(\"isna is not defined for MultiIndex\")\n elif isinstance(obj, (ABCSeries, np.ndarray, ABCIndexClass)):\n return _isna_ndarraylike_old(obj)\n elif isinstance(obj, ABCGeneric):\n return obj._constructor(obj._data.isna(func=_isna_old))\n elif isinstance(obj, list):\n return _isna_ndarraylike_old(np.asarray(obj, dtype=object))\n elif hasattr(obj, '__array__'):\n return _isna_ndarraylike_old(np.asarray(obj))\n else:\n return obj is None", "docstring": "Detect missing values. Treat None, NaN, INF, -INF as null.\n\n Parameters\n ----------\n arr: ndarray or object value\n\n Returns\n -------\n boolean ndarray or boolean" }, { "code": "def get_file(self, fid):\n url = self.get_file_url(fid)\n return self.conn.get_raw_data(url)", "docstring": "Get file from WeedFS.\n\n Returns file content. May be problematic for large files as content is\n stored in memory.\n\n Args:\n **fid**: File identifier ,\n\n Returns:\n Content of the file with provided fid or None if file doesn't\n exist on the server\n\n .. versionadded:: 0.3.1" }, { "code": "def make_tag(cls, tag_name):\n\t\tif cls.cm:\n\t\t\treturn cls.cm.make_tag(tag_name)\n\t\treturn Tag(tag_name.strip())", "docstring": "Make a Tag object from a tag name. Registers it with the content manager\n\t\tif possible." }, { "code": "def _starts_with(field, filter_value):\n valid = False\n if field.startswith(filter_value):\n valid = True\n return valid", "docstring": "Validate field starts with provided value.\n\n Args:\n filter_value (string): A string or list of values.\n\n Returns:\n (boolean): Results of validation" }, { "code": "def asmono(samples:np.ndarray, channel:Union[int, str]=0) -> np.ndarray:\n if numchannels(samples) == 1:\n if isinstance(samples[0], float):\n return samples\n elif isinstance(samples[0], np.dnarray):\n return np.reshape(samples, (len(samples),))\n else:\n raise TypeError(\"Samples should be numeric, found: %s\"\n % str(type(samples[0])))\n if isinstance(channel, int):\n return samples[:, channel]\n elif channel == 'mix':\n return _mix(samples, scale_by_numchannels=True)\n else:\n raise ValueError(\"channel has to be an integer indicating a channel,\"\n \" or 'mix' to mix down all channels\")", "docstring": "convert samples to mono if they are not mono already.\n\n The returned array will always have the shape (numframes,)\n\n channel: the channel number to use, or 'mix' to mix-down\n all channels" }, { "code": "def create_indices(catalog_slug):\n mapping = {\n \"mappings\": {\n \"layer\": {\n \"properties\": {\n \"layer_geoshape\": {\n \"type\": \"geo_shape\",\n \"tree\": \"quadtree\",\n \"precision\": REGISTRY_MAPPING_PRECISION\n }\n }\n }\n }\n }\n ESHypermap.es.indices.create(catalog_slug, ignore=[400, 404], body=mapping)", "docstring": "Create ES core indices" }, { "code": "def make_connection(self):\n \"Make a fresh connection.\"\n connection = self.connection_class(**self.connection_kwargs)\n self._connections.append(connection)\n return connection", "docstring": "Make a fresh connection." }, { "code": "def points_to_spline_entity(points, smooth=None, count=None):\n from scipy.interpolate import splprep\n if count is None:\n count = len(points)\n if smooth is None:\n smooth = 0.002\n points = np.asanyarray(points, dtype=np.float64)\n closed = np.linalg.norm(points[0] - points[-1]) < tol.merge\n knots, control, degree = splprep(points.T, s=smooth)[0]\n control = np.transpose(control)\n index = np.arange(len(control))\n if closed:\n control[0] = control[[0, -1]].mean(axis=0)\n control = control[:-1]\n index[-1] = index[0]\n entity = entities.BSpline(points=index,\n knots=knots,\n closed=closed)\n return entity, control", "docstring": "Create a spline entity from a curve in space\n\n Parameters\n -----------\n points: (n, dimension) float, points in space\n smooth: float, smoothing amount\n count: int, number of samples in result\n\n Returns\n ---------\n entity: entities.BSpline object with points indexed at zero\n control: (m, dimension) float, new vertices for entity" }, { "code": "def process(obj):\n merged = merge(obj)\n if obj.get('full'):\n print 'Saving: {} ({:.2f}kB)'.format(obj['full'], len(merged)/1024.0)\n _save(obj['full'], merged)\n else:\n print 'Full merged size: {:.2f}kB'.format(len(merged)/1024.0)\n if obj.get('jsmin'):\n jsMin(merged, obj['jsmin'])\n if obj.get('cssmin'):\n cssMin(merged, obj['cssmin'])", "docstring": "Process each block of the merger object." }, { "code": "def isreference(a):\n return False\n return id(a) != id(copy.copy(a))\n check = ('__dict__', '__slots__')\n for attr in check:\n try:\n getattr(a, attr)\n except (SystemExit, KeyboardInterrupt):\n raise\n except:\n pass\n else:\n return True\n return False", "docstring": "Tell whether a variable is an object reference.\n\n Due to garbage collection, some objects happen to get the id of a distinct variable.\n As a consequence, linking is not ready yet and `isreference` returns ``False``." }, { "code": "def STRUCT_DECL(self, cursor, num=None):\n return self._record_decl(cursor, typedesc.Structure, num)", "docstring": "Handles Structure declaration.\n Its a wrapper to _record_decl." }, { "code": "def pca_overview(adata, **params):\n show = params['show'] if 'show' in params else None\n if 'show' in params: del params['show']\n scatterplots.pca(adata, **params, show=False)\n pca_loadings(adata, show=False)\n pca_variance_ratio(adata, show=show)", "docstring": "\\\n Plot PCA results.\n\n The parameters are the ones of the scatter plot. Call pca_ranking separately\n if you want to change the default settings.\n\n Parameters\n ----------\n adata : :class:`~anndata.AnnData`\n Annotated data matrix.\n color : string or list of strings, optional (default: `None`)\n Keys for observation/cell annotation either as list `[\"ann1\", \"ann2\"]` or\n string `\"ann1,ann2,...\"`.\n use_raw : `bool`, optional (default: `True`)\n Use `raw` attribute of `adata` if present.\n {scatter_bulk}\n show : bool, optional (default: `None`)\n Show the plot, do not return axis.\n save : `bool` or `str`, optional (default: `None`)\n If `True` or a `str`, save the figure. A string is appended to the\n default filename. Infer the filetype if ending on {{'.pdf', '.png', '.svg'}}." }, { "code": "def make_channel(name, samples, data=None, verbose=False):\n if verbose:\n llog = log['make_channel']\n llog.info(\"creating channel {0}\".format(name))\n chan = Channel('channel_{0}'.format(name))\n chan.SetStatErrorConfig(0.05, \"Poisson\")\n if data is not None:\n if verbose:\n llog.info(\"setting data\")\n chan.SetData(data)\n for sample in samples:\n if verbose:\n llog.info(\"adding sample {0}\".format(sample.GetName()))\n chan.AddSample(sample)\n return chan", "docstring": "Create a Channel from a list of Samples" }, { "code": "def disqualified(self, num, natural=True, **kwargs):\n search_type = 'natural' if natural else 'corporate'\n baseuri = (self._BASE_URI +\n 'disqualified-officers/{}/{}'.format(search_type, num))\n res = self.session.get(baseuri, params=kwargs)\n self.handle_http_error(res)\n return res", "docstring": "Search for disqualified officers by officer ID.\n\n Searches for natural disqualifications by default. Specify\n natural=False to search for corporate disqualifications.\n\n Args:\n num (str): Company number to search on.\n natural (Optional[bool]): Natural or corporate search\n kwargs (dict): additional keywords passed into\n requests.session.get *params* keyword." }, { "code": "def get(self, item):\n resource = super(CloudDatabaseManager, self).get(item)\n resource.volume = CloudDatabaseVolume(resource, resource.volume)\n return resource", "docstring": "This additional code is necessary to properly return the 'volume'\n attribute of the instance as a CloudDatabaseVolume object instead of\n a raw dict." }, { "code": "def visit_class(rec, cls, op):\n if isinstance(rec, MutableMapping):\n if \"class\" in rec and rec.get(\"class\") in cls:\n op(rec)\n for d in rec:\n visit_class(rec[d], cls, op)\n if isinstance(rec, MutableSequence):\n for d in rec:\n visit_class(d, cls, op)", "docstring": "Apply a function to with \"class\" in cls." }, { "code": "def bar(x, y, **kwargs):\n kwargs['x'] = x\n kwargs['y'] = y\n return _draw_mark(Bars, **kwargs)", "docstring": "Draws a bar chart in the current context figure.\n\n Parameters\n ----------\n\n x: numpy.ndarray, 1d\n The x-coordinates of the data points.\n y: numpy.ndarray, 1d\n The y-coordinates of the data pints.\n options: dict (default: {})\n Options for the scales to be created. If a scale labeled 'x' is\n required for that mark, options['x'] contains optional keyword\n arguments for the constructor of the corresponding scale type.\n axes_options: dict (default: {})\n Options for the axes to be created. If an axis labeled 'x' is required\n for that mark, axes_options['x'] contains optional keyword arguments\n for the constructor of the corresponding axis type." }, { "code": "def fix_return_value(v, method_name, method=None, checker=None):\n method_name = (method_name or method.__func__.__name__).replace(\"check_\",\"\")\n if v is None or not isinstance(v, Result):\n v = Result(value=v, name=method_name)\n v.name = v.name or method_name\n v.checker = checker\n v.check_method = method\n return v", "docstring": "Transforms scalar return values into Result." }, { "code": "def add_firmware_manifest(self, name, datafile, key_table_file=None, **kwargs):\n kwargs.update({\n 'name': name,\n 'url': datafile,\n })\n if key_table_file is not None:\n kwargs.update({'key_table_url': key_table_file})\n firmware_manifest = FirmwareManifest._create_request_map(kwargs)\n api = self._get_api(update_service.DefaultApi)\n return FirmwareManifest(\n api.firmware_manifest_create(**firmware_manifest)\n )", "docstring": "Add a new manifest reference.\n\n :param str name: Manifest file short name (Required)\n :param str datafile: The file object or path to the manifest file (Required)\n :param str key_table_file: The file object or path to the key_table file (Optional)\n :param str description: Manifest file description\n :return: the newly created manifest file object\n :rtype: FirmwareManifest" }, { "code": "def add_item(self, item):\n self.items.append(item)\n self.last_updated = datetime.datetime.now()", "docstring": "Append item to the list.\n\n :attr:`last_updated` will be set to :py:meth:`datetime.datetime.now`.\n\n :param item:\n Something to append to :attr:`items`." }, { "code": "def get_clients_per_page(self, per_page=1000, page=1, params=None):\n return self._get_resource_per_page(resource=CLIENTS, per_page=per_page, page=page, params=params)", "docstring": "Get clients per page\n\n :param per_page: How many objects per page. Default: 1000\n :param page: Which page. Default: 1\n :param params: Search parameters. Default: {}\n :return: list" }, { "code": "def is_any_clicked(self):\n for key in range(len(self.current_state.key_states)):\n if self.is_clicked(key):\n return True\n return False", "docstring": "Is any button clicked?" }, { "code": "def add_attribute_listener(self, attr_name, *args, **kwargs):\n attr_name = attr_name.upper()\n return super(Parameters, self).add_attribute_listener(attr_name, *args, **kwargs)", "docstring": "Add a listener callback on a particular parameter.\n\n The callback can be removed using :py:func:`remove_attribute_listener`.\n\n .. note::\n\n The :py:func:`on_attribute` decorator performs the same operation as this method, but with\n a more elegant syntax. Use ``add_attribute_listener`` only if you will need to remove\n the observer.\n\n The callback function is invoked only when the parameter changes.\n\n The callback arguments are:\n\n * ``self`` - the associated :py:class:`Parameters`.\n * ``attr_name`` - the parameter name. This can be used to infer which parameter has triggered\n if the same callback is used for watching multiple parameters.\n * ``msg`` - the new parameter value (so you don't need to re-query the vehicle object).\n\n The example below shows how to get callbacks for the ``THR_MIN`` parameter:\n\n .. code:: python\n\n #Callback function for the THR_MIN parameter\n def thr_min_callback(self, attr_name, value):\n print \" PARAMETER CALLBACK: %s changed to: %s\" % (attr_name, value)\n\n #Add observer for the vehicle's THR_MIN parameter\n vehicle.parameters.add_attribute_listener('THR_MIN', thr_min_callback)\n\n See :ref:`vehicle_state_observing_parameters` for more information.\n\n :param String attr_name: The name of the parameter to watch (or '*' to watch all parameters).\n :param args: The callback to invoke when a change in the parameter is detected." }, { "code": "def decamelise(text):\n s = re.sub('(.)([A-Z][a-z]+)', r'\\1_\\2', text)\n return re.sub('([a-z0-9])([A-Z])', r'\\1_\\2', s).lower()", "docstring": "Convert CamelCase to lower_and_underscore." }, { "code": "def getpeercert(self, binary_form=False):\n try:\n peer_cert = _X509(SSL_get_peer_certificate(self._ssl.value))\n except openssl_error():\n return\n if binary_form:\n return i2d_X509(peer_cert.value)\n if self._cert_reqs == CERT_NONE:\n return {}\n return decode_cert(peer_cert)", "docstring": "Retrieve the peer's certificate\n\n When binary form is requested, the peer's DER-encoded certficate is\n returned if it was transmitted during the handshake.\n\n When binary form is not requested, and the peer's certificate has been\n validated, then a certificate dictionary is returned. If the certificate\n was not validated, an empty dictionary is returned.\n\n In all cases, None is returned if no certificate was received from the\n peer." }, { "code": "def copy_doc(klass, fnname):\n base_meth, base_func = __get_meth_func(klass.__base__, fnname)\n meth, func = __get_meth_func(klass, fnname)\n func.__doc__ = base_func.__doc__", "docstring": "Copies documentation string of a method from the super class into the\n rewritten method of the given class" }, { "code": "def print_timer(self, timer_name, **kwargs):\n if hasattr(self, timer_name):\n _delete_timer = kwargs.get(\"delete\", False)\n print(\"|-------- {} [Time Log Calculation]-----------------|\".format(\\\n timer_name))\n print(\"StartDiff\\tLastNodeDiff\\tNodeName\")\n time_log = getattr(self, timer_name)\n start_time = time_log[0]['time']\n previous_time = start_time\n for entry in time_log:\n time_diff = (entry['time'] - previous_time) *1000\n time_from_start = (entry['time'] - start_time) * 1000\n previous_time = entry['time']\n print(\"{:.1f}\\t\\t{:.1f}\\t\\t{}\".format(time_from_start,\n time_diff,\n entry['node']))\n print(\"|--------------------------------------------------------|\")\n if _delete_timer:\n self.delete_timer(timer_name)", "docstring": "prints the timer to the terminal\n\n keyword args:\n delete -> True/False -deletes the timer after printing" }, { "code": "def newText(content):\n ret = libxml2mod.xmlNewText(content)\n if ret is None:raise treeError('xmlNewText() failed')\n return xmlNode(_obj=ret)", "docstring": "Creation of a new text node." }, { "code": "def activity(self, *args, **kwargs):\n _activities = self.activities(*args, **kwargs)\n if len(_activities) == 0:\n raise NotFoundError(\"No activity fits criteria\")\n if len(_activities) != 1:\n raise MultipleFoundError(\"Multiple activities fit criteria\")\n return _activities[0]", "docstring": "Search for a single activity.\n\n If additional `keyword=value` arguments are provided, these are added to the request parameters. Please\n refer to the documentation of the KE-chain API for additional query parameters.\n\n :param pk: id (primary key) of the activity to retrieve\n :type pk: basestring or None\n :param name: filter the activities by name\n :type name: basestring or None\n :param scope: filter by scope id\n :type scope: basestring or None\n :return: a single :class:`models.Activity`\n :raises NotFoundError: When no `Activity` is found\n :raises MultipleFoundError: When more than a single `Activity` is found" }, { "code": "def get_coiledcoil_region(self, cc_number=0, cutoff=7.0, min_kihs=2):\n g = self.filter_graph(self.graph, cutoff=cutoff, min_kihs=min_kihs)\n ccs = sorted(networkx.connected_component_subgraphs(g, copy=True),\n key=lambda x: len(x.nodes()), reverse=True)\n cc = ccs[cc_number]\n helices = [x for x in g.nodes() if x.number in cc.nodes()]\n assigned_regions = self.get_assigned_regions(helices=helices, include_alt_states=False, complementary_only=True)\n coiledcoil_monomers = [h.get_slice_from_res_id(*assigned_regions[h.number]) for h in helices]\n return Assembly(coiledcoil_monomers)", "docstring": "Assembly containing only assigned regions (i.e. regions with contiguous KnobsIntoHoles." }, { "code": "def generate_thumbnail_download_link_vimeo(video_id_from_shortcode):\n\tvideo_metadata = urlopen(\"https://vimeo.com/api/v2/video/\" + str(video_id_from_shortcode) + \".json\").read()\n\tvideo_metadata_parsed = json.loads(video_metadata.decode('utf-8'))\n\tvideo_thumbnail_large_location = video_metadata_parsed[0]['thumbnail_large']\n\treturn video_thumbnail_large_location", "docstring": "Thumbnail URL generator for Vimeo videos." }, { "code": "def _delete_membership(self, pipeline=None):\n Set(self._key['all'], pipeline=pipeline).remove(self.id)", "docstring": "Removes the id of the object to the set of all objects of the\n same class." }, { "code": "def identity(self):\n res = self.app.get_id()\n res.update({\"start_time\": self.start_time})\n res.update({\"running_id\": self.running_id})\n return res", "docstring": "Get the daemon identity\n\n This will return an object containing some properties:\n - alignak: the Alignak instance name\n - version: the Alignak version\n - type: the daemon type\n - name: the daemon name\n\n :return: daemon identity\n :rtype: dict" }, { "code": "def close_open_fds(keep_files=[]):\n keep_fds = set()\n for file in keep_files:\n if isinstance(file, int):\n keep_fds.add(file)\n else:\n try:\n keep_fds.add(file.fileno())\n except Exception:\n pass\n for fd in os.listdir(\"/proc/self/fd\"):\n fd = int(fd)\n if fd not in keep_fds:\n try:\n os.close(fd)\n except OSError:\n pass", "docstring": "Close all open file descriptors except those in a given set.\n @param keep_files: an iterable of file descriptors or file-like objects." }, { "code": "def draw360_to_texture(self, cubetexture, **kwargs):\n assert self.camera.projection.aspect == 1. and self.camera.projection.fov_y == 90\n if not isinstance(cubetexture, TextureCube):\n raise ValueError(\"Must render to TextureCube\")\n old_rotation = self.camera.rotation\n self.camera.rotation = self.camera.rotation.to_euler(units='deg')\n for face, rotation in enumerate([[180, -90, 0], [180, 90, 0], [90, 0, 0], [-90, 0, 0], [180, 0, 0], [0, 0, 180]]):\n self.camera.rotation.xyz = rotation\n cubetexture.attach_to_fbo(face)\n self.draw(**kwargs)\n self.camera.rotation = old_rotation", "docstring": "Draw each visible mesh in the scene from the perspective of the scene's camera and lit by its light, and\n applies it to each face of cubetexture, which should be currently bound to an FBO." }, { "code": "def setConfigKey(key, value):\n\t\tconfigFile = ConfigurationManager._configFile()\n\t\treturn JsonDataManager(configFile).setKey(key, value)", "docstring": "Sets the config data value for the specified dictionary key" }, { "code": "def git_commit(targets, message, force=False, sign=False):\n root = get_root()\n target_paths = []\n for t in targets:\n target_paths.append(os.path.join(root, t))\n with chdir(root):\n result = run_command('git add{} {}'.format(' -f' if force else '', ' '.join(target_paths)))\n if result.code != 0:\n return result\n return run_command('git commit{} -m \"{}\"'.format(' -S' if sign else '', message))", "docstring": "Commit the changes for the given targets." }, { "code": "def V_(x, requires_grad=False, volatile=False):\n return create_variable(x, volatile=volatile, requires_grad=requires_grad)", "docstring": "equivalent to create_variable, which creates a pytorch tensor" }, { "code": "def delayed_redraw(self):\n with self._defer_lock:\n whence = self._defer_whence\n self._defer_whence = self._defer_whence_reset\n flag = self._defer_flag\n self._defer_flag = False\n if flag:\n self.redraw_now(whence=whence)", "docstring": "Handle delayed redrawing of the canvas." }, { "code": "def mainloop(self):\n while self.keep_going:\n with self.lock:\n if self.on_connect and not self.readable(2):\n self.on_connect()\n self.on_connect = None\n if not self.keep_going:\n break\n self.process_once()", "docstring": "Handles events and calls their handler for infinity." }, { "code": "def is_extension_supported(request, extension_alias):\n extensions = list_extensions(request)\n for extension in extensions:\n if extension['alias'] == extension_alias:\n return True\n else:\n return False", "docstring": "Check if a specified extension is supported.\n\n :param request: django request object\n :param extension_alias: neutron extension alias" }, { "code": "def __get_value(self, field_name):\r\n value = request.values.get(field_name)\r\n if value is None:\r\n if self.json_form_data is None:\r\n value = None\r\n elif field_name in self.json_form_data:\r\n value = self.json_form_data[field_name]\r\n return value", "docstring": "Get request Json value by field name" }, { "code": "def get_certificates(self):\n for certificate in self.user_data.certificates:\n certificate['datetime'] = certificate['datetime'].strip()\n return self.user_data.certificates", "docstring": "Get user's certificates." }, { "code": "def create(cls, receiver_id, user_id=None):\n event = cls(id=uuid.uuid4(), receiver_id=receiver_id, user_id=user_id)\n event.payload = event.receiver.extract_payload()\n return event", "docstring": "Create an event instance." }, { "code": "def create_masked_lm_predictions(tokens, masked_lm_prob, max_predictions_per_seq, vocab_list):\n cand_indices = []\n for (i, token) in enumerate(tokens):\n if token == \"[CLS]\" or token == \"[SEP]\":\n continue\n cand_indices.append(i)\n num_to_mask = min(max_predictions_per_seq,\n max(1, int(round(len(tokens) * masked_lm_prob))))\n shuffle(cand_indices)\n mask_indices = sorted(sample(cand_indices, num_to_mask))\n masked_token_labels = []\n for index in mask_indices:\n if random() < 0.8:\n masked_token = \"[MASK]\"\n else:\n if random() < 0.5:\n masked_token = tokens[index]\n else:\n masked_token = choice(vocab_list)\n masked_token_labels.append(tokens[index])\n tokens[index] = masked_token\n return tokens, mask_indices, masked_token_labels", "docstring": "Creates the predictions for the masked LM objective. This is mostly copied from the Google BERT repo, but\n with several refactors to clean it up and remove a lot of unnecessary variables." }, { "code": "def from_tuple(self, t):\n if len(t) > 1:\n self.id = t[0]\n self.sitting = t[1]\n else:\n self.sitting = t[0]\n self.id = None\n return self", "docstring": "Set this person from tuple\n\n :param t: Tuple representing a person (sitting[, id])\n :type t: (bool) | (bool, None | str | unicode | int)\n :rtype: Person" }, { "code": "def undisplay(self):\n self._tools.pop()\n self._justClear()\n for tool in self._tools:\n self._justDisplay(tool)", "docstring": "Undisplays the top tool.\n\n This actually forces a complete re-render." }, { "code": "def get_structure_by_material_id(self, material_id, final=True,\n conventional_unit_cell=False):\n prop = \"final_structure\" if final else \"initial_structure\"\n data = self.get_data(material_id, prop=prop)\n if conventional_unit_cell:\n data[0][prop] = SpacegroupAnalyzer(data[0][prop]). \\\n get_conventional_standard_structure()\n return data[0][prop]", "docstring": "Get a Structure corresponding to a material_id.\n\n Args:\n material_id (str): Materials Project material_id (a string,\n e.g., mp-1234).\n final (bool): Whether to get the final structure, or the initial\n (pre-relaxation) structure. Defaults to True.\n conventional_unit_cell (bool): Whether to get the standard\n conventional unit cell\n\n Returns:\n Structure object." }, { "code": "def is_predecessor_of_other(self, predecessor, others):\n return any(predecessor in self._predecessors_by_id[o] for o in others)", "docstring": "Returns whether the predecessor is a predecessor or a predecessor\n of a predecessor...of any of the others.\n\n Args:\n predecessor (str): The txn id of the predecessor.\n others (list(str)): The txn id of the successor.\n\n Returns:\n (bool)" }, { "code": "def write_strings_on_files_between_markers(filenames: list, strings: list,\n marker: str):\n r\n assert len(filenames) == len(strings)\n if len(filenames) > 0:\n for f in filenames:\n assert isinstance(f, str)\n if len(strings) > 0:\n for s in strings:\n assert isinstance(s, str)\n file_id = 0\n for f in filenames:\n write_string_on_file_between_markers(f, strings[file_id], marker)\n file_id += 1", "docstring": "r\"\"\"Write the table of contents on multiple files.\n\n :parameter filenames: the files that needs to be read or modified.\n :parameter strings: the strings that will be written on the file. Each\n string is associated with one file.\n :parameter marker: a marker that will identify the start\n and the end of the string.\n :type filenames: list\n :type string: list\n :type marker: str\n :returns: None\n :rtype: None\n :raises: an fpyutils exception or a built-in exception." }, { "code": "def TypeFactory(type_):\n if isinstance(type_, type) and issubclass(type_, Type):\n return type_\n for x in __types__:\n if x.represents(type_):\n return x.get(type_)\n raise UnknownType(type_)", "docstring": "This function creates a standard form type from a simplified form.\n\n >>> from datetime import date, datetime\n >>> from pyws.functions.args import TypeFactory\n >>> from pyws.functions.args import String, Integer, Float, Date, DateTime\n >>> TypeFactory(str) == String\n True\n >>> TypeFactory(float) == Float\n True\n >>> TypeFactory(date) == Date\n True\n >>> TypeFactory(datetime) == DateTime\n True\n\n >>> from operator import attrgetter\n >>> from pyws.functions.args import Dict\n >>> dct = TypeFactory({0: 'HelloWorldDict', 'hello': str, 'world': int})\n >>> issubclass(dct, Dict)\n True\n >>> dct.__name__\n 'HelloWorldDict'\n >>> fields = sorted(dct.fields, key=attrgetter('name'))\n >>> len(dct.fields)\n 2\n >>> fields[0].name == 'hello'\n True\n >>> fields[0].type == String\n True\n >>> fields[1].name == 'world'\n True\n >>> fields[1].type == Integer\n True\n\n >>> from pyws.functions.args import List\n >>> lst = TypeFactory([int])\n >>> issubclass(lst, List)\n True\n >>> lst.__name__\n 'IntegerList'\n >>> lst.element_type == Integer\n True" }, { "code": "def _viscounts2radiance(counts, slope, offset):\n rad = counts * slope + offset\n return rad.clip(min=0)", "docstring": "Convert VIS counts to radiance\n\n References: [VIS]\n\n Args:\n counts: Raw detector counts\n slope: Slope [W m-2 um-1 sr-1]\n offset: Offset [W m-2 um-1 sr-1]\n Returns:\n Radiance [W m-2 um-1 sr-1]" }, { "code": "def documents(cls, filter=None, **kwargs):\n documents = [cls(document) for document in cls.find(filter, **kwargs)]\n return [document for document in documents if document.document]", "docstring": "Returns a list of Documents if any document is filtered" }, { "code": "def make_input_from_plain_string(sentence_id: SentenceId, string: str) -> TranslatorInput:\n return TranslatorInput(sentence_id, tokens=list(data_io.get_tokens(string)), factors=None)", "docstring": "Returns a TranslatorInput object from a plain string.\n\n :param sentence_id: Sentence id.\n :param string: An input string.\n :return: A TranslatorInput." }, { "code": "def write_to(self, content, content_type):\n try:\n self._api.object_upload(self._bucket, self._key, content, content_type)\n except Exception as e:\n raise e", "docstring": "Writes text content to this item.\n\n Args:\n content: the text content to be written.\n content_type: the type of text content.\n Raises:\n Exception if there was an error requesting the item's content." }, { "code": "def likelihood_markov_blanket(self, beta):\n states = beta[self.z_no:self.z_no+self.data_length]\n parm = np.array([self.latent_variables.z_list[k].prior.transform(beta[k]) for k in range(self.z_no)])\n scale, shape, skewness = self._get_scale_and_shape(parm)\n return self.family.markov_blanket(self.data, self.link(states), scale, shape, skewness)", "docstring": "Creates likelihood markov blanket of the model\n\n Parameters\n ----------\n beta : np.array\n Contains untransformed starting values for latent variables\n\n Returns\n ----------\n - Negative loglikelihood" }, { "code": "def get_ips(self, interface=None, family=None, scope=None, timeout=0):\n kwargs = {}\n if interface:\n kwargs['interface'] = interface\n if family:\n kwargs['family'] = family\n if scope:\n kwargs['scope'] = scope\n ips = None\n timeout = int(os.environ.get('LXC_GETIP_TIMEOUT', timeout))\n while not ips:\n ips = _lxc.Container.get_ips(self, **kwargs)\n if timeout == 0:\n break\n timeout -= 1\n time.sleep(1)\n return ips", "docstring": "Get a tuple of IPs for the container." }, { "code": "def list_uplink_dvportgroup(dvs, service_instance=None):\n proxy_type = get_proxy_type()\n if proxy_type == 'esxdatacenter':\n datacenter = __salt__['esxdatacenter.get_details']()['datacenter']\n dc_ref = _get_proxy_target(service_instance)\n elif proxy_type == 'esxcluster':\n datacenter = __salt__['esxcluster.get_details']()['datacenter']\n dc_ref = salt.utils.vmware.get_datacenter(service_instance, datacenter)\n dvs_refs = salt.utils.vmware.get_dvss(dc_ref, dvs_names=[dvs])\n if not dvs_refs:\n raise VMwareObjectRetrievalError('DVS \\'{0}\\' was not '\n 'retrieved'.format(dvs))\n uplink_pg_ref = salt.utils.vmware.get_uplink_dvportgroup(dvs_refs[0])\n return _get_dvportgroup_dict(uplink_pg_ref)", "docstring": "Returns the uplink portgroup of a distributed virtual switch.\n\n dvs\n Name of the DVS containing the portgroup.\n\n service_instance\n Service instance (vim.ServiceInstance) of the vCenter.\n Default is None.\n\n .. code-block:: bash\n\n salt '*' vsphere.list_uplink_dvportgroup dvs=dvs_name" }, { "code": "def write(self, file, text, subvars={}, trim_leading_lf=True):\n file.write(self.substitute(text, subvars=subvars, trim_leading_lf=trim_leading_lf))", "docstring": "write to a file with variable substitution" }, { "code": "def get_attribute(self, code, default=None):\n try:\n return self.get(code=code).value\n except models.ObjectDoesNotExist:\n return default", "docstring": "Get attribute for user" }, { "code": "def simplify(self, e=None):\n if e is None:\n return self._solver.simplify()\n elif isinstance(e, (int, float, bool)):\n return e\n elif isinstance(e, claripy.ast.Base) and e.op in claripy.operations.leaf_operations_concrete:\n return e\n elif isinstance(e, SimActionObject) and e.op in claripy.operations.leaf_operations_concrete:\n return e.ast\n elif not isinstance(e, (SimActionObject, claripy.ast.Base)):\n return e\n else:\n return self._claripy_simplify(e)", "docstring": "Simplifies `e`. If `e` is None, simplifies the constraints of this\n state." }, { "code": "def get_area(self):\n return (self.p2.x-self.p1.x)*(self.p2.y-self.p1.y)", "docstring": "Calculate area of bounding box." }, { "code": "def checkQueryRange(self, start, end):\n condition = (\n (start < 0 or end > self.getLength()) or\n start > end or start == end)\n if condition:\n raise exceptions.ReferenceRangeErrorException(\n self.getId(), start, end)", "docstring": "Checks to ensure that the query range is valid within this reference.\n If not, raise ReferenceRangeErrorException." }, { "code": "def rm(ctx, dataset, kwargs):\n \"removes the dataset's folder if it exists\"\n kwargs = parse_kwargs(kwargs)\n data(dataset, **ctx.obj).rm(**kwargs)", "docstring": "removes the dataset's folder if it exists" }, { "code": "def pause(ctx):\n lancet = ctx.obj\n paused_status = lancet.config.get(\"tracker\", \"paused_status\")\n issue = get_issue(lancet)\n transition = get_transition(ctx, lancet, issue, paused_status)\n set_issue_status(lancet, issue, paused_status, transition)\n with taskstatus(\"Pausing harvest timer\") as ts:\n lancet.timer.pause()\n ts.ok(\"Harvest timer paused\")", "docstring": "Pause work on the current issue.\n\n This command puts the issue in the configured paused status and stops the\n current Harvest timer." }, { "code": "def print_tree(graph, tails, node_id_map):\n walker = graph.walk()\n next_block_num, next_parent, next_siblings = next(walker)\n prev_cliques = []\n done = False\n while not done:\n cliques = {}\n block_num = next_block_num\n try:\n while block_num == next_block_num:\n cliques[next_parent] = next_siblings\n next_block_num, next_parent, next_siblings = next(walker)\n except StopIteration:\n done = True\n print_cliques(prev_cliques, cliques, node_id_map)\n print_block_num_row(block_num, prev_cliques, cliques)\n print_splits(prev_cliques, cliques)\n print_folds(prev_cliques, cliques)\n prev_cliques = build_ordered_cliques(prev_cliques, cliques)\n print_cliques(prev_cliques, [], node_id_map)", "docstring": "Print out a tree of blocks starting from the common ancestor." }, { "code": "def get_repository(self, path):\n parts = path.split('@', 1)\n if len(parts) == 1:\n parts = (\"filesystem\", parts[0])\n repo_type, location = parts\n if repo_type == \"filesystem\":\n location = os.path.abspath(location)\n normalised_path = \"%s@%s\" % (repo_type, location)\n return self._get_repository(normalised_path)", "docstring": "Get a package repository.\n\n Args:\n path (str): Entry from the 'packages_path' config setting. This may\n simply be a path (which is managed by the 'filesystem' package\n repository plugin), or a string in the form \"type@location\",\n where 'type' identifies the repository plugin type to use.\n\n Returns:\n `PackageRepository` instance." }, { "code": "def qnh_estimate(self):\n alt_gps = self.master.field('GPS_RAW_INT', 'alt', 0) * 0.001\n pressure2 = self.master.field('SCALED_PRESSURE', 'press_abs', 0)\n ground_temp = self.get_mav_param('GND_TEMP', 21)\n temp = ground_temp + 273.15\n pressure1 = pressure2 / math.exp(math.log(1.0 - (alt_gps / (153.8462 * temp))) / 0.190259)\n return pressure1", "docstring": "estimate QNH pressure from GPS altitude and scaled pressure" }, { "code": "def post_tweet_intent_handler(request):\n tweet = request.get_slot_value(\"Tweet\")\n tweet = tweet if tweet else \"\" \n if tweet:\n user_state = twitter_cache.get_user_state(request.access_token())\n def action():\n return post_tweet(request.access_token(), tweet)\n message = \"I am ready to post the tweet, {} ,\\n Please say yes to confirm or stop to cancel .\".format(tweet)\n user_state['pending_action'] = {\"action\" : action,\n \"description\" : message} \n return r.create_response(message=message, end_session=False)\n else:\n message = \" \".join(\n [\n \"I'm sorry, I couldn't understand what you wanted to tweet .\",\n \"Please prepend the message with either post or tweet .\"\n ]\n )\n return alexa.create_response(message=message, end_session=False)", "docstring": "Use the 'intent' field in the VoiceHandler to map to the respective intent." }, { "code": "def mark_locations(h,section,locs,markspec='or',**kwargs):\n xyz = get_section_path(h,section)\n (r,theta,phi) = sequential_spherical(xyz)\n rcum = np.append(0,np.cumsum(r))\n if type(locs) is float or type(locs) is np.float64:\n locs = np.array([locs])\n if type(locs) is list:\n locs = np.array(locs)\n lengths = locs*rcum[-1]\n xyz_marks = []\n for targ_length in lengths:\n xyz_marks.append(find_coord(targ_length,xyz,rcum,theta,phi))\n xyz_marks = np.array(xyz_marks)\n line, = plt.plot(xyz_marks[:,0], xyz_marks[:,1], \\\n xyz_marks[:,2], markspec, **kwargs)\n return line", "docstring": "Marks one or more locations on along a section. Could be used to\n mark the location of a recording or electrical stimulation.\n\n Args:\n h = hocObject to interface with neuron\n section = reference to section\n locs = float between 0 and 1, or array of floats\n optional arguments specify details of marker\n\n Returns:\n line = reference to plotted markers" }, { "code": "def reset(self):\n old_value = self._value\n old_raw_str_value = self.raw_str_value\n self._value = not_set\n self.raw_str_value = not_set\n new_value = self._value\n if old_value is not_set:\n return\n if self.section:\n self.section.dispatch_event(\n self.section.hooks.item_value_changed,\n item=self,\n old_value=old_value,\n new_value=new_value,\n old_raw_str_value=old_raw_str_value,\n new_raw_str_value=self.raw_str_value,\n )", "docstring": "Resets the value of config item to its default value." }, { "code": "def yaml_dump(dict_to_dump):\n yaml.SafeDumper.add_representer(OrderedDict, _dict_representer)\n return yaml.safe_dump(dict_to_dump, default_flow_style=False)", "docstring": "Dump the dictionary as a YAML document.\n\n :param dict_to_dump: Data to be serialized as YAML\n :type dict_to_dump: dict\n :return: YAML document\n :rtype: str" }, { "code": "def links(self):\n links = Links()\n links[\"self\"] = Link.for_(\n self._operation,\n self._ns,\n qs=self._page.to_items(),\n **self._context\n )\n return links", "docstring": "Include a self link." }, { "code": "def determine_labels(target_dir: Path, label_type: str) -> Set[str]:\n logger.info(\"Finding phonemes of type %s in directory %s\", label_type, target_dir)\n label_dir = target_dir / \"label/\"\n if not label_dir.is_dir():\n raise FileNotFoundError(\n \"The directory {} does not exist.\".format(target_dir))\n phonemes = set()\n for fn in os.listdir(str(label_dir)):\n if fn.endswith(str(label_type)):\n with (label_dir / fn).open(\"r\", encoding=ENCODING) as f:\n try:\n line_phonemes = set(f.readline().split())\n except UnicodeDecodeError:\n logger.error(\"Unicode decode error on file %s\", fn)\n print(\"Unicode decode error on file {}\".format(fn))\n raise\n phonemes = phonemes.union(line_phonemes)\n return phonemes", "docstring": "Returns a set of all phonemes found in the corpus. Assumes that WAV files and\n label files are split into utterances and segregated in a directory which contains a\n \"wav\" subdirectory and \"label\" subdirectory.\n\n Arguments:\n target_dir: A `Path` to the directory where the corpus data is found\n label_type: The type of label we are creating the label set from. For example\n \"phonemes\" would only search for labels for that type." }, { "code": "def perform(self):\n if self.use_https:\n conn = client.HTTPSConnection(self.host, self.port)\n else:\n conn = client.HTTPConnection(self.host, self.port)\n conn.request(self.method, self.uri)\n response = conn.getresponse()\n conn.close()\n return bool(response.status >= 200 and response.status < 300)", "docstring": "Performs a simple HTTP request against the configured url and returns\n true if the response has a 2xx code.\n\n The url can be configured to use https via the \"https\" boolean flag\n in the config, as well as a custom HTTP method via the \"method\" key.\n\n The default is to not use https and the GET method." }, { "code": "def load(self, table: str):\n if self._check_db() is False:\n return\n if table not in self.db.tables:\n self.warning(\"The table \" + table + \" does not exists\")\n return\n try:\n self.start(\"Loading data from table \" + table)\n res = self.db[table].all()\n self.df = pd.DataFrame(list(res))\n self.end(\"Data loaded from table \" + table)\n except Exception as e:\n self.err(e, \"Can not load table \" + table)", "docstring": "Set the main dataframe from a table's data\n\n :param table: table name\n :type table: str\n\n :example: ``ds.load(\"mytable\")``" }, { "code": "def execute(self, method, **kwargs):\n payload = {\n 'id': 1,\n 'jsonrpc': '2.0',\n 'method': method,\n 'params': kwargs\n }\n credentials = base64.b64encode('{}:{}'.format(self._username, self._password).encode())\n auth_header_prefix = 'Basic ' if self._auth_header == DEFAULT_AUTH_HEADER else ''\n headers = {\n self._auth_header: auth_header_prefix + credentials.decode(),\n 'Content-Type': 'application/json',\n }\n return self._do_request(headers, payload)", "docstring": "Call remote API procedure\n\n Args:\n method: Procedure name\n kwargs: Procedure named arguments\n\n Returns:\n Procedure result\n\n Raises:\n urllib2.HTTPError: Any HTTP error (Python 2)\n urllib.error.HTTPError: Any HTTP error (Python 3)" }, { "code": "def UCRTLibraries(self):\n if self.vc_ver < 14.0:\n return []\n arch_subdir = self.pi.target_dir(x64=True)\n lib = os.path.join(self.si.UniversalCRTSdkDir, 'lib')\n ucrtver = self._ucrt_subdir\n return [os.path.join(lib, '%sucrt%s' % (ucrtver, arch_subdir))]", "docstring": "Microsoft Universal C Runtime SDK Libraries" }, { "code": "def __open_pidfile(self, write=False):\n try:\n self.pre_log.append((\"DEBUG\",\n \"Opening %s pid file: %s\" % ('existing' if\n os.path.exists(self.pid_filename)\n else 'missing', self.pid_filename)))\n if not write and os.path.exists(self.pid_filename):\n self.fpid = open(self.pid_filename, 'r+')\n else:\n self.fpid = open(self.pid_filename, 'w+')\n except Exception as exp:\n self.exit_on_error(\"Error opening pid file: %s. Error: %s. \"\n \"Check the %s:%s account permissions to write this file.\"\n % (self.pid_filename, str(exp), self.user, self.group), exit_code=3)", "docstring": "Open pid file in read or write mod\n\n :param write: boolean to open file in write mod (true = write)\n :type write: bool\n :return: None" }, { "code": "def get(self, time, interpolate='previous'):\n try:\n getter = self.getter_functions[interpolate]\n except KeyError:\n msg = (\n \"unknown value '{}' for interpolate, \"\n \"valid values are in [{}]\"\n ).format(interpolate, ', '.join(self.getter_functions))\n raise ValueError(msg)\n else:\n return getter(time)", "docstring": "Get the value of the time series, even in-between measured values." }, { "code": "def inspect_commit(self, commit):\n req = proto.InspectCommitRequest(commit=commit_from(commit))\n return self.stub.InspectCommit(req, metadata=self.metadata)", "docstring": "Returns info about a specific Commit.\n\n Params:\n * commit: A tuple, string, or Commit object representing the commit." }, { "code": "def get_progressbar(self, total, **options):\n progressbar = ColoredProgressBar(total)\n progressbar.steps_label = 'Commit'\n progressbar.elements += ['eta', 'time']\n return progressbar", "docstring": "Returns progress bar instance for a given ``total`` number of clicks\n it should do." }, { "code": "def dpu(self, hash=None, historics_id=None):\n if hash:\n return self.request.get('dpu', params=dict(hash=hash))\n if historics_id:\n return self.request.get('dpu', params=dict(historics_id=historics_id))", "docstring": "Calculate the DPU cost of consuming a stream.\n\n Uses API documented at http://dev.datasift.com/docs/api/rest-api/endpoints/dpu\n\n :param hash: target CSDL filter hash\n :type hash: str\n :returns: dict with extra response data\n :rtype: :class:`~datasift.request.DictResponse`\n :raises: :class:`~datasift.exceptions.DataSiftApiException`, :class:`requests.exceptions.HTTPError`" }, { "code": "def blog_reverse(viewname, args=None, kwargs=None, current_app='fluent_blogs', **page_kwargs):\n return mixed_reverse(viewname, args=args, kwargs=kwargs, current_app=current_app, **page_kwargs)", "docstring": "Reverse a URL to the blog, taking various configuration options into account.\n\n This is a compatibility function to allow django-fluent-blogs to operate stand-alone.\n Either the app can be hooked in the URLconf directly, or it can be added as a pagetype of *django-fluent-pages*." }, { "code": "def dict_to_op(d, index_name, doc_type, op_type='index'):\n if d is None:\n return d\n op_types = ('create', 'delete', 'index', 'update')\n if op_type not in op_types:\n msg = 'Unknown operation type \"{}\", must be one of: {}'\n raise Exception(msg.format(op_type, ', '.join(op_types)))\n if 'id' not in d:\n raise Exception('\"id\" key not found')\n operation = {\n '_op_type': op_type,\n '_index': index_name,\n '_type': doc_type,\n '_id': d.pop('id'),\n }\n operation.update(d)\n return operation", "docstring": "Create a bulk-indexing operation from the given dictionary." }, { "code": "def get_complex_attrs(self):\n return [getattr(self, attr_name) for attr_name in self._attributes if\n isinstance(getattr(self, attr_name), ComplexSchemaItem)]", "docstring": "Returns a dictionary of the complex attributes" }, { "code": "def format_sensor(self, sensor):\n current_val = sensor.current\n if self.pango_enabled:\n percentage = self.percentage(sensor.current, sensor.critical)\n if self.dynamic_color:\n color = self.colors[int(percentage)]\n return self.format_pango(color, current_val)\n return current_val", "docstring": "Format a sensor value. If pango is enabled color is per sensor." }, { "code": "def latexify(obj, **kwargs):\n if hasattr(obj, '__pk_latex__'):\n return obj.__pk_latex__(**kwargs)\n if isinstance(obj, text_type):\n from .unicode_to_latex import unicode_to_latex\n return unicode_to_latex(obj)\n if isinstance(obj, bool):\n raise ValueError('no well-defined LaTeXification of bool %r' % obj)\n if isinstance(obj, float):\n nplaces = kwargs.get('nplaces')\n if nplaces is None:\n return '$%f$' % obj\n return '$%.*f$' % (nplaces, obj)\n if isinstance(obj, int):\n return '$%d$' % obj\n if isinstance(obj, binary_type):\n if all(c in _printable_ascii for c in obj):\n return obj.decode('ascii')\n raise ValueError('no safe LaTeXification of binary string %r' % obj)\n raise ValueError('can\\'t LaTeXify %r' % obj)", "docstring": "Render an object in LaTeX appropriately." }, { "code": "def getcells(self, line):\n for boundary in self.boundaries:\n cell = line.lstrip()[boundary].strip()\n if cell:\n for cell in re.split('\\s{3,}', cell):\n yield cell\n else:\n yield None", "docstring": "Using self.boundaries, extract cells from the given line." }, { "code": "def get_vasp_kpoint_file_sym(structure):\n output = run_aconvasp_command([\"aconvasp\", \"--kpath\"], structure)\n if \"ERROR\" in output[1]:\n raise AconvaspError(output[1])\n started = False\n kpoints_string = \"\"\n for line in output[0].split(\"\\n\"):\n if started or line.find(\"END\") != -1:\n kpoints_string = kpoints_string + line + \"\\n\"\n if line.find(\"KPOINTS TO RUN\") != -1:\n started = True\n if line.find(\"END\") != -1:\n started = False\n return kpoints_string", "docstring": "get a kpoint file ready to be ran in VASP along the symmetry lines of the\n Brillouin Zone" }, { "code": "def apply_cut(self, cut):\n return MacroSubsystem(\n self.network,\n self.network_state,\n self.micro_node_indices,\n cut=cut,\n time_scale=self.time_scale,\n blackbox=self.blackbox,\n coarse_grain=self.coarse_grain)", "docstring": "Return a cut version of this |MacroSubsystem|.\n\n Args:\n cut (Cut): The cut to apply to this |MacroSubsystem|.\n\n Returns:\n MacroSubsystem: The cut version of this |MacroSubsystem|." }, { "code": "def _get_pid_file_variable(self, db):\n pid_file = None\n try:\n with closing(db.cursor()) as cursor:\n cursor.execute(\"SHOW VARIABLES LIKE 'pid_file'\")\n pid_file = cursor.fetchone()[1]\n except Exception:\n self.warning(\"Error while fetching pid_file variable of MySQL.\")\n return pid_file", "docstring": "Get the `pid_file` variable" }, { "code": "def mirror(self: BaseBoardT) -> BaseBoardT:\n board = self.transform(flip_vertical)\n board.occupied_co[WHITE], board.occupied_co[BLACK] = board.occupied_co[BLACK], board.occupied_co[WHITE]\n return board", "docstring": "Returns a mirrored copy of the board.\n\n The board is mirrored vertically and piece colors are swapped, so that\n the position is equivalent modulo color." }, { "code": "def count_characters(root, out):\n if os.path.isfile(root):\n with open(root, 'rb') as in_f:\n for line in in_f:\n for char in line:\n if char not in out:\n out[char] = 0\n out[char] = out[char] + 1\n elif os.path.isdir(root):\n for filename in os.listdir(root):\n count_characters(os.path.join(root, filename), out)", "docstring": "Count the occurrances of the different characters in the files" }, { "code": "def reload(self, encoding):\n assert os.path.exists(self.path)\n self.open(self.path, encoding=encoding,\n use_cached_encoding=False)", "docstring": "Reload the file with another encoding.\n\n :param encoding: the new encoding to use to reload the file." }, { "code": "def wgan(cls, data:DataBunch, generator:nn.Module, critic:nn.Module, switcher:Callback=None, clip:float=0.01, **learn_kwargs):\n \"Create a WGAN from `data`, `generator` and `critic`.\"\n return cls(data, generator, critic, NoopLoss(), WassersteinLoss(), switcher=switcher, clip=clip, **learn_kwargs)", "docstring": "Create a WGAN from `data`, `generator` and `critic`." }, { "code": "def currency_format(cents):\n try:\n cents = int(cents)\n except ValueError:\n return cents\n negative = (cents < 0)\n if negative:\n cents = -1 * cents\n if cents < 100:\n dollars = 0\n else:\n dollars = cents / 100\n cents = cents % 100\n centstr = str(cents)\n if len(centstr) < 2:\n centstr = '0' + centstr\n if negative:\n return \"- $%s.%s\" % (intcomma(dollars), centstr)\n return \"$%s.%s\" % (intcomma(dollars), centstr)", "docstring": "Format currency with symbol and decimal points.\n\n >> currency_format(-600)\n - $6.00\n\n TODO: Add localization support." }, { "code": "def shell(args):\n \" A helper command to be used for shell integration \"\n print\n print \"\n print \"\n print \"export MAKESITE_HOME=%s\" % args.path\n print \"source %s\" % op.join(settings.BASEDIR, 'shell.sh')\n print", "docstring": "A helper command to be used for shell integration" }, { "code": "def add_tags(self, tags):\n if not isinstance(tags, list):\n tags = [tags]\n self._bugsy.request('bug/comment/%s/tags' % self._comment['id'],\n method='PUT', json={\"add\": tags})", "docstring": "Add tags to the comments" }, { "code": "def _twoByteStringToNum(bytestring, numberOfDecimals=0, signed=False):\n _checkString(bytestring, minlength=2, maxlength=2, description='bytestring')\n _checkInt(numberOfDecimals, minvalue=0, description='number of decimals')\n _checkBool(signed, description='signed parameter')\n formatcode = '>'\n if signed:\n formatcode += 'h'\n else:\n formatcode += 'H'\n fullregister = _unpack(formatcode, bytestring)\n if numberOfDecimals == 0:\n return fullregister\n divisor = 10 ** numberOfDecimals\n return fullregister / float(divisor)", "docstring": "Convert a two-byte string to a numerical value, possibly scaling it.\n\n Args:\n * bytestring (str): A string of length 2.\n * numberOfDecimals (int): The number of decimals. Defaults to 0.\n * signed (bol): Whether large positive values should be interpreted as negative values.\n\n Returns:\n The numerical value (int or float) calculated from the ``bytestring``.\n\n Raises:\n TypeError, ValueError\n\n Use the parameter ``signed=True`` if converting a bytestring that can hold\n negative values. Then upper range data will be automatically converted into\n negative return values (two's complement).\n\n Use ``numberOfDecimals=1`` to divide the received data by 10 before returning the value.\n Similarly ``numberOfDecimals=2`` will divide the received data by 100 before returning the value.\n\n The byte order is big-endian, meaning that the most significant byte is sent first.\n\n For example:\n A string ``\\\\x03\\\\x02`` (which has the length 2) corresponds to 0302 (hex) = 770 (dec). If\n ``numberOfDecimals = 1``, then this is converted to 77.0 (float)." }, { "code": "def get_privileges(self):\n url = self.url('GET_USER_PRIVILEGES')\n return self.dispatch('GET', url, auth=self.auth)", "docstring": "Get privledges for this user." }, { "code": "def get_header(self, name, default=None):\n return self._handler.headers.get(name, default)", "docstring": "Retrieves the value of a header" }, { "code": "def random_choice(self, actions=None, random_state=None):\n random_state = check_random_state(random_state)\n if actions is not None:\n n = len(actions)\n else:\n n = self.num_actions\n if n == 1:\n idx = 0\n else:\n idx = random_state.randint(n)\n if actions is not None:\n return actions[idx]\n else:\n return idx", "docstring": "Return a pure action chosen randomly from `actions`.\n\n Parameters\n ----------\n actions : array_like(int), optional(default=None)\n An array of integers representing pure actions.\n\n random_state : int or np.random.RandomState, optional\n Random seed (integer) or np.random.RandomState instance to\n set the initial state of the random number generator for\n reproducibility. If None, a randomly initialized RandomState\n is used.\n\n Returns\n -------\n scalar(int)\n If `actions` is given, returns an integer representing a\n pure action chosen randomly from `actions`; if not, an\n action is chosen randomly from the player's all actions." }, { "code": "def _subprocess_method(self, command):\n p = subprocess.Popen([self._ipmitool_path] + self.args + command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n self.output, self.error = p.communicate()\n self.status = p.returncode", "docstring": "Use the subprocess module to execute ipmitool commands\n and and set status" }, { "code": "def _call(self, x, out=None):\n if out is None:\n return self.prod_op(x)[0]\n else:\n wrapped_out = self.prod_op.range.element([out], cast=False)\n pspace_result = self.prod_op(x, out=wrapped_out)\n return pspace_result[0]", "docstring": "Apply operators to ``x`` and sum." }, { "code": "def ValidateStopTimesForTrip(self, problems, trip, stop_times):\n prev_departure_secs = -1\n consecutive_stop_times_with_potentially_same_time = 0\n consecutive_stop_times_with_fully_specified_same_time = 0\n def CheckSameTimeCount():\n if (prev_departure_secs != -1 and\n consecutive_stop_times_with_fully_specified_same_time > 5):\n problems.TooManyConsecutiveStopTimesWithSameTime(trip.trip_id,\n consecutive_stop_times_with_fully_specified_same_time,\n prev_departure_secs)\n for index, st in enumerate(stop_times):\n if st.arrival_secs is None or st.departure_secs is None:\n consecutive_stop_times_with_potentially_same_time += 1\n continue\n if (prev_departure_secs == st.arrival_secs and\n st.arrival_secs == st.departure_secs):\n consecutive_stop_times_with_potentially_same_time += 1\n consecutive_stop_times_with_fully_specified_same_time = (\n consecutive_stop_times_with_potentially_same_time)\n else:\n CheckSameTimeCount()\n consecutive_stop_times_with_potentially_same_time = 1\n consecutive_stop_times_with_fully_specified_same_time = 1\n prev_departure_secs = st.departure_secs\n CheckSameTimeCount()", "docstring": "Checks for the stop times of a trip.\n\n Ensure that a trip does not have too many consecutive stop times with the\n same departure/arrival time." }, { "code": "def get_raw_data(self, mac, response_format='json'):\n data = {\n self._FORMAT_F: response_format,\n self._SEARCH_F: mac\n }\n response = self.__decode_str(self.__call_api(self.__url, data), 'utf-8')\n if len(response) > 0:\n return response\n raise EmptyResponseException()", "docstring": "Get data from API as string.\n\n Keyword arguments:\n mac -- MAC address or OUI for searching\n response_format -- supported types you can see on the https://macaddress.io" }, { "code": "def _load_file(self, filename):\n filename = os.path.abspath(os.path.expanduser(filename))\n if not os.path.isfile(filename):\n raise Exception('File %s does not exist' % filename)\n ext = vtki.get_ext(filename)\n if ext == '.ply':\n reader = vtk.vtkPLYReader()\n elif ext == '.stl':\n reader = vtk.vtkSTLReader()\n elif ext == '.vtk':\n reader = vtk.vtkPolyDataReader()\n elif ext == '.vtp':\n reader = vtk.vtkXMLPolyDataReader()\n elif ext == '.obj':\n reader = vtk.vtkOBJReader()\n else:\n raise TypeError('Filetype must be either \"ply\", \"stl\", \"vtk\", \"vtp\", or \"obj\".')\n reader.SetFileName(filename)\n reader.Update()\n self.ShallowCopy(reader.GetOutput())\n if not np.any(self.points):\n raise AssertionError('Empty or invalid file')", "docstring": "Load a surface mesh from a mesh file.\n\n Mesh file may be an ASCII or binary ply, stl, or vtk mesh file.\n\n Parameters\n ----------\n filename : str\n Filename of mesh to be loaded. File type is inferred from the\n extension of the filename\n\n Notes\n -----\n Binary files load much faster than ASCII." }, { "code": "def get_display_panel_by_id(self, identifier: str) -> DisplayPanel:\n display_panel = next(\n (display_panel for display_panel in self.__document_controller.workspace_controller.display_panels if\n display_panel.identifier.lower() == identifier.lower()), None)\n return DisplayPanel(display_panel) if display_panel else None", "docstring": "Return display panel with the identifier.\n\n .. versionadded:: 1.0\n\n Status: Provisional\n Scriptable: Yes" }, { "code": "def _initialize_client_from_environment():\n global _client, project_id, write_key, read_key, master_key, base_url\n if _client is None:\n project_id = project_id or os.environ.get(\"KEEN_PROJECT_ID\")\n write_key = write_key or os.environ.get(\"KEEN_WRITE_KEY\")\n read_key = read_key or os.environ.get(\"KEEN_READ_KEY\")\n master_key = master_key or os.environ.get(\"KEEN_MASTER_KEY\")\n base_url = base_url or os.environ.get(\"KEEN_BASE_URL\")\n if not project_id:\n raise InvalidEnvironmentError(\"Please set the KEEN_PROJECT_ID environment variable or set keen.project_id!\")\n _client = KeenClient(project_id,\n write_key=write_key,\n read_key=read_key,\n master_key=master_key,\n base_url=base_url)", "docstring": "Initialize a KeenClient instance using environment variables." }, { "code": "def string_to_enum(value, enumeration, strict=True, default_value=None):\n if not isinstance(enumeration, Enum):\n raise ValueError('The specified enumeration is not an instance of Enum')\n if is_undefined(value):\n if strict:\n raise ValueError('The value cannot be null')\n if default_value is not None and not default_value in enumeration:\n raise ValueError('The default value must be an item of the specified enumeration')\n return default_value\n item = [ item for item in enumeration if str(item) == value]\n if len(item) == 0:\n raise ValueError('The specified string \"%s\" does not represent any item of the enumeration' % value)\n return item[0]", "docstring": "Return the item of an enumeration that corresponds to the specified\n string representation.\n\n @param value: string representation of an item of a Python\n enumeration.\n\n @param enumeration: a Python enumeration.\n\n @param strict: indicate whether the value must correspond to an\n item of the specified Python enumeration or if ``None`` value is\n accepted.\n\n @return: the item of the Python enumeration the specified string\n representation corresponds to.\n\n @raise ValueError: if the enumeration is not an instance of\n ``Enum``, or if the string representation doesn't correspond\n to any item of the given Python enumeration, or if the default\n value is not an item of the given Python enumeration." }, { "code": "def __call(self, uri, params=None, method=\"get\"):\n try:\n resp = self.__get_response(uri, params, method, False)\n rjson = resp.json(**self.json_options)\n assert resp.ok\n except AssertionError:\n msg = \"OCode-{}: {}\".format(resp.status_code, rjson[\"message\"])\n raise BadRequest(msg)\n except Exception as e:\n msg = \"Bad response: {}\".format(e)\n log.error(msg, exc_info=True)\n raise BadRequest(msg)\n else:\n return rjson", "docstring": "Only returns the response, nor the status_code" }, { "code": "def _getTrafficClassAndFlowLabel(self):\n if self.tf == 0x0:\n return (self.tc_ecn << 6) + self.tc_dscp, self.flowlabel\n elif self.tf == 0x1:\n return (self.tc_ecn << 6), self.flowlabel\n elif self.tf == 0x2:\n return (self.tc_ecn << 6) + self.tc_dscp, 0\n else:\n return 0, 0", "docstring": "Page 6, draft feb 2011" }, { "code": "def parse_qs(qs, keep_blank_values=0, strict_parsing=0, keep_attr_order=True):\n od = DefaultOrderedDict(list) if keep_attr_order else defaultdict(list)\n for name, value in parse_qsl(qs, keep_blank_values, strict_parsing):\n od[name].append(value)\n return od", "docstring": "Kind of like urlparse.parse_qs, except returns an ordered dict.\n Also avoids replicating that function's bad habit of overriding the\n built-in 'dict' type.\n\n Taken from below with modification:\n " }, { "code": "def call_or_cast(self, method, args={}, nowait=False, **kwargs):\n return (nowait and self.cast or self.call)(method, args, **kwargs)", "docstring": "Apply remote `method` asynchronously or synchronously depending\n on the value of `nowait`.\n\n :param method: The name of the remote method to perform.\n :param args: Dictionary of arguments for the method.\n :keyword nowait: If false the call will block until the result\n is available and return it (default), if true the call will be\n non-blocking and no result will be returned.\n :keyword retry: If set to true then message sending will be retried\n in the event of connection failures. Default is decided by the\n :attr:`retry` attributed.\n :keyword retry_policy: Override retry policies.\n See :attr:`retry_policy`. This must be a dictionary, and keys will\n be merged with the default retry policy.\n :keyword timeout: Timeout to wait for replies in seconds as a float\n (**only relevant in blocking mode**).\n :keyword limit: Limit number of replies to wait for\n (**only relevant in blocking mode**).\n :keyword callback: If provided, this callback will be called for every\n reply received (**only relevant in blocking mode**).\n :keyword \\*\\*props: Additional message properties.\n See :meth:`kombu.Producer.publish`." }, { "code": "def send_cons3rt_agent_logs(self):\n log = logging.getLogger(self.cls_logger + '.send_cons3rt_agent_logs')\n if self.cons3rt_agent_log_dir is None:\n log.warn('There is not CONS3RT agent log directory on this system')\n return\n log.debug('Searching for log files in directory: {d}'.format(d=self.cons3rt_agent_log_dir))\n for item in os.listdir(self.cons3rt_agent_log_dir):\n item_path = os.path.join(self.cons3rt_agent_log_dir, item)\n if os.path.isfile(item_path):\n log.info('Sending email with cons3rt agent log file: {f}'.format(f=item_path))\n try:\n self.send_text_file(text_file=item_path)\n except (TypeError, OSError, AssetMailerError):\n _, ex, trace = sys.exc_info()\n msg = '{n}: There was a problem sending CONS3RT agent log file: {f}\\n{e}'.format(\n n=ex.__class__.__name__, f=item_path, e=str(ex))\n raise AssetMailerError, msg, trace\n else:\n log.info('Successfully sent email with file: {f}'.format(f=item_path))", "docstring": "Send the cons3rt agent log file\n\n :return:" }, { "code": "def get_field_mro(cls, field_name):\n res = set()\n if hasattr(cls, '__mro__'):\n for _class in inspect.getmro(cls):\n values_ = getattr(_class, field_name, None)\n if values_ is not None:\n res = res.union(set(make_list(values_)))\n return res", "docstring": "Goes up the mro and looks for the specified field." }, { "code": "def get_market_history(self, market):\n return self._api_query(path_dict={\n API_V1_1: '/public/getmarkethistory',\n }, options={'market': market, 'marketname': market}, protection=PROTECTION_PUB)", "docstring": "Used to retrieve the latest trades that have occurred for a\n specific market.\n\n Endpoint:\n 1.1 /market/getmarkethistory\n 2.0 NO Equivalent\n\n Example ::\n {'success': True,\n 'message': '',\n 'result': [ {'Id': 5625015,\n 'TimeStamp': '2017-08-31T01:29:50.427',\n 'Quantity': 7.31008193,\n 'Price': 0.00177639,\n 'Total': 0.01298555,\n 'FillType': 'FILL',\n 'OrderType': 'BUY'},\n ...\n ]\n }\n\n :param market: String literal for the market (ex: BTC-LTC)\n :type market: str\n :return: Market history in JSON\n :rtype : dict" }, { "code": "def _get_current_names(current, dsn, pc):\n _table_name = \"\"\n _variable_name = \"\"\n try:\n _table_name = current['{}_tableName'.format(pc)]\n _variable_name = current['{}_variableName'.format(pc)]\n except Exception as e:\n print(\"Error: Unable to collapse time series: {}, {}\".format(dsn, e))\n logger_ts.error(\"get_current: {}, {}\".format(dsn, e))\n return _table_name, _variable_name", "docstring": "Get the table name and variable name from the given time series entry\n\n :param dict current: Time series entry\n :param str pc: paleoData or chronData\n :return str _table_name:\n :return str _variable_name:" }, { "code": "def rpc_call(self, request, method=None, params=None, **kwargs):\n args = []\n kwargs = dict()\n if isinstance(params, dict):\n kwargs.update(params)\n else:\n args = list(as_tuple(params))\n method_key = \"{0}.{1}\".format(self.scheme_name, method)\n if method_key not in self.methods:\n raise AssertionError(\"Unknown method: {0}\".format(method))\n method = self.methods[method_key]\n if hasattr(method, 'request'):\n args.insert(0, request)\n return method(*args, **kwargs)", "docstring": "Call a RPC method.\n\n return object: a result" }, { "code": "def sphlat(r, colat, lons):\n r = ctypes.c_double(r)\n colat = ctypes.c_double(colat)\n lons = ctypes.c_double(lons)\n radius = ctypes.c_double()\n lon = ctypes.c_double()\n lat = ctypes.c_double()\n libspice.sphcyl_c(r, colat, lons, ctypes.byref(radius), ctypes.byref(lon),\n ctypes.byref(lat))\n return radius.value, lon.value, lat.value", "docstring": "Convert from spherical coordinates to latitudinal coordinates.\n\n http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/sphlat_c.html\n\n :param r: Distance of the point from the origin.\n :type r: float\n :param colat: Angle of the point from positive z axis (radians).\n :type colat: float\n :param lons: Angle of the point from the XZ plane (radians).\n :type lons: float\n :return:\n Distance of a point from the origin,\n Angle of the point from the XZ plane in radians,\n Angle of the point from the XY plane in radians.\n :rtype: tuple" }, { "code": "def _set_load_action(self, mem_addr, rec_count, retries,\n read_complete=False):\n if self._have_all_records():\n mem_addr = None\n rec_count = 0\n retries = 0\n elif read_complete:\n retries = 0\n if rec_count:\n mem_addr = self._next_address(mem_addr)\n else:\n mem_addr = self._next_address(mem_addr)\n rec_count = 1\n retries = 0\n elif rec_count and retries < ALDB_RECORD_RETRIES:\n retries = retries + 1\n elif not rec_count and retries < ALDB_ALL_RECORD_RETRIES:\n retries = retries + 1\n elif not rec_count and retries >= ALDB_ALL_RECORD_RETRIES:\n mem_addr = self._next_address(mem_addr)\n rec_count = 1\n retries = 0\n else:\n mem_addr = None\n rec_count = 0\n retries = 0\n self._load_action = LoadAction(mem_addr, rec_count, retries)\n if mem_addr is not None:\n _LOGGER.debug('Load action: addr: %04x rec_count: %d retries: %d',\n self._load_action.mem_addr,\n self._load_action.rec_count,\n self._load_action.retries)", "docstring": "Calculate the next record to read.\n\n If the last record was successful and one record was being read then\n look for the next record until we get to the high water mark.\n\n If the last read was successful and all records were being read then\n look for the first record.\n\n if the last read was unsuccessful and one record was being read then\n repeat the last read until max retries\n\n If the last read was unsuccessful and all records were being read then\n repeat the last read until max retries or look for the first record." }, { "code": "def get_ctype(rtype, cfunc, *args):\n val_p = backend.ffi.new(rtype)\n args = args + (val_p,)\n cfunc(*args)\n return val_p[0]", "docstring": "Call a C function that takes a pointer as its last argument and\n return the C object that it contains after the function has finished.\n\n :param rtype: C data type is filled by the function\n :param cfunc: C function to call\n :param args: Arguments to call function with\n :return: A pointer to the specified data type" }, { "code": "async def set_config(self, config):\n app_facade = client.ApplicationFacade.from_connection(self.connection)\n log.debug(\n 'Setting config for %s: %s', self.name, config)\n return await app_facade.Set(self.name, config)", "docstring": "Set configuration options for this application.\n\n :param config: Dict of configuration to set" }, { "code": "def _fit_and_score_ensemble(self, X, y, cv, **fit_params):\n fit_params_steps = self._split_fit_params(fit_params)\n folds = list(cv.split(X, y))\n base_estimators, kernel_cache = self._get_base_estimators(X)\n out = Parallel(\n n_jobs=self.n_jobs, verbose=self.verbose\n )(\n delayed(_fit_and_score_fold)(clone(estimator),\n X if i not in kernel_cache else kernel_cache[i],\n y,\n self.scorer,\n train_index, test_index,\n fit_params_steps[name],\n i, fold)\n for i, (name, estimator) in enumerate(base_estimators)\n for fold, (train_index, test_index) in enumerate(folds))\n if len(kernel_cache) > 0:\n out = self._restore_base_estimators(kernel_cache, out, X, folds)\n return self._create_base_ensemble(out, len(base_estimators), len(folds))", "docstring": "Create a cross-validated model by training a model for each fold with the same model parameters" }, { "code": "def content(self, path=None, overwrite=True, encoding='utf-8'):\n if path:\n self.download(wait=True, path=path, overwrite=overwrite)\n with io.open(path, 'r', encoding=encoding) as fp:\n return fp.read()\n with tempfile.NamedTemporaryFile() as tmpfile:\n self.download(wait=True, path=tmpfile.name, overwrite=overwrite)\n with io.open(tmpfile.name, 'r', encoding=encoding) as fp:\n return fp.read()", "docstring": "Downloads file to the specified path or as temporary file\n and reads the file content in memory.\n Should not be used on very large files.\n\n :param path: Path for file download If omitted tmp file will be used.\n :param overwrite: Overwrite file if exists locally\n :param encoding: File encoding, by default it is UTF-8\n :return: File content." }, { "code": "def _get_shade_hdrgos(**kws):\n if 'shade_hdrgos' in kws:\n return kws['shade_hdrgos']\n if 'hdrgo_prt' in kws:\n return kws['hdrgo_prt']\n if 'section_sortby' in kws and kws['section_sortby']:\n return False\n if 'top_n' in kws and isinstance(kws['top_n'], int):\n return False\n return True", "docstring": "If no hdrgo_prt specified, and these conditions are present -> hdrgo_prt=F." }, { "code": "def top_sections(self):\n top_line = self.text.split('\\n')[0]\n sections = len(top_line.split('+')) - 2\n return sections", "docstring": "The number of sections that touch the top side.\n\n Returns\n -------\n sections : int\n The number of sections on the top" }, { "code": "def countok(self):\n ok = np.ones(len(self.stars)).astype(bool)\n for name in self.constraints:\n c = self.constraints[name]\n if c.name not in self.selectfrac_skip:\n ok &= c.ok\n return ok", "docstring": "Boolean array showing which stars pass all count constraints.\n\n A \"count constraint\" is a constraint that affects the number of stars." }, { "code": "def do_commit_amends(self):\n commit_cumalative_count = 0\n for days in MARKED_DAYS:\n amend_date = (\n self.end_date - datetime.timedelta(days)).strftime(\"%Y-%m-%d %H:%M:%S\")\n for commit_number_in_a_day in xrange(0, self.max_commits):\n commit_cumalative_count += 1\n subprocess.check_call(\n ['git', 'commit', '--amend', \"--date='<\" + amend_date + \" + 0530 >' \", '-C',\n 'HEAD~{commit_number}'.format(commit_number=commit_cumalative_count)], cwd=self.repository_name)\n subprocess.check_call(\n ['git', 'pull', '--no-edit'], cwd=self.repository_name)\n subprocess.check_call(\n ['git', 'push', 'origin', 'master'], cwd=self.repository_name)", "docstring": "Amends the Commit to form the heart" }, { "code": "def disallow(nodes):\n def disallowed(cls):\n cls.unsupported_nodes = ()\n for node in nodes:\n new_method = _node_not_implemented(node, cls)\n name = 'visit_{node}'.format(node=node)\n cls.unsupported_nodes += (name,)\n setattr(cls, name, new_method)\n return cls\n return disallowed", "docstring": "Decorator to disallow certain nodes from parsing. Raises a\n NotImplementedError instead.\n\n Returns\n -------\n disallowed : callable" }, { "code": "def get_sh_ids(self, identity, backend_name):\n identity_tuple = tuple(identity.items())\n sh_ids = self.__get_sh_ids_cache(identity_tuple, backend_name)\n return sh_ids", "docstring": "Return the Sorting Hat id and uuid for an identity" }, { "code": "def _convert_to_degress(self, value):\n d0 = value[0][0]\n d1 = value[0][1]\n d = float(d0) / float(d1)\n m0 = value[1][0]\n m1 = value[1][1]\n m = float(m0) / float(m1)\n s0 = value[2][0]\n s1 = value[2][1]\n s = float(s0) / float(s1)\n return d + (m / 60.0) + (s / 3600.0)", "docstring": "Helper function to convert the GPS coordinates stored in the EXIF to degress in float format" }, { "code": "def time_window(self, window_width_ms):\n op = Operator(\n _generate_uuid(),\n OpType.TimeWindow,\n \"TimeWindow\",\n num_instances=self.env.config.parallelism,\n other=window_width_ms)\n return self.__register(op)", "docstring": "Applies a system time window to the stream.\n\n Attributes:\n window_width_ms (int): The length of the window in ms." }, { "code": "def _geodetic_to_cartesian(cls, lat, lon, alt):\n C = Earth.r / np.sqrt(1 - (Earth.e * np.sin(lat)) ** 2)\n S = Earth.r * (1 - Earth.e ** 2) / np.sqrt(1 - (Earth.e * np.sin(lat)) ** 2)\n r_d = (C + alt) * np.cos(lat)\n r_k = (S + alt) * np.sin(lat)\n norm = np.sqrt(r_d ** 2 + r_k ** 2)\n return norm * np.array([\n np.cos(lat) * np.cos(lon),\n np.cos(lat) * np.sin(lon),\n np.sin(lat)\n ])", "docstring": "Conversion from latitude, longitude and altitude coordinates to\n cartesian with respect to an ellipsoid\n\n Args:\n lat (float): Latitude in radians\n lon (float): Longitude in radians\n alt (float): Altitude to sea level in meters\n\n Return:\n numpy.array: 3D element (in meters)" }, { "code": "def get_interpolated(self, target, extent):\n result = self.copy()\n result.interpolate(target, extent)\n return result", "docstring": "Return a new vector that has been moved towards the given target by \n the given extent. The extent should be between 0 and 1." }, { "code": "def decode(self) -> Iterable:\n if self.data[0:1] not in (b'd', b'l'):\n return self.__wrap_with_tuple()\n return self.__parse()", "docstring": "Start of decode process. Returns final results." }, { "code": "def _apply_credentials(auto_refresh=True, credentials=None,\n headers=None):\n token = credentials.get_credentials().access_token\n if auto_refresh is True:\n if token is None:\n token = credentials.refresh(\n access_token=None, timeout=10)\n elif credentials.jwt_is_expired():\n token = credentials.refresh(timeout=10)\n headers.update(\n {'Authorization': \"Bearer {}\".format(token)}\n )", "docstring": "Update Authorization header.\n\n Update request headers with latest `access_token`. Perform token\n `refresh` if token is ``None``.\n\n Args:\n auto_refresh (bool): Perform token refresh if access_token is ``None`` or expired. Defaults to ``True``.\n credentials (class): Read-only credentials.\n headers (class): Requests `CaseInsensitiveDict`." }, { "code": "def do_random(context, seq):\n try:\n return random.choice(seq)\n except IndexError:\n return context.environment.undefined('No random item, sequence was empty.')", "docstring": "Return a random item from the sequence." }, { "code": "async def _sonar_data(self, data):\n data = data[1:-1]\n pin_number = data[0]\n val = int((data[PrivateConstants.MSB] << 7) +\n data[PrivateConstants.LSB])\n reply_data = []\n sonar_pin_entry = self.active_sonar_map[pin_number]\n if sonar_pin_entry[0] is not None:\n if sonar_pin_entry[2] != val:\n sonar_pin_entry[2] = val\n self.active_sonar_map[pin_number] = sonar_pin_entry\n if sonar_pin_entry[0]:\n reply_data.append(pin_number)\n reply_data.append(val)\n if sonar_pin_entry[1]:\n await sonar_pin_entry[0](reply_data)\n else:\n loop = self.loop\n loop.call_soon(sonar_pin_entry[0], reply_data)\n else:\n sonar_pin_entry[1] = val\n self.active_sonar_map[pin_number] = sonar_pin_entry\n await asyncio.sleep(self.sleep_tune)", "docstring": "This method handles the incoming sonar data message and stores\n the data in the response table.\n\n :param data: Message data from Firmata\n\n :returns: No return value." }, { "code": "def query_names(self, pat):\n for item in self.chnames.items():\n if fnmatch.fnmatchcase(item[1], pat):\n print item", "docstring": "pat a shell pattern. See fnmatch.fnmatchcase. Print the\n results to stdout." }, { "code": "def write_json(self):\n with open(self.results_folder_name + '/results-' + str(self.get_global_count()) + '.json', 'a') as f:\n json.dump(self.result, f)", "docstring": "Dump data into json file." }, { "code": "def ref(self):\n x = RefTrace(self.filehandle,\n self.dtype,\n len(self),\n self.shape,\n self.readonly,\n )\n yield x\n x.flush()", "docstring": "A write-back version of Trace\n\n Returns\n -------\n ref : RefTrace\n `ref` is returned in a context manager, and must be in a ``with``\n statement\n\n Notes\n -----\n .. versionadded:: 1.6\n\n Examples\n --------\n >>> with trace.ref as ref:\n ... ref[10] += 1.617" }, { "code": "def translate_state(self, s):\n if not isinstance(s, basestring):\n return s\n s = s.capitalize().replace(\"_\", \" \")\n return t(_(s))", "docstring": "Translate the given state string" }, { "code": "def require_bool(self, key: str) -> bool:\n v = self.get_bool(key)\n if v is None:\n raise ConfigMissingError(self.full_key(key))\n return v", "docstring": "Returns a configuration value, as a bool, by its given key. If it doesn't exist, or the\n configuration value is not a legal bool, an error is thrown.\n\n :param str key: The requested configuration key.\n :return: The configuration key's value.\n :rtype: bool\n :raises ConfigMissingError: The configuration value did not exist.\n :raises ConfigTypeError: The configuration value existed but couldn't be coerced to bool." }, { "code": "def tilequeue_rawr_seed_all(cfg, peripherals):\n rawr_yaml = cfg.yml.get('rawr')\n assert rawr_yaml is not None, 'Missing rawr configuration in yaml'\n group_by_zoom = rawr_yaml.get('group-zoom')\n assert group_by_zoom is not None, 'Missing group-zoom rawr config'\n max_coord = 2 ** group_by_zoom\n coords = []\n for x in xrange(0, max_coord):\n for y in xrange(0, max_coord):\n coords.append(Coordinate(zoom=group_by_zoom, column=x, row=y))\n _tilequeue_rawr_seed(cfg, peripherals, coords)", "docstring": "command to enqueue all the tiles at the group-by zoom" }, { "code": "def _get_model(self, appname, modelname):\n app = self._get_app(appname)\n models = app.get_models()\n model = None\n for mod in models:\n if mod.__name__ == modelname:\n model = mod\n return model\n msg = \"Model \" + modelname + \" not found\"", "docstring": "return model or None" }, { "code": "def stored_bind(self, instance):\n if self.id is None:\n return self.bind(instance)\n store = self._bound_pangler_store.setdefault(instance, {})\n p = store.get(self.id)\n if p is None:\n p = store[self.id] = self.bind(instance)\n return p", "docstring": "Bind an instance to this Pangler, using the bound Pangler store.\n\n This method functions identically to `bind`, except that it might\n return a Pangler which was previously bound to the provided instance." }, { "code": "def path_distance(points):\n vecs = np.diff(points, axis=0)[:, :3]\n d2 = [np.dot(p, p) for p in vecs]\n return np.sum(np.sqrt(d2))", "docstring": "Compute the path distance from given set of points" }, { "code": "def connectivity(measure_names, b, c=None, nfft=512):\n con = Connectivity(b, c, nfft)\n try:\n return getattr(con, measure_names)()\n except TypeError:\n return dict((m, getattr(con, m)()) for m in measure_names)", "docstring": "Calculate connectivity measures.\n\n Parameters\n ----------\n measure_names : str or list of str\n Name(s) of the connectivity measure(s) to calculate. See\n :class:`Connectivity` for supported measures.\n b : array, shape (n_channels, n_channels * model_order)\n VAR model coefficients. See :ref:`var-model-coefficients` for details\n about the arrangement of coefficients.\n c : array, shape (n_channels, n_channels), optional\n Covariance matrix of the driving noise process. Identity matrix is used\n if set to None (default).\n nfft : int, optional\n Number of frequency bins to calculate. Note that these points cover the\n range between 0 and half the sampling rate.\n\n Returns\n -------\n result : array, shape (n_channels, n_channels, `nfft`)\n An array of shape (m, m, nfft) is returned if measures is a string. If\n measures is a list of strings, a dictionary is returned, where each key\n is the name of the measure, and the corresponding values are arrays of\n shape (m, m, nfft).\n\n Notes\n -----\n When using this function, it is more efficient to get several measures at\n once than calling the function multiple times.\n\n Examples\n --------\n >>> c = connectivity(['DTF', 'PDC'], [[0.3, 0.6], [0.0, 0.9]])" }, { "code": "def count_async(self, limit=None, **q_options):\n qry = self._fix_namespace()\n return qry._count_async(limit=limit, **q_options)", "docstring": "Count the number of query results, up to a limit.\n\n This is the asynchronous version of Query.count()." }, { "code": "def _uri(self, url):\n if url and not url.startswith('/'):\n return url\n uri = \"{0}://{1}{2}{3}\".format(\n self._protocol,\n self.real_connection.host,\n self._port_postfix(),\n url,\n )\n return uri", "docstring": "Returns request absolute URI" }, { "code": "def from_object(obj):\n return obj if isinstance(obj, Contact) \\\n else Contact(cast.string_to_enum(obj.name, Contact.ContactName),\n obj.value,\n is_primary=obj.is_primary and cast.string_to_boolean(obj.is_primary, strict=True),\n is_verified=obj.is_verified and cast.string_to_boolean(obj.is_verified, strict=True))", "docstring": "Convert an object representing a contact information to an instance\n `Contact`.\n\n\n @param obj: an object containg the following attributes:\n\n * `name`: an item of the enumeration `ContactName` representing the\n type of this contact information.\n\n * `value`: value of this contact information representing by a string,\n such as ``+84.01272170781``, the formatted value for a telephone\n number property.\n\n * `is_primary`: indicate whether this contact property is the first to\n be used to contact the entity that this contact information\n corresponds to. There is only one primary contact property for a\n given property name (e.g., `EMAIL`, `PHONE`, `WEBSITE`).\n\n * `is_verified`: indicate whether this contact information has been\n verified, whether it has been grabbed from a trusted Social\n Networking Service (SNS), or whether through a challenge/response\n process.\n\n\n @raise ValueError: if the value of this contact information is null." }, { "code": "def on_network_adapter_change(self, network_adapter, change_adapter):\n if not isinstance(network_adapter, INetworkAdapter):\n raise TypeError(\"network_adapter can only be an instance of type INetworkAdapter\")\n if not isinstance(change_adapter, bool):\n raise TypeError(\"change_adapter can only be an instance of type bool\")\n self._call(\"onNetworkAdapterChange\",\n in_p=[network_adapter, change_adapter])", "docstring": "Triggered when settings of a network adapter of the\n associated virtual machine have changed.\n\n in network_adapter of type :class:`INetworkAdapter`\n\n in change_adapter of type bool\n\n raises :class:`VBoxErrorInvalidVmState`\n Session state prevents operation.\n \n raises :class:`VBoxErrorInvalidObjectState`\n Session type prevents operation." }, { "code": "def minutes_in_range(self, start_minute, end_minute):\n start_idx = searchsorted(self._trading_minutes_nanos,\n start_minute.value)\n end_idx = searchsorted(self._trading_minutes_nanos,\n end_minute.value)\n if end_minute.value == self._trading_minutes_nanos[end_idx]:\n end_idx += 1\n return self.all_minutes[start_idx:end_idx]", "docstring": "Given start and end minutes, return all the calendar minutes\n in that range, inclusive.\n\n Given minutes don't need to be calendar minutes.\n\n Parameters\n ----------\n start_minute: pd.Timestamp\n The minute representing the start of the desired range.\n\n end_minute: pd.Timestamp\n The minute representing the end of the desired range.\n\n Returns\n -------\n pd.DatetimeIndex\n The minutes in the desired range." }, { "code": "def diffuse_template(self, **kwargs):\n kwargs_copy = self.base_dict.copy()\n kwargs_copy.update(**kwargs)\n self._replace_none(kwargs_copy) \n localpath = NameFactory.diffuse_template_format.format(**kwargs_copy)\n if kwargs.get('fullpath', False):\n return self.fullpath(localpath=localpath)\n return localpath", "docstring": "return the file name for other diffuse map templates" }, { "code": "def _process(self, data):\n try:\n packet = json.loads(data)\n except ValueError:\n logger.warning('Received invalid JSON from client. Ignoring.')\n return\n if packet['cmd'] == 'run-command':\n self._run_command(packet)\n elif packet['cmd'] == 'in':\n self._pipeinput.send_text(packet['data'])\n elif packet['cmd'] == 'size':\n data = packet['data']\n self.size = Size(rows=data[0], columns=data[1])\n self.pymux.invalidate()\n elif packet['cmd'] == 'start-gui':\n detach_other_clients = bool(packet['detach-others'])\n color_depth = packet['color-depth']\n term = packet['term']\n if detach_other_clients:\n for c in self.pymux.connections:\n c.detach_and_close()\n print('Create app...')\n self._create_app(color_depth=color_depth, term=term)", "docstring": "Process packet received from client." }, { "code": "def currency_context(context):\n request = context['request']\n currency_code = memoize_nullary(lambda: get_currency_code(request))\n context['CURRENCIES'] = Currency.active.all()\n context['CURRENCY_CODE'] = currency_code\n context['CURRENCY'] = memoize_nullary(lambda: get_currency(currency_code))\n return ''", "docstring": "Use instead of context processor\n Context variables are only valid within the block scope" }, { "code": "def show_tabulated(self, begin, middle, end):\n internal_assert(len(begin) < info_tabulation, \"info message too long\", begin)\n self.show(begin + \" \" * (info_tabulation - len(begin)) + middle + \" \" + end)", "docstring": "Shows a tabulated message." }, { "code": "def create_user(self, claims):\n email = claims.get('email')\n username = self.get_username(claims)\n return self.UserModel.objects.create_user(username, email)", "docstring": "Return object for a newly created user account." }, { "code": "def unregister(self, command):\n if command not in self._commands.keys():\n self.log.warning(\"Can not unregister command %s\" % command)\n else:\n del(self._click_root_command.commands[command])\n del(self._commands[command])\n self.log.debug(\"Command %s got unregistered\" % command)", "docstring": "Unregisters an existing command, so that this command is no longer available on the command line interface.\n\n This function is mainly used during plugin deactivation.\n\n :param command: Name of the command" }, { "code": "def purge(datasets, reuses, organizations):\n purge_all = not any((datasets, reuses, organizations))\n if purge_all or datasets:\n log.info('Purging datasets')\n purge_datasets()\n if purge_all or reuses:\n log.info('Purging reuses')\n purge_reuses()\n if purge_all or organizations:\n log.info('Purging organizations')\n purge_organizations()\n success('Done')", "docstring": "Permanently remove data flagged as deleted.\n\n If no model flag is given, all models are purged." }, { "code": "def datapt_to_wcspt(self, datapt, coords='data', naxispath=None):\n if naxispath:\n raise NotImplementedError\n return np.asarray([self.pixtoradec((pt[0], pt[1]), coords=coords)\n for pt in datapt])", "docstring": "Convert multiple data points to WCS.\n\n Parameters\n ----------\n datapt : array-like\n Pixel coordinates in the format of\n ``[[x0, y0, ...], [x1, y1, ...], ..., [xn, yn, ...]]``.\n\n coords : 'data' or None, optional, default to 'data'\n Expresses whether the data coordinate is indexed from zero.\n\n naxispath : list-like or None, optional, defaults to None\n A sequence defining the pixel indexes > 2D, if any.\n\n Returns\n -------\n wcspt : array-like\n WCS coordinates in the format of\n ``[[ra0, dec0], [ra1, dec1], ..., [ran, decn]]``." }, { "code": "def move_to_clipboard(self, request, files_queryset, folders_queryset):\n if not self.has_change_permission(request):\n raise PermissionDenied\n if request.method != 'POST':\n return None\n clipboard = tools.get_user_clipboard(request.user)\n check_files_edit_permissions(request, files_queryset)\n check_folder_edit_permissions(request, folders_queryset)\n files_count = [0]\n def move_files(files):\n files_count[0] += tools.move_file_to_clipboard(files, clipboard)\n def move_folders(folders):\n for f in folders:\n move_files(f.files)\n move_folders(f.children.all())\n move_files(files_queryset)\n move_folders(folders_queryset)\n self.message_user(request, _(\"Successfully moved %(count)d files to \"\n \"clipboard.\") % {\"count\": files_count[0]})\n return None", "docstring": "Action which moves the selected files and files in selected folders\n to clipboard." }, { "code": "def jwt_required(realm=None):\n def wrapper(fn):\n @wraps(fn)\n def decorator(*args, **kwargs):\n _jwt_required(realm or current_app.config['JWT_DEFAULT_REALM'])\n return fn(*args, **kwargs)\n return decorator\n return wrapper", "docstring": "View decorator that requires a valid JWT token to be present in the request\n\n :param realm: an optional realm" }, { "code": "def remove_alert(thing_name, key, session=None):\n return _request('get', '/remove/alert/for/{0}'.format(thing_name), params={'key': key}, session=session)", "docstring": "Remove an alert for the given thing" }, { "code": "def dbmin20years(self, value=None):\n if value is not None:\n try:\n value = float(value)\n except ValueError:\n raise ValueError('value {} need to be of type float '\n 'for field `dbmin20years`'.format(value))\n self._dbmin20years = value", "docstring": "Corresponds to IDD Field `dbmin20years`\n 20-year return period values for minimum extreme dry-bulb temperature\n\n Args:\n value (float): value for IDD Field `dbmin20years`\n Unit: C\n if `value` is None it will not be checked against the\n specification and is assumed to be a missing value\n\n Raises:\n ValueError: if `value` is not a valid value" }, { "code": "def export(self, node):\n dictexporter = self.dictexporter or DictExporter()\n data = dictexporter.export(node)\n return json.dumps(data, **self.kwargs)", "docstring": "Return JSON for tree starting at `node`." }, { "code": "def parse_mailto(mailto_str):\n if mailto_str.startswith('mailto:'):\n import urllib.parse\n to_str, parms_str = mailto_str[7:].partition('?')[::2]\n headers = {}\n body = u''\n to = urllib.parse.unquote(to_str)\n if to:\n headers['To'] = [to]\n for s in parms_str.split('&'):\n key, value = s.partition('=')[::2]\n key = key.capitalize()\n if key == 'Body':\n body = urllib.parse.unquote(value)\n elif value:\n headers[key] = [urllib.parse.unquote(value)]\n return (headers, body)\n else:\n return (None, None)", "docstring": "Interpret mailto-string\n\n :param mailto_str: the string to interpret. Must conform to :rfc:2368.\n :type mailto_str: str\n :return: the header fields and the body found in the mailto link as a tuple\n of length two\n :rtype: tuple(dict(str->list(str)), str)" }, { "code": "def getCodecList(self):\n if self.checkVersion('1.4'):\n cmd = \"core show codecs\"\n else:\n cmd = \"show codecs\"\n cmdresp = self.executeCommand(cmd)\n info_dict = {}\n for line in cmdresp.splitlines():\n mobj = re.match('\\s*(\\d+)\\s+\\((.+)\\)\\s+\\((.+)\\)\\s+(\\w+)\\s+(\\w+)\\s+\\((.+)\\)$',\n line)\n if mobj:\n info_dict[mobj.group(5)] = (mobj.group(4), mobj.group(6))\n return info_dict", "docstring": "Query Asterisk Manager Interface for defined codecs.\n \n CLI Command - core show codecs\n \n @return: Dictionary - Short Name -> (Type, Long Name)" }, { "code": "def create_toolbutton(parent, text=None, shortcut=None, icon=None, tip=None,\r\n toggled=None, triggered=None,\r\n autoraise=True, text_beside_icon=False):\r\n button = QToolButton(parent)\r\n if text is not None:\r\n button.setText(text)\r\n if icon is not None:\r\n if is_text_string(icon):\r\n icon = get_icon(icon)\r\n button.setIcon(icon)\r\n if text is not None or tip is not None:\r\n button.setToolTip(text if tip is None else tip)\r\n if text_beside_icon:\r\n button.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)\r\n button.setAutoRaise(autoraise)\r\n if triggered is not None:\r\n button.clicked.connect(triggered)\r\n if toggled is not None:\r\n button.toggled.connect(toggled)\r\n button.setCheckable(True)\r\n if shortcut is not None:\r\n button.setShortcut(shortcut)\r\n return button", "docstring": "Create a QToolButton" }, { "code": "def _ctypes_code_parameter(lines, parameter, position):\n mdict = {\n 'indices': _ctypes_indices,\n 'variable': _ctypes_variables,\n 'out': _ctypes_out,\n 'regular': _ctypes_regular,\n 'saved': _ctypes_saved,\n 'assign': _ctypes_assign,\n 'clean': _ctypes_clean\n }\n line = mdict[position](parameter)\n if line is not None:\n value, blank = line\n lines.append(value)\n if blank:\n lines.append(\"\")", "docstring": "Returns the code for the specified parameter being written into a subroutine wrapper.\n\n :arg position: one of ['indices', 'variable', 'out', 'regular', 'saved', 'assign', 'clean']" }, { "code": "def set_close_callback(self, callback: Optional[Callable[[], None]]) -> None:\n self._close_callback = callback\n self._maybe_add_error_listener()", "docstring": "Call the given callback when the stream is closed.\n\n This mostly is not necessary for applications that use the\n `.Future` interface; all outstanding ``Futures`` will resolve\n with a `StreamClosedError` when the stream is closed. However,\n it is still useful as a way to signal that the stream has been\n closed while no other read or write is in progress.\n\n Unlike other callback-based interfaces, ``set_close_callback``\n was not removed in Tornado 6.0." }, { "code": "def read(parts):\n cur_dir = os.path.abspath(os.path.dirname(__file__))\n with codecs.open(os.path.join(cur_dir, *parts), \"rb\", \"utf-8\") as f:\n return f.read()", "docstring": "Build an absolute path from parts array and and return the contents\n of the resulting file. Assume UTF-8 encoding." }, { "code": "def bootstrap_buttons(parser, token):\n kwargs = parse_token_contents(parser, token)\n kwargs[\"nodelist\"] = parser.parse((\"endbuttons\",))\n parser.delete_first_token()\n return ButtonsNode(**kwargs)", "docstring": "Render buttons for form\n\n **Tag name**::\n\n buttons\n\n **Parameters**:\n\n submit\n Text for a submit button\n\n reset\n Text for a reset button\n\n **Usage**::\n\n {% buttons %}{% endbuttons %}\n\n **Example**::\n\n {% buttons submit='OK' reset=\"Cancel\" %}{% endbuttons %}" }, { "code": "def get_acls_recursive(self, path, depth, include_ephemerals):\n yield path, self.get_acls(path)[0]\n if depth == -1:\n return\n for tpath, _ in self.tree(path, depth, full_path=True):\n try:\n acls, stat = self.get_acls(tpath)\n except NoNodeError:\n continue\n if not include_ephemerals and stat.ephemeralOwner != 0:\n continue\n yield tpath, acls", "docstring": "A recursive generator wrapper for get_acls\n\n :param path: path from which to start\n :param depth: depth of the recursion (-1 no recursion, 0 means no limit)\n :param include_ephemerals: get ACLs for ephemerals too" }, { "code": "def fit_for_distance(self):\n for prop in self.properties.keys():\n if prop in self.ic.bands:\n return True\n return False", "docstring": "``True`` if any of the properties are apparent magnitudes." }, { "code": "def assign(self, dst, req, src):\n if req == 'null':\n return\n elif req in ('write', 'inplace'):\n dst[:] = src\n elif req == 'add':\n dst[:] += src", "docstring": "Helper function for assigning into dst depending on requirements." }, { "code": "def container_instance_from_string(id):\n try:\n service, instance = id.rsplit('_', 1)\n instance = int(instance)\n except (TypeError, ValueError):\n raise context.ValueError(\"Invalid container id %r\" % id)\n return _proto.ContainerInstance(service_name=service, instance=instance)", "docstring": "Create a ContainerInstance from an id string" }, { "code": "def push_primary_analyses_for_removal(self, analysis_request, analyses):\n to_remove = self.analyses_to_remove.get(analysis_request, [])\n to_remove.extend(analyses)\n self.analyses_to_remove[analysis_request] = list(set(to_remove))", "docstring": "Stores the analyses to be removed after partitions creation" }, { "code": "def set_focus(self, pos):\n \"Set the focus in the underlying body widget.\"\n logging.debug('setting focus to %s ', pos)\n self.body.set_focus(pos)", "docstring": "Set the focus in the underlying body widget." }, { "code": "def delete_info(ctx, info):\n head = ctx.parent.head\n vcf_handle = ctx.parent.handle\n outfile = ctx.parent.outfile\n silent = ctx.parent.silent\n if not info:\n logger.error(\"No info provided\")\n sys.exit(\"Please provide a info string\")\n if not info in head.info_dict:\n logger.error(\"Info '{0}' is not specified in vcf header\".format(info))\n sys.exit(\"Please provide a valid info field\")\n head.remove_header(info)\n print_headers(head, outfile=outfile, silent=silent)\n for line in vcf_handle:\n line = line.rstrip()\n new_line = remove_vcf_info(keyword=info, variant_line=line)\n print_variant(variant_line=new_line, outfile=outfile, silent=silent)", "docstring": "Delete a info field from all variants in a vcf" }, { "code": "def resize2fs(device):\n cmd = 'resize2fs {0}'.format(device)\n try:\n out = __salt__['cmd.run_all'](cmd, python_shell=False)\n except subprocess.CalledProcessError as err:\n return False\n if out['retcode'] == 0:\n return True", "docstring": "Resizes the filesystem.\n\n CLI Example:\n .. code-block:: bash\n\n salt '*' disk.resize2fs /dev/sda1" }, { "code": "def get_object(self):\n if self._object:\n return self._object\n self._object = super().get_object()\n if not self.AUDITOR_EVENT_TYPES:\n return self._object\n method = self.request.method\n event_type = self.AUDITOR_EVENT_TYPES.get(method)\n if method == 'GET' and event_type and is_user(self.request.user):\n auditor.record(event_type=event_type,\n instance=self._object,\n actor_id=self.request.user.id,\n actor_name=self.request.user.username)\n elif method == 'DELETE' and event_type and is_user(self.request.user):\n auditor.record(event_type=event_type,\n instance=self._object,\n actor_id=self.request.user.id,\n actor_name=self.request.user.username)\n return self._object", "docstring": "We memoize the access to this function in case a second call is made." }, { "code": "def db_exists(cls, impl, working_dir):\n path = config.get_snapshots_filename(impl, working_dir)\n return os.path.exists(path)", "docstring": "Does the chainstate db exist?" }, { "code": "def run_bottleneck_on_image(sess, image_data, image_data_tensor,\n decoded_image_tensor, resized_input_tensor,\n bottleneck_tensor):\n resized_input_values = sess.run(decoded_image_tensor,\n {image_data_tensor: image_data})\n bottleneck_values = sess.run(bottleneck_tensor,\n {resized_input_tensor: resized_input_values})\n bottleneck_values = np.squeeze(bottleneck_values)\n return bottleneck_values", "docstring": "Runs inference on an image to extract the 'bottleneck' summary layer.\n\n Args:\n sess: Current active TensorFlow Session.\n image_data: String of raw JPEG data.\n image_data_tensor: Input data layer in the graph.\n decoded_image_tensor: Output of initial image resizing and preprocessing.\n resized_input_tensor: The input node of the recognition graph.\n bottleneck_tensor: Layer before the final softmax.\n\n Returns:\n Numpy array of bottleneck values." }, { "code": "def getElementByWdomId(self, id: Union[str]) -> Optional[WebEventTarget]:\n elm = getElementByWdomId(id)\n if elm and elm.ownerDocument is self:\n return elm\n return None", "docstring": "Get an element node with ``wdom_id``.\n\n If this document does not have the element with the id, return None." }, { "code": "def apply_gates_to_fd(stilde_dict, gates):\n outdict = dict(stilde_dict.items())\n strain_dict = dict([[ifo, outdict[ifo].to_timeseries()] for ifo in gates])\n for ifo,d in apply_gates_to_td(strain_dict, gates).items():\n outdict[ifo] = d.to_frequencyseries()\n return outdict", "docstring": "Applies the given dictionary of gates to the given dictionary of\n strain in the frequency domain.\n\n Gates are applied by IFFT-ing the strain data to the time domain, applying\n the gate, then FFT-ing back to the frequency domain.\n\n Parameters\n ----------\n stilde_dict : dict\n Dictionary of frequency-domain strain, keyed by the ifos.\n gates : dict\n Dictionary of gates. Keys should be the ifo to apply the data to,\n values are a tuple giving the central time of the gate, the half\n duration, and the taper duration.\n\n Returns\n -------\n dict\n Dictionary of frequency-domain strain with the gates applied." }, { "code": "def search_info(self, search_index):\n ddoc_search_info = self.r_session.get(\n '/'.join([self.document_url, '_search_info', search_index]))\n ddoc_search_info.raise_for_status()\n return response_to_json_dict(ddoc_search_info)", "docstring": "Retrieves information about a specified search index within the design\n document, returns dictionary\n\n GET databasename/_design/{ddoc}/_search_info/{search_index}" }, { "code": "def setup(\n *,\n verbose: bool = False,\n quiet: bool = False,\n color: str = \"auto\",\n title: str = \"auto\",\n timestamp: bool = False\n) -> None:\n _setup(verbose=verbose, quiet=quiet, color=color, title=title, timestamp=timestamp)", "docstring": "Configure behavior of message functions.\n\n :param verbose: Whether :func:`debug` messages should get printed\n :param quiet: Hide every message except :func:`warning`, :func:`error`, and\n :func:`fatal`\n :param color: Choices: 'auto', 'always', or 'never'. Whether to color output.\n By default ('auto'), only use color when output is a terminal.\n :param title: Ditto for setting terminal title\n :param timestamp: Whether to prefix every message with a time stamp" }, { "code": "def write(self, text):\n if text:\n if text[0] in '(w':\n self.log.debug(text[:-1])\n return\n if self.access_log:\n self.access_log.write(text)\n self.log.info(text[:-1])", "docstring": "Write to appropriate target." }, { "code": "def read_energy_bounds(hdu):\n nebins = len(hdu.data)\n ebin_edges = np.ndarray((nebins + 1))\n try:\n ebin_edges[0:-1] = np.log10(hdu.data.field(\"E_MIN\")) - 3.\n ebin_edges[-1] = np.log10(hdu.data.field(\"E_MAX\")[-1]) - 3.\n except KeyError:\n ebin_edges[0:-1] = np.log10(hdu.data.field(\"energy_MIN\"))\n ebin_edges[-1] = np.log10(hdu.data.field(\"energy_MAX\")[-1])\n return ebin_edges", "docstring": "Reads and returns the energy bin edges from a FITs HDU" }, { "code": "def impact_check_range(func):\n @wraps(func)\n def impact_wrapper(*args,**kwargs):\n if isinstance(args[1],numpy.ndarray):\n out= numpy.zeros(len(args[1]))\n goodIndx= (args[1] < args[0]._deltaAngleTrackImpact)*(args[1] > 0.)\n out[goodIndx]= func(args[0],args[1][goodIndx])\n return out\n elif args[1] >= args[0]._deltaAngleTrackImpact or args[1] <= 0.:\n return 0.\n else:\n return func(*args,**kwargs)\n return impact_wrapper", "docstring": "Decorator to check the range of interpolated kicks" }, { "code": "def get_image_size(self, image):\n if image['size'] is None:\n args = settings.THUMBNAIL_VIPSHEADER.split(' ')\n args.append(image['source'])\n p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n p.wait()\n m = size_re.match(str(p.stdout.read()))\n image['size'] = int(m.group('x')), int(m.group('y'))\n return image['size']", "docstring": "Returns the image width and height as a tuple" }, { "code": "def get_as_parameters_with_default(self, key, default_value):\n result = self.get_as_nullable_parameters(key)\n return result if result != None else default_value", "docstring": "Converts map element into an Parameters or returns default value if conversion is not possible.\n\n :param key: a key of element to get.\n\n :param default_value: the default value\n\n :return: Parameters value of the element or default value if conversion is not supported." }, { "code": "def remove_listener(self, listener):\n internal_listener = self._internal_listeners.pop(listener)\n return self._client.remove_listener(internal_listener)", "docstring": "Remove the given listener from the wrapped client.\n\n :param listener: A listener previously passed to :meth:`add_listener`." }, { "code": "def get_narrow_url(self, instance):\n text = instance[0]\n request = self.context[\"request\"]\n query_params = request.GET.copy()\n page_query_param = self.get_paginate_by_param()\n if page_query_param and page_query_param in query_params:\n del query_params[page_query_param]\n selected_facets = set(query_params.pop(self.root.facet_query_params_text, []))\n selected_facets.add(\"%(field)s_exact:%(text)s\" % {\"field\": self.parent_field, \"text\": text})\n query_params.setlist(self.root.facet_query_params_text, sorted(selected_facets))\n path = \"%(path)s?%(query)s\" % {\"path\": request.path_info, \"query\": query_params.urlencode()}\n url = request.build_absolute_uri(path)\n return serializers.Hyperlink(url, \"narrow-url\")", "docstring": "Return a link suitable for narrowing on the current item." }, { "code": "def also_restrict_to(self, restriction):\n if type(restriction) != list:\n restriction = [ restriction ]\n self._also_restriction = restriction", "docstring": "Works like restict_to but offers an additional restriction. Playbooks use this\n to implement serial behavior." }, { "code": "def _convert_json(obj):\n if isinstance(obj, dict):\n return {_convert_json(key): _convert_json(val)\n for (key, val) in six.iteritems(obj)}\n elif isinstance(obj, list) and len(obj) == 2:\n first = obj[0]\n second = obj[1]\n if first == 'set' and isinstance(second, list):\n return [_convert_json(elem) for elem in second]\n elif first == 'map' and isinstance(second, list):\n for elem in second:\n if not isinstance(elem, list) or len(elem) != 2:\n return obj\n return {elem[0]: _convert_json(elem[1]) for elem in second}\n else:\n return obj\n elif isinstance(obj, list):\n return [_convert_json(elem) for elem in obj]\n else:\n return obj", "docstring": "Converts from the JSON output provided by ovs-vsctl into a usable Python\n object tree. In particular, sets and maps are converted from lists to\n actual sets or maps.\n\n Args:\n obj: Object that shall be recursively converted.\n\n Returns:\n Converted version of object." }, { "code": "def ex_varassign(name, expr):\n if not isinstance(expr, ast.expr):\n expr = ex_literal(expr)\n return ast.Assign([ex_lvalue(name)], expr)", "docstring": "Assign an expression into a single variable. The expression may\n either be an `ast.expr` object or a value to be used as a literal." }, { "code": "def _interpret_ltude(value, name, psuffix, nsuffix):\n if not isinstance(value, str):\n return Angle(degrees=_unsexagesimalize(value))\n value = value.strip().upper()\n if value.endswith(psuffix):\n sign = +1.0\n elif value.endswith(nsuffix):\n sign = -1.0\n else:\n raise ValueError('your {0} string {1!r} does not end with either {2!r}'\n ' or {3!r}'.format(name, value, psuffix, nsuffix))\n try:\n value = float(value[:-1])\n except ValueError:\n raise ValueError('your {0} string {1!r} cannot be parsed as a floating'\n ' point number'.format(name, value))\n return Angle(degrees=sign * value)", "docstring": "Interpret a string, float, or tuple as a latitude or longitude angle.\n\n `value` - The string to interpret.\n `name` - 'latitude' or 'longitude', for use in exception messages.\n `positive` - The string that indicates a positive angle ('N' or 'E').\n `negative` - The string that indicates a negative angle ('S' or 'W')." }, { "code": "def aroon_up(data, period):\n catch_errors.check_for_period_error(data, period)\n period = int(period)\n a_up = [((period -\n list(reversed(data[idx+1-period:idx+1])).index(np.max(data[idx+1-period:idx+1]))) /\n float(period)) * 100 for idx in range(period-1, len(data))]\n a_up = fill_for_noncomputable_vals(data, a_up)\n return a_up", "docstring": "Aroon Up.\n\n Formula:\n AROONUP = (((PERIOD) - (PERIODS since PERIOD high)) / (PERIOD)) * 100" }, { "code": "def _persist_metadata(self):\n serializable_data = self.get_serializable()\n try:\n self._try_persist_metadata(serializable_data)\n except TypeError:\n cleaned_data = Script._remove_non_serializable_store_entries(serializable_data[\"store\"])\n self._try_persist_metadata(cleaned_data)", "docstring": "Write all script meta-data, including the persistent script Store.\n The Store instance might contain arbitrary user data, like function objects, OpenCL contexts, or whatever other\n non-serializable objects, both as keys or values.\n Try to serialize the data, and if it fails, fall back to checking the store and removing all non-serializable\n data." }, { "code": "def get_transport_target(cls, instance, timeout, retries):\n if \"ip_address\" not in instance:\n raise Exception(\"An IP address needs to be specified\")\n ip_address = instance[\"ip_address\"]\n port = int(instance.get(\"port\", 161))\n return hlapi.UdpTransportTarget((ip_address, port), timeout=timeout, retries=retries)", "docstring": "Generate a Transport target object based on the instance's configuration" }, { "code": "def parse_datetime(record: str) -> Optional[datetime]:\n format_strings = {8: '%Y%m%d', 12: '%Y%m%d%H%M', 14: '%Y%m%d%H%M%S'}\n if record == '':\n return None\n return datetime.strptime(record.strip(),\n format_strings[len(record.strip())])", "docstring": "Parse a datetime string into a python datetime object" }, { "code": "def _start_lst_proc(self,\n listener_type,\n listener_opts):\n log.debug('Starting the listener process for %s', listener_type)\n listener = NapalmLogsListenerProc(self.opts,\n self.address,\n self.port,\n listener_type,\n listener_opts=listener_opts)\n proc = Process(target=listener.start)\n proc.start()\n proc.description = 'Listener process'\n log.debug('Started listener process as %s with PID %s', proc._name, proc.pid)\n return proc", "docstring": "Start the listener process." }, { "code": "def edit_matching_entry(program, arguments):\n entry = program.select_entry(*arguments)\n entry.context.execute(\"pass\", \"edit\", entry.name)", "docstring": "Edit the matching entry." }, { "code": "def _generate_manager(manager_config):\n if 'class' not in manager_config:\n raise ValueError(\n 'Manager not fully specified. Give '\n '\"class:manager_name\", e.g. \"class:MongoDBManager\".')\n mgr_class_name = manager_config['class']\n if mgr_class_name.lower()[:5] == 'mongo':\n from datafs.managers.manager_mongo import (\n MongoDBManager as mgr_class)\n elif mgr_class_name.lower()[:6] == 'dynamo':\n from datafs.managers.manager_dynamo import (\n DynamoDBManager as mgr_class)\n else:\n raise KeyError(\n 'Manager class \"{}\" not recognized. Choose from {}'.format(\n mgr_class_name, 'MongoDBManager or DynamoDBManager'))\n manager = mgr_class(\n *manager_config.get('args', []),\n **manager_config.get('kwargs', {}))\n return manager", "docstring": "Generate a manager from a manager_config dictionary\n\n Parameters\n ----------\n\n manager_config : dict\n Configuration with keys class, args, and kwargs\n used to generate a new datafs.manager object\n\n Returns\n -------\n\n manager : object\n datafs.managers.MongoDBManager or\n datafs.managers.DynamoDBManager object\n initialized with *args, **kwargs\n\n Examples\n --------\n\n Generate a dynamo manager:\n\n .. code-block:: python\n\n >>> mgr = APIConstructor._generate_manager({\n ... 'class': 'DynamoDBManager',\n ... 'kwargs': {\n ... 'table_name': 'data-from-yaml',\n ... 'session_args': {\n ... 'aws_access_key_id': \"access-key-id-of-your-choice\",\n ... 'aws_secret_access_key': \"secret-key-of-your-choice\"},\n ... 'resource_args': {\n ... 'endpoint_url':'http://localhost:8000/',\n ... 'region_name':'us-east-1'}\n ... }\n ... })\n >>>\n >>> from datafs.managers.manager_dynamo import DynamoDBManager\n >>> assert isinstance(mgr, DynamoDBManager)\n >>>\n >>> 'data-from-yaml' in mgr.table_names\n False\n >>> mgr.create_archive_table('data-from-yaml')\n >>> 'data-from-yaml' in mgr.table_names\n True\n >>> mgr.delete_table('data-from-yaml')" }, { "code": "def get_paths(self, theme, icon_size):\n _size_str = \"x\".join(map(str, icon_size))\n theme_path = get_program_path() + \"share\" + os.sep + \"icons\" + os.sep\n icon_path = theme_path + theme + os.sep + _size_str + os.sep\n action_path = icon_path + \"actions\" + os.sep\n toggle_path = icon_path + \"toggles\" + os.sep\n return theme_path, icon_path, action_path, toggle_path", "docstring": "Returns tuple of theme, icon, action and toggle paths" }, { "code": "def _handle_stderr_event(self, fd, events):\n assert fd == self.fd_stderr\n if events & self.ioloop.READ:\n if not self.headers_sent:\n payload = self.process.stderr.read()\n data = 'HTTP/1.1 500 Internal Server Error\\r\\nDate: %s\\r\\nContent-Length: %d\\r\\n\\r\\n' % (get_date_header(), len(payload))\n self.headers_sent = True\n data += payload\n else:\n logger.error(\"This should not happen (stderr)\")\n data = self.process.stderr.read()\n logger.debug('Sending stderr to client: %r', data)\n self.request.write(data)\n if events & self.ioloop.ERROR:\n logger.debug('Error on stderr')\n if not self.process.stderr.closed:\n self.process.stderr.close()\n self.ioloop.remove_handler(self.fd_stderr)\n return self._graceful_finish()", "docstring": "Eventhandler for stderr" }, { "code": "def set_published_date(self):\n try:\n self.published_date = self.soup.find('pubdate').string\n except AttributeError:\n self.published_date = None", "docstring": "Parses published date and set value" }, { "code": "def bluemix(cls, vcap_services, instance_name=None, service_name=None, **kwargs):\n service_name = service_name or 'cloudantNoSQLDB'\n try:\n service = CloudFoundryService(vcap_services,\n instance_name=instance_name,\n service_name=service_name)\n except CloudantException:\n raise CloudantClientException(103)\n if hasattr(service, 'iam_api_key'):\n return Cloudant.iam(service.username,\n service.iam_api_key,\n url=service.url,\n **kwargs)\n return Cloudant(service.username,\n service.password,\n url=service.url,\n **kwargs)", "docstring": "Create a Cloudant session using a VCAP_SERVICES environment variable.\n\n :param vcap_services: VCAP_SERVICES environment variable\n :type vcap_services: dict or str\n :param str instance_name: Optional Bluemix instance name. Only required\n if multiple Cloudant instances are available.\n :param str service_name: Optional Bluemix service name.\n\n Example usage:\n\n .. code-block:: python\n\n import os\n from cloudant.client import Cloudant\n\n client = Cloudant.bluemix(os.getenv('VCAP_SERVICES'),\n 'Cloudant NoSQL DB')\n\n print client.all_dbs()" }, { "code": "def get_all_query_traces(self, max_wait_per=None, query_cl=ConsistencyLevel.LOCAL_ONE):\n if self._query_traces:\n return [self._get_query_trace(i, max_wait_per, query_cl) for i in range(len(self._query_traces))]\n return []", "docstring": "Fetches and returns the query traces for all query pages, if tracing was enabled.\n\n See note in :meth:`~.get_query_trace` regarding possible exceptions." }, { "code": "def intercept(actions: dict={}):\n for action in actions.values():\n if type(action) is not returns and type(action) is not raises:\n raise InterceptorError('Actions must be declared as `returns` or `raises`')\n def decorated(f):\n def wrapped(*args, **kargs):\n try:\n return f(*args, **kargs)\n except Exception as e:\n if e.__class__ in actions:\n return actions[e.__class__](e)\n else:\n raise\n return wrapped\n return decorated", "docstring": "Decorates a function and handles any exceptions that may rise.\n\n Args:\n actions: A dictionary ``: ``. Available actions\\\n are :class:`raises` and :class:`returns`.\n\n Returns:\n Any value declared using a :class:`returns` action.\n\n Raises:\n AnyException: if AnyException is declared together with a\n :class:`raises` action.\n InterceptorError: if the decorator is called with something different\n from a :class:`returns` or :class:`raises` action.\n\n Interceptors can be declared inline to return a value or raise an exception\n when the declared exception is risen:\n\n >>> @intercept({\n ... TypeError: returns('intercepted!')\n ... })\n ... def fails(foo):\n ... if foo:\n ... raise TypeError('inner exception')\n ... return 'ok'\n >>> fails(False)\n 'ok'\n >>> fails(True)\n 'intercepted!'\n\n >>> @intercept({\n ... TypeError: raises(Exception('intercepted!'))\n ... })\n ... def fail():\n ... raise TypeError('inner exception')\n >>> fail()\n Traceback (most recent call last):\n ...\n Exception: intercepted!\n\n But they can also be declared and then used later on:\n\n >>> intercept0r = intercept({\n ... TypeError: returns('intercepted!')\n ... })\n >>> @intercept0r\n ... def fail():\n ... raise TypeError('raising error')\n >>> fail()\n 'intercepted!'\n\n You can declare also an action that captures the risen exception by passing\n a callable to the action. This is useful to create a custom error message:\n\n >>> @intercept({\n ... TypeError: returns(lambda e: 'intercepted {}'.format(e))\n ... })\n ... def fail():\n ... raise TypeError('inner exception')\n >>> fail()\n 'intercepted inner exception'\n\n Or to convert captured exceptions into custom errors:\n\n >>> class CustomError(Exception):\n ... pass\n >>> @intercept({\n ... TypeError: raises(lambda e: CustomError(e))\n ... })\n ... def fail():\n ... raise TypeError('inner exception')\n >>> fail()\n Traceback (most recent call last):\n ...\n intercept.CustomError: inner exception" }, { "code": "def clear_copyright(self):\n if (self.get_copyright_metadata().is_read_only() or\n self.get_copyright_metadata().is_required()):\n raise errors.NoAccess()\n self._my_map['copyright'] = dict(self._copyright_default)", "docstring": "Removes the copyright.\n\n raise: NoAccess - ``Metadata.isRequired()`` is ``true`` or\n ``Metadata.isReadOnly()`` is ``true``\n *compliance: mandatory -- This method must be implemented.*" }, { "code": "def _evaluate_dimension_fields(self) -> bool:\n for _, item in self._dimension_fields.items():\n item.run_evaluate()\n if item.eval_error:\n return False\n return True", "docstring": "Evaluates the dimension fields. Returns False if any of the fields could not be evaluated." }, { "code": "def findLowest(self, symorders):\n _range = range(len(symorders))\n stableSymorders = map(None, symorders, _range)\n stableSymorders.sort()\n lowest = None\n for index in _range:\n if stableSymorders[index][0] == lowest:\n return stableSymorders[index-1][1]\n lowest = stableSymorders[index][0]\n return -1", "docstring": "Find the position of the first lowest tie in a\n symorder or -1 if there are no ties" }, { "code": "def vae(x, z_size, name=None):\n with tf.variable_scope(name, default_name=\"vae\"):\n mu = tf.layers.dense(x, z_size, name=\"mu\")\n log_sigma = tf.layers.dense(x, z_size, name=\"log_sigma\")\n shape = common_layers.shape_list(x)\n epsilon = tf.random_normal([shape[0], shape[1], 1, z_size])\n z = mu + tf.exp(log_sigma / 2) * epsilon\n kl = 0.5 * tf.reduce_mean(\n tf.expm1(log_sigma) + tf.square(mu) - log_sigma, axis=-1)\n free_bits = z_size // 4\n kl_loss = tf.reduce_mean(tf.maximum(kl - free_bits, 0.0))\n return z, kl_loss, mu, log_sigma", "docstring": "Simple variational autoencoder without discretization.\n\n Args:\n x: Input to the discretization bottleneck.\n z_size: Number of bits, where discrete codes range from 1 to 2**z_size.\n name: Name for the bottleneck scope.\n\n Returns:\n Embedding function, latent, loss, mu and log_simga." }, { "code": "def inv(self):\n self.v = 1/self.v\n tmp = self.v**2\n if self.deriv > 1:\n self.dd[:] = tmp*(2*self.v*np.outer(self.d, self.d) - self.dd)\n if self.deriv > 0:\n self.d[:] = -tmp*self.d[:]", "docstring": "In place invert" }, { "code": "def get_subgraph_by_edge_filter(graph, edge_predicates: Optional[EdgePredicates] = None):\n rv = graph.fresh_copy()\n expand_by_edge_filter(graph, rv, edge_predicates=edge_predicates)\n return rv", "docstring": "Induce a sub-graph on all edges that pass the given filters.\n\n :param pybel.BELGraph graph: A BEL graph\n :param edge_predicates: An edge predicate or list of edge predicates\n :return: A BEL sub-graph induced over the edges passing the given filters\n :rtype: pybel.BELGraph" }, { "code": "def readAltWCS(fobj, ext, wcskey=' ', verbose=False):\n if isinstance(fobj, str):\n fobj = fits.open(fobj, memmap=False)\n hdr = altwcs._getheader(fobj, ext)\n try:\n original_logging_level = log.level\n log.setLevel(logutil.logging.WARNING)\n nwcs = pywcs.WCS(hdr, fobj=fobj, key=wcskey)\n except KeyError:\n if verbose:\n print('readAltWCS: Could not read WCS with key %s' % wcskey)\n print(' Skipping %s[%s]' % (fobj.filename(), str(ext)))\n return None\n finally:\n log.setLevel(original_logging_level)\n hwcs = nwcs.to_header()\n if nwcs.wcs.has_cd():\n hwcs = altwcs.pc2cd(hwcs, key=wcskey)\n return hwcs", "docstring": "Reads in alternate primary WCS from specified extension.\n\n Parameters\n ----------\n fobj : str, `astropy.io.fits.HDUList`\n fits filename or fits file object\n containing alternate/primary WCS(s) to be converted\n wcskey : str\n [\" \",A-Z]\n alternate/primary WCS key that will be replaced by the new key\n ext : int\n fits extension number\n Returns\n -------\n hdr: fits.Header\n header object with ONLY the keywords for specified alternate WCS" }, { "code": "def _any_pandas_objects(terms):\n return any(isinstance(term.value, pd.core.generic.PandasObject)\n for term in terms)", "docstring": "Check a sequence of terms for instances of PandasObject." }, { "code": "def _get_batch_representative(items, key):\n if isinstance(items, dict):\n return items, items\n else:\n vals = set([])\n out = []\n for data in items:\n if key in data:\n vals.add(data[key])\n out.append(data)\n if len(vals) != 1:\n raise ValueError(\"Incorrect values for %s: %s\" % (key, list(vals)))\n return out[0], items", "docstring": "Retrieve a representative data item from a batch.\n\n Handles standard bcbio cases (a single data item) and CWL cases with\n batches that have a consistent variant file." }, { "code": "def _is_valid_function(module_name, function):\n try:\n functions = __salt__['sys.list_functions'](module_name)\n except salt.exceptions.SaltException:\n functions = [\"unable to look up functions\"]\n return \"{0}.{1}\".format(module_name, function) in functions", "docstring": "Determine if a function is valid for a module" }, { "code": "def _get_driver(self):\n ComputeEngine = get_driver(Provider.GCE)\n return ComputeEngine(\n self.service_account_email,\n self.service_account_file,\n project=self.service_account_project\n )", "docstring": "Get authenticated GCE driver." }, { "code": "def family_coff(self):\n if not self._ptr:\n raise BfdException(\"BFD not initialized\")\n return _bfd.get_bfd_attribute(self._ptr, BfdAttributes.FAMILY_COFF)", "docstring": "Return the family_coff attribute of the BFD file being processed." }, { "code": "def check_padding_around_mutation(given_padding, epitope_lengths):\n min_required_padding = max(epitope_lengths) - 1\n if not given_padding:\n return min_required_padding\n else:\n require_integer(given_padding, \"Padding around mutation\")\n if given_padding < min_required_padding:\n raise ValueError(\n \"Padding around mutation %d cannot be less than %d \"\n \"for epitope lengths %s\" % (\n given_padding,\n min_required_padding,\n epitope_lengths))\n return given_padding", "docstring": "If user doesn't provide any padding around the mutation we need\n to at least include enough of the surrounding non-mutated\n esidues to construct candidate epitopes of the specified lengths." }, { "code": "def extract(path_to_hex, output_path=None):\n with open(path_to_hex, 'r') as hex_file:\n python_script = extract_script(hex_file.read())\n if output_path:\n with open(output_path, 'w') as output_file:\n output_file.write(python_script)\n else:\n print(python_script)", "docstring": "Given a path_to_hex file this function will attempt to extract the\n embedded script from it and save it either to output_path or stdout" }, { "code": "def remove_cycle_mrkr(self):\n window_start = self.parent.value('window_start')\n try:\n self.annot.remove_cycle_mrkr(window_start)\n except KeyError:\n msg = ('The start of the window does not correspond to any cycle '\n 'marker in sleep scoring file')\n self.parent.statusBar().showMessage(msg)\n lg.debug(msg)\n else:\n lg.debug('User removed cycle marker at' + str(window_start))\n self.parent.overview.update(reset=False)\n self.parent.overview.display_annotations()", "docstring": "Remove cycle marker." }, { "code": "def set_type(spec, obj_type):\n if spec is None:\n raise ValueError('Spec cannot be None')\n if TemplateFields.generation not in spec:\n spec[TemplateFields.generation] = {}\n spec[TemplateFields.generation][TemplateFields.commkey] = \\\n Gen.CLIENT if (obj_type & (int(1) << TemplateFields.FLAG_COMM_GEN)) > 0 else Gen.LEGACY_RANDOM\n spec[TemplateFields.generation][TemplateFields.appkey] = \\\n Gen.CLIENT if (obj_type & (int(1) << TemplateFields.FLAG_APP_GEN)) > 0 else Gen.LEGACY_RANDOM\n spec[TemplateFields.type] = \"%x\" % obj_type\n return spec", "docstring": "Updates type integer in the cerate UO specification.\n Type has to already have generations flags set correctly.\n Generation field is set accordingly.\n\n :param spec:\n :param obj_type:\n :return:" }, { "code": "def load_from_file(filename):\n if os.path.isdir(filename):\n logger.error(\"Err: File '%s' is a directory\", filename)\n return None\n if not os.path.isfile(filename):\n logger.error(\"Err: File '%s' does not exist\", filename)\n return None\n try:\n with open(filename, 'r') as sourcefile:\n songs = [line.strip() for line in sourcefile]\n except IOError as error:\n logger.exception(error)\n return None\n songs = set(Song.from_filename(song) for song in songs)\n return songs.difference({None})", "docstring": "Load a list of filenames from an external text file." }, { "code": "def convert(self, value, view):\n if isinstance(value, int):\n return value\n elif isinstance(value, float):\n return int(value)\n else:\n self.fail(u'must be a number', view, True)", "docstring": "Check that the value is an integer. Floats are rounded." }, { "code": "def build_full_toctree(builder, docname, prune, collapse):\n env = builder.env\n doctree = env.get_doctree(env.config.master_doc)\n toctrees = []\n for toctreenode in doctree.traverse(addnodes.toctree):\n toctree = env.resolve_toctree(docname, builder, toctreenode,\n collapse=collapse,\n prune=prune,\n )\n toctrees.append(toctree)\n if not toctrees:\n return None\n result = toctrees[0]\n for toctree in toctrees[1:]:\n if toctree:\n result.extend(toctree.children)\n env.resolve_references(result, docname, builder)\n return result", "docstring": "Return a single toctree starting from docname containing all\n sub-document doctrees." }, { "code": "def rename(self, name):\n if name:\n rename1, rename2 = callbacks.add(\n b'rename', self.change_name, False)\n self.dispatch_command(b'/bin/echo \"' + rename1 + b'\"\"' + rename2 +\n b'\"' + name + b'\\n')\n else:\n self.change_name(self.hostname.encode())", "docstring": "Send to the remote shell, its new name to be shell expanded" }, { "code": "def expand_dataset(X, y_proba, factor=10, random_state=None, extra_arrays=None):\n rng = check_random_state(random_state)\n extra_arrays = extra_arrays or []\n n_classes = y_proba.shape[1]\n classes = np.arange(n_classes, dtype=int)\n for el in zip(X, y_proba, *extra_arrays):\n x, probs = el[0:2]\n rest = el[2:]\n for label in rng.choice(classes, size=factor, p=probs):\n yield (x, label) + rest", "docstring": "Convert a dataset with float multiclass probabilities to a dataset\n with indicator probabilities by duplicating X rows and sampling\n true labels." }, { "code": "def schema(self):\n if not self._schema:\n try:\n self._load_info()\n self._schema = _schema.Schema(self._info['schema']['fields'])\n except KeyError:\n raise Exception('Unexpected table response: missing schema')\n return self._schema", "docstring": "Retrieves the schema of the table.\n\n Returns:\n A Schema object containing a list of schema fields and associated metadata.\n Raises\n Exception if the request could not be executed or the response was malformed." }, { "code": "def patch_sys_version():\n if '|' in sys.version:\n sys_version = sys.version.split('|')\n sys.version = ' '.join([sys_version[0].strip(), sys_version[-1].strip()])", "docstring": "Remove Continuum copyright statement to avoid parsing errors in IDLE" }, { "code": "def is_installed(self, name: str) -> bool:\n assert name is not None\n try:\n self.__docker.images.get(name)\n return True\n except docker.errors.ImageNotFound:\n return False", "docstring": "Indicates a given Docker image is installed on this server.\n\n Parameters:\n name: the name of the Docker image.\n\n Returns:\n `True` if installed; `False` if not." }, { "code": "def _get_by_index(self, index):\n volume_or_disk = self.parser.get_by_index(index)\n volume, disk = (volume_or_disk, None) if not isinstance(volume_or_disk, Disk) else (None, volume_or_disk)\n return volume, disk", "docstring": "Returns a volume,disk tuple for the specified index" }, { "code": "def start(self):\n self._timer = Timer(self.time, self.handler)\n self._timer.daemon = True\n self._timer.start()\n return", "docstring": "Starts the watchdog timer." }, { "code": "def redirect_to(request, url, permanent=True, query_string=False, **kwargs):\n r\n args = request.META.get('QUERY_STRING', '')\n if url is not None:\n if kwargs:\n url = url % kwargs\n if args and query_string:\n url = \"%s?%s\" % (url, args)\n klass = (permanent and HttpResponsePermanentRedirect\n or HttpResponseRedirect)\n return klass(url)\n else:\n logger.warning(\n 'Gone: %s',\n request.path,\n extra={\n 'status_code': 410,\n 'request': request\n })\n return HttpResponseGone()", "docstring": "r\"\"\"\n Redirect to a given URL.\n\n The given url may contain dict-style string formatting, which will be\n interpolated against the params in the URL. For example, to redirect from\n ``/foo//`` to ``/bar//``, you could use the following URLconf::\n\n urlpatterns = patterns('',\n (r'^foo/(?P\\d+)/$',\n 'django.views.generic.simple.redirect_to',\n {'url' : '/bar/%(id)s/'}),\n )\n\n If the given url is ``None``, a HttpResponseGone (410) will be issued.\n\n If the ``permanent`` argument is False, then the response will have a 302\n HTTP status code. Otherwise, the status code will be 301.\n\n If the ``query_string`` argument is True, then the GET query string\n from the request is appended to the URL." }, { "code": "def update_content_encoding(self, data: Any) -> None:\n if not data:\n return\n enc = self.headers.get(hdrs.CONTENT_ENCODING, '').lower()\n if enc:\n if self.compress:\n raise ValueError(\n 'compress can not be set '\n 'if Content-Encoding header is set')\n elif self.compress:\n if not isinstance(self.compress, str):\n self.compress = 'deflate'\n self.headers[hdrs.CONTENT_ENCODING] = self.compress\n self.chunked = True", "docstring": "Set request content encoding." }, { "code": "def find_op_code_sequence(pattern: list, instruction_list: list) -> Generator:\n for i in range(0, len(instruction_list) - len(pattern) + 1):\n if is_sequence_match(pattern, instruction_list, i):\n yield i", "docstring": "Returns all indices in instruction_list that point to instruction\n sequences following a pattern.\n\n :param pattern: The pattern to look for, e.g. [[\"PUSH1\", \"PUSH2\"], [\"EQ\"]] where [\"PUSH1\", \"EQ\"] satisfies pattern\n :param instruction_list: List of instructions to look in\n :return: Indices to the instruction sequences" }, { "code": "def detailed_tokens(tokenizer, text):\n node = tokenizer.parseToNode(text)\n node = node.next\n words = []\n while node.posid != 0:\n surface = node.surface\n base = surface\n parts = node.feature.split(\",\")\n pos = \",\".join(parts[0:4])\n if len(parts) > 7:\n base = parts[7]\n words.append(ShortUnitWord(surface, base, pos))\n node = node.next\n return words", "docstring": "Format Mecab output into a nice data structure, based on Janome." }, { "code": "def SamplingRoundAddedEventHandler(instance, event):\n if instance.portal_type != \"SamplingRound\":\n print(\"How does this happen: type is %s should be SamplingRound\" % instance.portal_type)\n return\n renameAfterCreation(instance)\n num_art = len(instance.ar_templates)\n destination_url = instance.aq_parent.absolute_url() + \\\n \"/portal_factory/\" + \\\n \"AnalysisRequest/Request new analyses/ar_add?samplinground=\" + \\\n instance.UID() + \"&ar_count=\" + str(num_art)\n request = getattr(instance, 'REQUEST', None)\n request.response.redirect(destination_url)", "docstring": "Event fired when BikaSetup object gets modified.\n Since Sampling Round is a dexterity object we have to change the ID by \"hand\"\n Then we have to redirect the user to the ar add form" }, { "code": "def forward(self, inputs, label, begin_state, sampled_values):\n encoded = self.embedding(inputs)\n length = inputs.shape[0]\n batch_size = inputs.shape[1]\n encoded, out_states = self.encoder.unroll(length, encoded, begin_state,\n layout='TNC', merge_outputs=True)\n out, new_target = self.decoder(encoded, sampled_values, label)\n out = out.reshape((length, batch_size, -1))\n new_target = new_target.reshape((length, batch_size))\n return out, out_states, new_target", "docstring": "Defines the forward computation.\n\n Parameters\n -----------\n inputs : NDArray\n input tensor with shape `(sequence_length, batch_size)`\n when `layout` is \"TNC\".\n begin_state : list\n initial recurrent state tensor with length equals to num_layers*2.\n For each layer the two initial states have shape `(batch_size, num_hidden)`\n and `(batch_size, num_projection)`\n sampled_values : list\n a list of three tensors for `sampled_classes` with shape `(num_samples,)`,\n `expected_count_sampled` with shape `(num_samples,)`, and\n `expected_count_true` with shape `(sequence_length, batch_size)`.\n\n Returns\n --------\n out : NDArray\n output tensor with shape `(sequence_length, batch_size, 1+num_samples)`\n when `layout` is \"TNC\".\n out_states : list\n output recurrent state tensor with length equals to num_layers*2.\n For each layer the two initial states have shape `(batch_size, num_hidden)`\n and `(batch_size, num_projection)`\n new_target : NDArray\n output tensor with shape `(sequence_length, batch_size)`\n when `layout` is \"TNC\"." }, { "code": "def network_undefine(name, **kwargs):\n conn = __get_conn(**kwargs)\n try:\n net = conn.networkLookupByName(name)\n return not bool(net.undefine())\n finally:\n conn.close()", "docstring": "Remove a defined virtual network. This does not stop the virtual network.\n\n :param name: virtual network name\n :param connection: libvirt connection URI, overriding defaults\n :param username: username to connect with, overriding defaults\n :param password: password to connect with, overriding defaults\n\n .. versionadded:: 2019.2.0\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' virt.network_undefine default" }, { "code": "def get_path(self):\n md5_hash = hashlib.md5(self.task_id.encode()).hexdigest()\n logger.debug('Hash %s corresponds to task %s', md5_hash, self.task_id)\n return os.path.join(self.temp_dir, str(self.unique.value), md5_hash)", "docstring": "Returns a temporary file path based on a MD5 hash generated with the task's name and its arguments" }, { "code": "def queue_command(self, command):\n if self._running:\n QtCore.QCoreApplication.postEvent(\n self, ActionEvent(command), QtCore.Qt.LowEventPriority)\n else:\n self._incoming.append(command)", "docstring": "Put a command on the queue to be called in the component's\n thread.\n\n :param callable command: the method to be invoked, e.g.\n :py:meth:`~Component.new_frame_event`." }, { "code": "def _read_with_mask(raster, masked):\n if masked is None:\n mask_flags = raster.mask_flag_enums\n per_dataset_mask = all([rasterio.enums.MaskFlags.per_dataset in flags for flags in mask_flags])\n masked = per_dataset_mask\n return masked", "docstring": "returns if we should read from rasterio using the masked" }, { "code": "def parse_date(date: str, hour_threshold: int = 200):\n date = date.strip('Z')\n if len(date) == 4:\n date += '00'\n if not (len(date) == 6 and date.isdigit()):\n return\n now = datetime.utcnow()\n guess = now.replace(day=int(date[0:2]),\n hour=int(date[2:4]) % 24,\n minute=int(date[4:6]) % 60,\n second=0, microsecond=0)\n hourdiff = (guess - now) / timedelta(minutes=1) / 60\n if hourdiff > hour_threshold:\n guess += relativedelta(months=-1)\n elif hourdiff < -hour_threshold:\n guess += relativedelta(months=+1)\n return guess", "docstring": "Parses a report timestamp in ddhhZ or ddhhmmZ format\n\n This function assumes the given timestamp is within the hour threshold from current date" }, { "code": "def _unicode_sub_super(string, mapping, max_len=None):\n string = str(string)\n if string.startswith('(') and string.endswith(')'):\n len_string = len(string) - 2\n else:\n len_string = len(string)\n if max_len is not None:\n if len_string > max_len:\n raise KeyError(\"max_len exceeded\")\n unicode_letters = []\n for letter in string:\n unicode_letters.append(mapping[letter])\n return ''.join(unicode_letters)", "docstring": "Try to render a subscript or superscript string in unicode, fall back on\n ascii if this is not possible" }, { "code": "def function_to_serializable_representation(fn):\n if type(fn) not in (FunctionType, BuiltinFunctionType):\n raise ValueError(\n \"Can't serialize %s : %s, must be globally defined function\" % (\n fn, type(fn),))\n if hasattr(fn, \"__closure__\") and fn.__closure__ is not None:\n raise ValueError(\"No serializable representation for closure %s\" % (fn,))\n return {\"__module__\": get_module_name(fn), \"__name__\": fn.__name__}", "docstring": "Converts a Python function into a serializable representation. Does not\n currently work for methods or functions with closure data." }, { "code": "def weighting(self, landscape=None):\n if landscape is not None:\n if len(landscape) > 0:\n maxy = np.max(landscape[:, 1])\n else: \n maxy = 1\n def linear(interval):\n d = interval[1]\n return (1 / maxy) * d if landscape is not None else d\n def pw_linear(interval):\n t = interval[1]\n b = maxy / self.ny\n if t <= 0:\n return 0\n if 0 < t < b:\n return t / b\n if b <= t:\n return 1\n return linear", "docstring": "Define a weighting function, \n for stability results to hold, the function must be 0 at y=0." }, { "code": "def from_name(cls, name):\n result = cls.list({'items_per_page': 500})\n webaccs = {}\n for webacc in result:\n webaccs[webacc['name']] = webacc['id']\n return webaccs.get(name)", "docstring": "Retrieve webacc id associated to a webacc name." }, { "code": "def set_config(self, config):\n if self.config is None:\n self.config = { }\n self.config.update(config_to_api_list(config))", "docstring": "Set the service configuration.\n\n @param config: A dictionary of config key/value" }, { "code": "def tnet_to_nx(df, t=None):\n if t is not None:\n df = get_network_when(df, t=t)\n if 'weight' in df.columns:\n nxobj = nx.from_pandas_edgelist(\n df, source='i', target='j', edge_attr='weight')\n else:\n nxobj = nx.from_pandas_edgelist(df, source='i', target='j')\n return nxobj", "docstring": "Creates undirected networkx object" }, { "code": "def get_substances(identifier, namespace='sid', as_dataframe=False, **kwargs):\n results = get_json(identifier, namespace, 'substance', **kwargs)\n substances = [Substance(r) for r in results['PC_Substances']] if results else []\n if as_dataframe:\n return substances_to_frame(substances)\n return substances", "docstring": "Retrieve the specified substance records from PubChem.\n\n :param identifier: The substance identifier to use as a search query.\n :param namespace: (optional) The identifier type, one of sid, name or sourceid/.\n :param as_dataframe: (optional) Automatically extract the :class:`~pubchempy.Substance` properties into a pandas\n :class:`~pandas.DataFrame` and return that." }, { "code": "def _ConvertAttributeContainerToDict(cls, attribute_container):\n if not isinstance(\n attribute_container, containers_interface.AttributeContainer):\n raise TypeError('{0:s} is not an attribute container type.'.format(\n type(attribute_container)))\n container_type = getattr(attribute_container, 'CONTAINER_TYPE', None)\n if not container_type:\n raise ValueError('Unsupported attribute container type: {0:s}.'.format(\n type(attribute_container)))\n json_dict = {\n '__type__': 'AttributeContainer',\n '__container_type__': container_type,\n }\n for attribute_name, attribute_value in attribute_container.GetAttributes():\n json_dict[attribute_name] = cls._ConvertAttributeValueToDict(\n attribute_value)\n return json_dict", "docstring": "Converts an attribute container object into a JSON dictionary.\n\n The resulting dictionary of the JSON serialized objects consists of:\n {\n '__type__': 'AttributeContainer'\n '__container_type__': ...\n ...\n }\n\n Here '__type__' indicates the object base type. In this case\n 'AttributeContainer'.\n\n '__container_type__' indicates the container type and rest of the elements\n of the dictionary make up the attributes of the container.\n\n Args:\n attribute_container (AttributeContainer): attribute container.\n\n Returns:\n dict[str, object]: JSON serialized objects.\n\n Raises:\n TypeError: if not an instance of AttributeContainer.\n ValueError: if the attribute container type is not supported." }, { "code": "def burst_range(psd, snr=8, energy=1e-2, fmin=100, fmax=500):\n freqs = psd.frequencies.value\n if not fmin:\n fmin = psd.f0\n if not fmax:\n fmax = psd.span[1]\n condition = (freqs >= fmin) & (freqs < fmax)\n integrand = burst_range_spectrum(\n psd[condition], snr=snr, energy=energy) ** 3\n result = integrate.trapz(integrand.value, freqs[condition])\n r = units.Quantity(result / (fmax - fmin), unit=integrand.unit) ** (1/3.)\n return r.to('Mpc')", "docstring": "Calculate the integrated GRB-like GW burst range from a strain PSD\n\n Parameters\n ----------\n psd : `~gwpy.frequencyseries.FrequencySeries`\n the instrumental power-spectral-density data\n\n snr : `float`, optional\n the signal-to-noise ratio for which to calculate range,\n default: ``8``\n\n energy : `float`, optional\n the relative energy output of the GW burst, defaults to ``1e-2``\n for a GRB-like burst\n\n fmin : `float`, optional\n the lower frequency cutoff of the burst range integral,\n default: ``100 Hz``\n\n fmax : `float`, optional\n the upper frequency cutoff of the burst range integral,\n default: ``500 Hz``\n\n Returns\n -------\n range : `~astropy.units.Quantity`\n the GRB-like-burst sensitive range [Mpc (default)]\n\n Examples\n --------\n Grab some data for LIGO-Livingston around GW150914 and generate a PSD\n\n >>> from gwpy.timeseries import TimeSeries\n >>> hoft = TimeSeries.fetch_open_data('H1', 1126259446, 1126259478)\n >>> hoff = hoft.psd(fftlength=4)\n\n Now we can calculate the :func:`burst_range`:\n\n >>> from gwpy.astro import burst_range\n >>> r = burst_range(hoff, fmin=30)\n >>> print(r)\n 42.5055584195 Mpc" }, { "code": "def int_dp_g(arr, dp):\n return integrate(arr, to_pascal(dp, is_dp=True),\n vert_coord_name(dp)) / GRAV_EARTH", "docstring": "Mass weighted integral." }, { "code": "def add_nodes(self, coors, node_low_or_high=None):\n last = self.lastnode\n if type(coors) is nm.ndarray:\n if len(coors.shape) == 1:\n coors = coors.reshape((1, coors.size))\n nadd = coors.shape[0]\n idx = slice(last, last + nadd)\n else:\n nadd = 1\n idx = self.lastnode\n right_dimension = coors.shape[1]\n self.nodes[idx, :right_dimension] = coors\n self.node_flag[idx] = True\n self.lastnode += nadd\n self.nnodes += nadd", "docstring": "Add new nodes at the end of the list." }, { "code": "def dropout_mask(x:Tensor, sz:Collection[int], p:float):\n \"Return a dropout mask of the same type as `x`, size `sz`, with probability `p` to cancel an element.\"\n return x.new(*sz).bernoulli_(1-p).div_(1-p)", "docstring": "Return a dropout mask of the same type as `x`, size `sz`, with probability `p` to cancel an element." }, { "code": "def declare_config_variable(self, name, config_id, type_name, default=None, convert=None):\n config = ConfigDescriptor(config_id, type_name, default, name=name, python_type=convert)\n self._config_variables[config_id] = config", "docstring": "Declare a config variable that this emulated tile accepts.\n\n The default value (if passed) may be specified as either a `bytes`\n object or a python int or list of ints. If an int or list of ints is\n passed, it is converted to binary. Otherwise, the raw binary data is\n used.\n\n Passing a unicode string is only allowed if as_string is True and it\n will be encoded as utf-8 and null terminated for use as a default value.\n\n Args:\n name (str): A user friendly name for this config variable so that it can\n be printed nicely.\n config_id (int): A 16-bit integer id number to identify the config variable.\n type_name (str): An encoded type name that will be parsed by parse_size_name()\n default (object): The default value if there is one. This should be a\n python object that will be converted to binary according to the rules for\n the config variable type specified in type_name.\n convert (str): whether this variable should be converted to a\n python string or bool rather than an int or a list of ints. You can\n pass either 'bool', 'string' or None" }, { "code": "def attr_to_path(node):\n def get_intrinsic_path(modules, attr):\n if isinstance(attr, ast.Name):\n return modules[demangle(attr.id)], (demangle(attr.id),)\n elif isinstance(attr, ast.Attribute):\n module, path = get_intrinsic_path(modules, attr.value)\n return module[attr.attr], path + (attr.attr,)\n obj, path = get_intrinsic_path(MODULES, node)\n if not obj.isliteral():\n path = path[:-1] + ('functor', path[-1])\n return obj, ('pythonic', ) + path", "docstring": "Compute path and final object for an attribute node" }, { "code": "def get_authorizations_by_ids(self, authorization_ids):\n collection = JSONClientValidated('authorization',\n collection='Authorization',\n runtime=self._runtime)\n object_id_list = []\n for i in authorization_ids:\n object_id_list.append(ObjectId(self._get_id(i, 'authorization').get_identifier()))\n result = collection.find(\n dict({'_id': {'$in': object_id_list}},\n **self._view_filter()))\n result = list(result)\n sorted_result = []\n for object_id in object_id_list:\n for object_map in result:\n if object_map['_id'] == object_id:\n sorted_result.append(object_map)\n break\n return objects.AuthorizationList(sorted_result, runtime=self._runtime, proxy=self._proxy)", "docstring": "Gets an ``AuthorizationList`` corresponding to the given ``IdList``.\n\n In plenary mode, the returned list contains all of the\n authorizations specified in the ``Id`` list, in the order of the\n list, including duplicates, or an error results if an ``Id`` in\n the supplied list is not found or inaccessible. Otherwise,\n inaccessible ``Authorizations`` may be omitted from the list and\n may present the elements in any order including returning a\n unique set.\n\n arg: authorization_ids (osid.id.IdList): the list of ``Ids``\n to retrieve\n return: (osid.authorization.AuthorizationList) - the returned\n ``Authorization list``\n raise: NotFound - an ``Id was`` not found\n raise: NullArgument - ``authorization_ids`` is ``null``\n raise: OperationFailed - unable to complete request\n raise: PermissionDenied - authorization failure\n *compliance: mandatory -- This method must be implemented.*" }, { "code": "def has_scope(context=None):\n if not booted(context):\n return False\n _sd_version = version(context)\n if _sd_version is None:\n return False\n return _sd_version >= 205", "docstring": "Scopes were introduced in systemd 205, this function returns a boolean\n which is true when the minion is systemd-booted and running systemd>=205." }, { "code": "def read(self, document, iface, *args, **kwargs):\n try:\n document = IReadableDocument(document)\n mime_type = document.mime_type\n reader = self.lookup_reader(mime_type, iface)\n if not reader:\n msg = (\"No adapter found to read object %s from %s document\"\n % (iface.__class__.__name__, mime_type))\n raise NoReaderFoundError(msg)\n return reader.read(document, *args, **kwargs)\n except:\n return defer.fail(Failure())", "docstring": "Returns a Deferred that fire the read object." }, { "code": "def AgregarReceptor(self, cuit, iibb, nro_socio, nro_fet, **kwargs):\n \"Agrego un receptor a la liq.\"\n rcpt = dict(cuit=cuit, iibb=iibb, nroSocio=nro_socio, nroFET=nro_fet)\n self.solicitud['receptor'] = rcpt\n return True", "docstring": "Agrego un receptor a la liq." }, { "code": "def strip_HETATMs(self, only_strip_these_chains = []):\n if only_strip_these_chains:\n self.lines = [l for l in self.lines if not(l.startswith('HETATM')) or l[21] not in only_strip_these_chains]\n else:\n self.lines = [l for l in self.lines if not(l.startswith('HETATM'))]\n self._update_structure_lines()", "docstring": "Throw away all HETATM lines. If only_strip_these_chains is specified then only strip HETATMs lines for those chains." }, { "code": "def contact_methods(self, **kwargs):\n endpoint = '{0}/{1}/contact_methods'.format(\n self.endpoint,\n self['id'],\n )\n result = self.request('GET', endpoint=endpoint, query_params=kwargs)\n return result['contact_methods']", "docstring": "Get all contact methods for this user." }, { "code": "def transform(self, X=None, y=None):\n zoom_x, zoom_y= self.zoom\n self.params = (zoom_x, zoom_y)\n zoom_matrix = np.array([[zoom_x, 0, 0],\n [0, zoom_y, 0]])\n self.tx.set_parameters(zoom_matrix)\n if self.lazy or X is None:\n return self.tx\n else:\n return self.tx.apply_to_image(X, reference=self.reference)", "docstring": "Transform an image using an Affine transform with the given\n zoom parameters. Return the transform if X=None.\n\n Arguments\n ---------\n X : ANTsImage\n Image to transform\n\n y : ANTsImage (optional)\n Another image to transform\n\n Returns\n -------\n ANTsImage if y is None, else a tuple of ANTsImage types\n\n Examples\n --------\n >>> import ants\n >>> img = ants.image_read(ants.get_data('r16'))\n >>> tx = ants.contrib.Zoom2D(zoom=(0.8,0.8,0.8))\n >>> img2 = tx.transform(img)" }, { "code": "def issequence(arg):\n string_behaviour = (\n isinstance(arg, six.string_types) or\n isinstance(arg, six.text_type))\n list_behaviour = hasattr(arg, '__getitem__') or hasattr(arg, '__iter__')\n return not string_behaviour and list_behaviour", "docstring": "Return True if `arg` acts as a list and does not look like a string." }, { "code": "def put_name(self, type_, id_, name):\n cachefile = self.filename(type_, id_)\n dirname = os.path.dirname(cachefile)\n try:\n os.makedirs(dirname)\n except OSError as e:\n if e.errno != errno.EEXIST:\n raise\n with open(cachefile, 'w') as f:\n f.write(name)", "docstring": "Write a cached name to disk.\n\n :param type_: str, \"user\" or \"tag\"\n :param id_: int, eg. 123456\n :returns: None" }, { "code": "def get_ip6_address(interface_name, expand=False):\n address = _get_address(interface_name, IP6_PATTERN)\n if address and expand:\n return ':'.join(_expand_groups(address))\n return address", "docstring": "Extracts the IPv6 address for a particular interface from `ifconfig`.\n\n :param interface_name: Name of the network interface (e.g. ``eth0``).\n :type interface_name: unicode\n :param expand: If set to ``True``, an abbreviated address is expanded to the full address.\n :type expand: bool\n :return: IPv6 address; ``None`` if the interface is present but no address could be extracted.\n :rtype: unicode" }, { "code": "def close(self):\n if self._socket is not None and self._conn is not None:\n message_input = UnityMessage()\n message_input.header.status = 400\n self._communicator_send(message_input.SerializeToString())\n if self._socket is not None:\n self._socket.close()\n self._socket = None\n if self._socket is not None:\n self._conn.close()\n self._conn = None", "docstring": "Sends a shutdown signal to the unity environment, and closes the socket connection." }, { "code": "def get_remote_file(self, remote_path, local_path):\n sftp_client = self.transport.open_sftp_client()\n LOG.debug('Get the remote file. '\n 'Source=%(src)s. Target=%(target)s.' %\n {'src': remote_path, 'target': local_path})\n try:\n sftp_client.get(remote_path, local_path)\n except Exception as ex:\n LOG.error('Failed to secure copy. Reason: %s.' %\n six.text_type(ex))\n raise SFtpExecutionError(err=ex)", "docstring": "Fetch remote File.\n\n :param remote_path: remote path\n :param local_path: local path" }, { "code": "def GetAll(alias=None,location=None,session=None):\n\t\tif not alias: alias = clc.v2.Account.GetAlias(session=session)\n\t\tpolicies = []\n\t\tpolicy_resp = clc.v2.API.Call('GET','antiAffinityPolicies/%s' % alias,{},session=session)\n\t\tfor k in policy_resp:\n\t\t\tr_val = policy_resp[k]\n\t\t\tfor r in r_val:\n\t\t\t\tif r.get('location'):\n\t\t\t\t\tif location and r['location'].lower()!=location.lower(): continue\n\t\t\t\t\tservers = [obj['id'] for obj in r['links'] if obj['rel'] == \"server\"]\n\t\t\t\t\tpolicies.append(AntiAffinity(id=r['id'],name=r['name'],location=r['location'],servers=servers,session=session))\n\t\treturn(policies)", "docstring": "Gets a list of anti-affinity policies within a given account.\n\n\t\thttps://t3n.zendesk.com/entries/44657214-Get-Anti-Affinity-Policies\n\n\t\t>>> clc.v2.AntiAffinity.GetAll()\n\t\t[, ]" }, { "code": "def generateCertificate(self, alias,\n commonName, organizationalUnit,\n city, state, country,\n keyalg=\"RSA\", keysize=1024,\n sigalg=\"SHA256withRSA\",\n validity=90\n ):\n params = {\"f\" : \"json\",\n \"alias\" : alias,\n \"commonName\" : commonName,\n \"organizationalUnit\" : organizationalUnit,\n \"city\" : city,\n \"state\" : state,\n \"country\" : country,\n \"keyalg\" : keyalg,\n \"keysize\" : keysize,\n \"sigalg\" : sigalg,\n \"validity\" : validity\n }\n url = self._url + \"/SSLCertificate/ generateCertificate\"\n return self._post(url=url,\n param_dict=params,\n proxy_port=self._proxy_port,\n proxy_url=self._proxy_url)", "docstring": "Use this operation to create a self-signed certificate or as a\n starting point for getting a production-ready CA-signed\n certificate. The portal will generate a certificate for you and\n store it in its keystore." }, { "code": "def _fetch_dimensions(self, dataset):\n yield Dimension(u\"school\")\n yield Dimension(u\"year\",\n datatype=\"year\")\n yield Dimension(u\"semester\",\n datatype=\"academic_term\",\n dialect=\"swedish\")\n yield Dimension(u\"municipality\",\n datatype=\"year\",\n domain=\"sweden/municipalities\")", "docstring": "Iterate through semesters, counties and municipalities." }, { "code": "def _handle_config(self, data):\n self.room.config.update(data)\n self.conn.enqueue_data(\"config\", data)", "docstring": "Handle initial config push and config changes" }, { "code": "def pkg_supports(feature, pkg_version, pkg_feat_dict):\n from pkg_resources import parse_requirements\n feature = str(feature)\n pkg_version = str(pkg_version)\n supp_versions = pkg_feat_dict.get(feature, None)\n if supp_versions is None:\n return False\n if is_string(supp_versions):\n supp_versions = [supp_versions]\n ver_specs = ['pkg' + supp_ver for supp_ver in supp_versions]\n ver_reqs = [list(parse_requirements(ver_spec))[0]\n for ver_spec in ver_specs]\n for req in ver_reqs:\n if req.specifier.contains(pkg_version, prereleases=True):\n return True\n return False", "docstring": "Return bool indicating whether a package supports ``feature``.\n\n Parameters\n ----------\n feature : str\n Name of a potential feature of a package.\n pkg_version : str\n Version of the package that should be checked for presence of the\n feature.\n pkg_feat_dict : dict\n Specification of features of a package. Each item has the\n following form::\n\n feature_name: version_specification\n\n Here, ``feature_name`` is a string that is matched against\n ``feature``, and ``version_specification`` is a string or a\n sequence of strings that specifies version sets. These\n specifications are the same as for ``setuptools`` requirements,\n just without the package name.\n A ``None`` entry signals \"no support in any version\", i.e.,\n always ``False``.\n If a sequence of requirements are given, they are OR-ed together.\n See ``Examples`` for details.\n\n Returns\n -------\n supports : bool\n ``True`` if ``pkg_version`` of the package in question supports\n ``feature``, ``False`` otherwise.\n\n Examples\n --------\n >>> feat_dict = {\n ... 'feat1': '==0.5.1',\n ... 'feat2': '>0.6, <=0.9', # both required simultaneously\n ... 'feat3': ['>0.6', '<=0.9'], # only one required, i.e. always True\n ... 'feat4': ['==0.5.1', '>0.6, <=0.9'],\n ... 'feat5': None\n ... }\n >>> pkg_supports('feat1', '0.5.1', feat_dict)\n True\n >>> pkg_supports('feat1', '0.4', feat_dict)\n False\n >>> pkg_supports('feat2', '0.5.1', feat_dict)\n False\n >>> pkg_supports('feat2', '0.6.1', feat_dict)\n True\n >>> pkg_supports('feat2', '0.9', feat_dict)\n True\n >>> pkg_supports('feat2', '1.0', feat_dict)\n False\n >>> pkg_supports('feat3', '0.4', feat_dict)\n True\n >>> pkg_supports('feat3', '1.0', feat_dict)\n True\n >>> pkg_supports('feat4', '0.5.1', feat_dict)\n True\n >>> pkg_supports('feat4', '0.6', feat_dict)\n False\n >>> pkg_supports('feat4', '0.6.1', feat_dict)\n True\n >>> pkg_supports('feat4', '1.0', feat_dict)\n False\n >>> pkg_supports('feat5', '0.6.1', feat_dict)\n False\n >>> pkg_supports('feat5', '1.0', feat_dict)\n False" }, { "code": "def configured_class(cls):\n base = cls.configurable_base()\n if base.__dict__.get('_Configurable__impl_class') is None:\n base.__impl_class = cls.configurable_default()\n return base.__impl_class", "docstring": "Returns the currently configured class." }, { "code": "def _start_srv_proc(self,\n started_os_proc):\n log.debug('Starting the server process')\n server = NapalmLogsServerProc(self.opts,\n self.config_dict,\n started_os_proc,\n buffer=self._buffer)\n proc = Process(target=server.start)\n proc.start()\n proc.description = 'Server process'\n log.debug('Started server process as %s with PID %s', proc._name, proc.pid)\n return proc", "docstring": "Start the server process." }, { "code": "def progress_patch(self, _=False):\n from .progress import ShellProgressView\n self.cli_ctx.progress_controller.init_progress(ShellProgressView())\n return self.cli_ctx.progress_controller", "docstring": "forces to use the Shell Progress" }, { "code": "def _threaded_copy_data(instream, outstream):\n copy_thread = threading.Thread(target=_copy_data,\n args=(instream, outstream))\n copy_thread.setDaemon(True)\n log.debug('%r, %r, %r', copy_thread, instream, outstream)\n copy_thread.start()\n return copy_thread", "docstring": "Copy data from one stream to another in a separate thread.\n\n Wraps ``_copy_data()`` in a :class:`threading.Thread`.\n\n :type instream: :class:`io.BytesIO` or :class:`io.StringIO`\n :param instream: A byte stream to read from.\n :param file outstream: The file descriptor of a tmpfile to write to." }, { "code": "def _get_params(self):\n return np.hstack((self.varianceU,self.varianceY, self.lengthscaleU,self.lengthscaleY))", "docstring": "return the value of the parameters." }, { "code": "def handle_onchain_secretreveal(\n initiator_state: InitiatorTransferState,\n state_change: ContractReceiveSecretReveal,\n channel_state: NettingChannelState,\n pseudo_random_generator: random.Random,\n) -> TransitionResult[InitiatorTransferState]:\n iteration: TransitionResult[InitiatorTransferState]\n secret = state_change.secret\n secrethash = initiator_state.transfer_description.secrethash\n is_valid_secret = is_valid_secret_reveal(\n state_change=state_change,\n transfer_secrethash=secrethash,\n secret=secret,\n )\n is_channel_open = channel.get_status(channel_state) == CHANNEL_STATE_OPENED\n is_lock_expired = state_change.block_number > initiator_state.transfer.lock.expiration\n is_lock_unlocked = (\n is_valid_secret and\n not is_lock_expired\n )\n if is_lock_unlocked:\n channel.register_onchain_secret(\n channel_state=channel_state,\n secret=secret,\n secrethash=secrethash,\n secret_reveal_block_number=state_change.block_number,\n )\n if is_lock_unlocked and is_channel_open:\n events = events_for_unlock_lock(\n initiator_state,\n channel_state,\n state_change.secret,\n state_change.secrethash,\n pseudo_random_generator,\n )\n iteration = TransitionResult(None, events)\n else:\n events = list()\n iteration = TransitionResult(initiator_state, events)\n return iteration", "docstring": "When a secret is revealed on-chain all nodes learn the secret.\n\n This check the on-chain secret corresponds to the one used by the\n initiator, and if valid a new balance proof is sent to the next hop with\n the current lock removed from the merkle tree and the transferred amount\n updated." }, { "code": "def stop(self):\n self.logger.info('Stopping client fuzzer')\n self._target_control_thread.stop()\n self.target.signal_mutated()\n super(ClientFuzzer, self).stop()", "docstring": "Stop the fuzzing session" }, { "code": "def get_feed_renderer(engines, name):\n if name not in engines:\n raise FeedparserError(\"Given feed name '{}' does not exists in 'settings.FEED_RENDER_ENGINES'\".format(name))\n renderer = safe_import_module(engines[name])\n return renderer", "docstring": "From engine name, load the engine path and return the renderer class\n \n Raise 'FeedparserError' if any loading error" }, { "code": "def remove_files(self):\n file_list = [\"molecule.svg\",\"lig.pdb\",\"HIS.pdb\",\"PHE.pdb\",\"TRP.pdb\",\"TYR.pdb\",\"lig.mol\",\"test.xtc\"]\n for residue in self.topol_data.dict_of_plotted_res.keys():\n file_list.append(residue[1]+residue[2]+\".svg\")\n for f in file_list:\n if os.path.isfile(f)==True:\n os.remove(f)", "docstring": "Removes intermediate files." }, { "code": "def getAsWmsDatasetString(self, session):\n FIRST_VALUE_INDEX = 12\n if type(self.raster) != type(None):\n valueGrassRasterString = self.getAsGrassAsciiGrid(session)\n values = valueGrassRasterString.split()\n wmsDatasetString = ''\n for i in range(FIRST_VALUE_INDEX, len(values)):\n wmsDatasetString += '{0:.6f}\\r\\n'.format(float(values[i]))\n return wmsDatasetString\n else:\n wmsDatasetString = self.rasterText", "docstring": "Retrieve the WMS Raster as a string in the WMS Dataset format" }, { "code": "def delete_tags(self, archive_name, tags):\n updated_tag_list = list(self._get_tags(archive_name))\n for tag in tags:\n if tag in updated_tag_list:\n updated_tag_list.remove(tag)\n self._set_tags(archive_name, updated_tag_list)", "docstring": "Delete tags from an archive\n\n Parameters\n ----------\n archive_name:s tr\n Name of archive\n\n tags: list or tuple of strings\n tags to delete from the archive" }, { "code": "def add_user(bridge_user):\n resp = post_resource(admin_uid_url(None) +\n (\"?%s\" % CUSTOM_FIELD),\n json.dumps(bridge_user.to_json_post(),\n separators=(',', ':')))\n return _process_json_resp_data(resp, no_custom_fields=True)", "docstring": "Add the bridge_user given\n Return a list of BridgeUser objects with custom fields" }, { "code": "def get(self, path_or_index, default=None):\n err, value = self._resolve(path_or_index)\n value = default if err else value\n return err, value", "docstring": "Get details about a given result\n\n :param path_or_index: The path (or index) of the result to fetch.\n :param default: If the given result does not exist, return this value\n instead\n :return: A tuple of `(error, value)`. If the entry does not exist\n then `(err, default)` is returned, where `err` is the actual error\n which occurred.\n You can use :meth:`couchbase.exceptions.CouchbaseError.rc_to_exctype`\n to convert the error code to a proper exception class\n :raise: :exc:`IndexError` or :exc:`KeyError` if `path_or_index`\n is not an initially requested path. This is a programming error\n as opposed to a constraint error where the path is not found." }, { "code": "def followers_org_count(self):\n from udata.models import Follow\n return sum(Follow.objects(following=org).count()\n for org in self.organizations)", "docstring": "Return the number of followers of user's organizations." }, { "code": "def get(self, sid):\n return CertificateContext(self._version, fleet_sid=self._solution['fleet_sid'], sid=sid, )", "docstring": "Constructs a CertificateContext\n\n :param sid: A string that uniquely identifies the Certificate.\n\n :returns: twilio.rest.preview.deployed_devices.fleet.certificate.CertificateContext\n :rtype: twilio.rest.preview.deployed_devices.fleet.certificate.CertificateContext" }, { "code": "def updateSynapses(self, synapses, delta):\n reached0 = False\n if delta > 0:\n for synapse in synapses:\n self.syns[synapse][2] = newValue = self.syns[synapse][2] + delta\n if newValue > self.tp.permanenceMax:\n self.syns[synapse][2] = self.tp.permanenceMax\n else:\n for synapse in synapses:\n self.syns[synapse][2] = newValue = self.syns[synapse][2] + delta\n if newValue <= 0:\n self.syns[synapse][2] = 0\n reached0 = True\n return reached0", "docstring": "Update a set of synapses in the segment.\n\n @param tp The owner TP\n @param synapses List of synapse indices to update\n @param delta How much to add to each permanence\n\n @returns True if synapse reached 0" }, { "code": "def guessImageMetadataFromData(img_data):\n format, width, height = None, None, None\n img_stream = io.BytesIO(img_data)\n try:\n img = PIL.Image.open(img_stream)\n except IOError:\n format = imghdr.what(None, h=img_data)\n format = SUPPORTED_IMG_FORMATS.get(format, None)\n else:\n format = img.format.lower()\n format = SUPPORTED_IMG_FORMATS.get(format, None)\n width, height = img.size\n return format, width, height", "docstring": "Identify an image format and size from its first bytes." }, { "code": "def get_easter_monday(self, year):\n \"Return the date of the monday after easter\"\n sunday = self.get_easter_sunday(year)\n return sunday + timedelta(days=1)", "docstring": "Return the date of the monday after easter" }, { "code": "def sort_by_efficiency(self, reverse=True):\n self._confs.sort(key=lambda c: c.efficiency, reverse=reverse)\n return self", "docstring": "Sort the configurations in place. items with highest efficiency come first" }, { "code": "def on_connection_closed(self, connection, reply_code, reply_text):\n start_state = self.state\n self.state = self.STATE_CLOSED\n if self.on_unavailable:\n self.on_unavailable(self)\n self.connection = None\n self.channel = None\n if start_state != self.STATE_CLOSING:\n LOGGER.warning('%s closed while %s: (%s) %s',\n connection, self.state_description,\n reply_code, reply_text)\n self._reconnect()", "docstring": "This method is invoked by pika when the connection to RabbitMQ is\n closed unexpectedly. Since it is unexpected, we will reconnect to\n RabbitMQ if it disconnects.\n\n :param pika.TornadoConnection connection: Closed connection\n :param int reply_code: The server provided reply_code if given\n :param str reply_text: The server provided reply_text if given" }, { "code": "def _get_selectable(self):\n cursong = self.loop[self.song][0]\n if self.dif_song and len(cursong) > 1:\n s = cursong[0] + cursong[1]\n else:\n s = cursong[-1]\n return s", "docstring": "Used internally to get a group of choosable tracks." }, { "code": "def _get_component_from_result(self, result, lookup):\n for component in result['address_components']:\n if lookup['type'] in component['types']:\n return component.get(lookup['key'], '')\n return ''", "docstring": "Helper function to get a particular address component from a Google result.\n\n Since the address components in results are an array of objects containing a types array,\n we have to search for a particular component rather than being able to look it up directly.\n\n Returns the first match, so this should be used for unique component types (e.g.\n 'locality'), not for categories (e.g. 'political') that can describe multiple components.\n\n :arg dict result: A results dict with an 'address_components' key, as returned by the\n Google geocoder.\n :arg dict lookup: The type (e.g. 'street_number') and key ('short_name' or 'long_name') of\n the desired address component value.\n :returns: address component or empty string" }, { "code": "def set_colors(self, text='black', background='white'):\n if self._multiline: self._widget.setStyleSheet(\"QTextEdit {background-color: \"+str(background)+\"; color: \"+str(text)+\"}\")\n else: self._widget.setStyleSheet(\"QLineEdit {background-color: \"+str(background)+\"; color: \"+str(text)+\"}\")", "docstring": "Sets the colors of the text area." }, { "code": "def _extend_object(parent, n, o, otype, fqdn):\n from inspect import ismodule, isclass\n pmodule = parent if ismodule(parent) or isclass(parent) else None\n try:\n if otype == \"methods\":\n setattr(o.__func__, \"__acornext__\", None)\n else:\n setattr(o, \"__acornext__\", None)\n fqdn = _fqdn(o, recheck=True, pmodule=pmodule)\n return o\n except (TypeError, AttributeError):\n okey = id(o)\n if okey not in _extended_objs:\n xobj = _create_extension(o, otype, fqdn, pmodule)\n fqdn = _fqdn(xobj, recheck=True, pmodule=pmodule)\n if xobj is not None:\n _extended_objs[okey] = xobj\n try:\n setattr(parent, n, _extended_objs[okey])\n return _extended_objs[okey]\n except KeyError:\n msg.warn(\"Object extension failed: {} ({}).\".format(o, otype))", "docstring": "Extends the specified object if it needs to be extended. The method\n attempts to add an attribute to the object; if it fails, a new object is\n created that inherits all of `o` attributes, but is now a regular object\n that can have attributes set.\n\n Args:\n parent: has `n` in its `__dict__` attribute.\n n (str): object name attribute.\n o (list): object instances to be extended.\n otype (str): object types; one of [\"classes\", \"functions\", \"methods\",\n \"modules\"].\n fqdn (str): fully qualified name of the package that the object belongs\n to." }, { "code": "def get_parents_letters(self, goobj):\n parents_all = set.union(self.go2parents[goobj.id])\n parents_all.add(goobj.id)\n parents_d1 = parents_all.intersection(self.gos_depth1)\n return [self.goone2ntletter[g].D1 for g in parents_d1]", "docstring": "Get the letters representing all parent terms which are depth-01 GO terms." }, { "code": "def get_mute(self):\n params = '0Master'\n res = self.soap_request(URL_CONTROL_DMR, URN_RENDERING_CONTROL,\n 'GetMute', params)\n root = ET.fromstring(res)\n el_mute = root.find('.//CurrentMute')\n return el_mute.text != '0'", "docstring": "Return if the TV is muted." }, { "code": "def apply_rules(self, rules, recursive=True):\n if recursive:\n new_args = [_apply_rules(arg, rules) for arg in self.args]\n new_kwargs = {\n key: _apply_rules(val, rules)\n for (key, val) in self.kwargs.items()}\n else:\n new_args = self.args\n new_kwargs = self.kwargs\n simplified = self.create(*new_args, **new_kwargs)\n return _apply_rules_no_recurse(simplified, rules)", "docstring": "Rebuild the expression while applying a list of rules\n\n The rules are applied against the instantiated expression, and any\n sub-expressions if `recursive` is True. Rule application is best though\n of as a pattern-based substitution. This is different from the\n *automatic* rules that :meth:`create` uses (see :meth:`add_rule`),\n which are applied *before* expressions are instantiated.\n\n Args:\n rules (list or ~collections.OrderedDict): List of rules or\n dictionary mapping names to rules, where each rule is a tuple\n (:class:`Pattern`, replacement callable), cf.\n :meth:`apply_rule`\n recursive (bool): If true (default), apply rules to all arguments\n and keyword arguments of the expression. Otherwise, only the\n expression itself will be re-instantiated.\n\n If `rules` is a dictionary, the keys (rules names) are used only for\n debug logging, to allow an analysis of which rules lead to the final\n form of an expression." }, { "code": "def _pigpio_aio_command(self, cmd, p1, p2,):\n with (yield from self._lock):\n data = struct.pack('IIII', cmd, p1, p2, 0)\n self._loop.sock_sendall(self.s, data)\n response = yield from self._loop.sock_recv(self.s, 16)\n _, res = struct.unpack('12sI', response)\n return res", "docstring": "Runs a pigpio socket command.\n\n sl:= command socket and lock.\n cmd:= the command to be executed.\n p1:= command parameter 1 (if applicable).\n p2:= command parameter 2 (if applicable)." }, { "code": "def get_repo(self, auth, username, repo_name):\n path = \"/repos/{u}/{r}\".format(u=username, r=repo_name)\n response = self.get(path, auth=auth)\n return GogsRepo.from_json(response.json())", "docstring": "Returns a the repository with name ``repo_name`` owned by\n the user with username ``username``.\n\n :param auth.Authentication auth: authentication object\n :param str username: username of owner of repository\n :param str repo_name: name of repository\n :return: a representation of the retrieved repository\n :rtype: GogsRepo\n :raises NetworkFailure: if there is an error communicating with the server\n :raises ApiFailure: if the request cannot be serviced" }, { "code": "def sign_data(self, name, hash_input, key_version=None, hash_algorithm=\"sha2-256\", context=\"\", prehashed=False,\n signature_algorithm=\"pss\", mount_point=DEFAULT_MOUNT_POINT):\n if hash_algorithm not in transit_constants.ALLOWED_HASH_DATA_ALGORITHMS:\n error_msg = 'invalid hash_algorithm argument provided \"{arg}\", supported types: \"{allowed_types}\"'\n raise exceptions.ParamValidationError(error_msg.format(\n arg=hash_algorithm,\n allowed_types=', '.join(transit_constants.ALLOWED_HASH_DATA_ALGORITHMS),\n ))\n if signature_algorithm not in transit_constants.ALLOWED_SIGNATURE_ALGORITHMS:\n error_msg = 'invalid signature_algorithm argument provided \"{arg}\", supported types: \"{allowed_types}\"'\n raise exceptions.ParamValidationError(error_msg.format(\n arg=signature_algorithm,\n allowed_types=', '.join(transit_constants.ALLOWED_SIGNATURE_ALGORITHMS),\n ))\n params = {\n 'input': hash_input,\n 'key_version': key_version,\n 'hash_algorithm': hash_algorithm,\n 'context': context,\n 'prehashed': prehashed,\n 'signature_algorithm': signature_algorithm,\n }\n api_path = '/v1/{mount_point}/sign/{name}'.format(\n mount_point=mount_point,\n name=name,\n )\n response = self._adapter.post(\n url=api_path,\n json=params,\n )\n return response.json()", "docstring": "Return the cryptographic signature of the given data using the named key and the specified hash algorithm.\n\n The key must be of a type that supports signing.\n\n Supported methods:\n POST: /{mount_point}/sign/{name}(/{hash_algorithm}). Produces: 200 application/json\n\n :param name: Specifies the name of the encryption key to use for signing. This is specified as part of the URL.\n :type name: str | unicode\n :param hash_input: Specifies the base64 encoded input data.\n :type hash_input: str | unicode\n :param key_version: Specifies the version of the key to use for signing. If not set, uses the latest version.\n Must be greater than or equal to the key's min_encryption_version, if set.\n :type key_version: int\n :param hash_algorithm: Specifies the hash algorithm to use for supporting key types (notably, not including\n ed25519 which specifies its own hash algorithm). This can also be specified as part of the URL.\n Currently-supported algorithms are: sha2-224, sha2-256, sha2-384, sha2-512\n :type hash_algorithm: str | unicode\n :param context: Base64 encoded context for key derivation. Required if key derivation is enabled; currently only\n available with ed25519 keys.\n :type context: str | unicode\n :param prehashed: Set to true when the input is already hashed. If the key type is rsa-2048 or rsa-4096, then\n the algorithm used to hash the input should be indicated by the hash_algorithm parameter. Just as the value\n to sign should be the base64-encoded representation of the exact binary data you want signed, when set, input\n is expected to be base64-encoded binary hashed data, not hex-formatted. (As an example, on the command line,\n you could generate a suitable input via openssl dgst -sha256 -binary | base64.)\n :type prehashed: bool\n :param signature_algorithm: When using a RSA key, specifies the RSA signature algorithm to use for signing.\n Supported signature types are: pss, pkcs1v15\n :type signature_algorithm: str | unicode\n :param mount_point: The \"path\" the method/backend was mounted on.\n :type mount_point: str | unicode\n :return: The JSON response of the request.\n :rtype: requests.Response" }, { "code": "def parameters(self):\n return self.block_tl, self.block_br, self.rows, self.cols, self.cells", "docstring": "Returns tuple of selection parameters of self\n\n (self.block_tl, self.block_br, self.rows, self.cols, self.cells)" }, { "code": "def fetch(url, binary, outfile, noprint, rendered):\n\twith chrome_context.ChromeContext(binary=binary) as cr:\n\t\tresp = cr.blocking_navigate_and_get_source(url)\n\t\tif rendered:\n\t\t\tresp['content'] = cr.get_rendered_page_source()\n\t\t\tresp['binary'] = False\n\t\t\tresp['mimie'] = 'text/html'\n\tif not noprint:\n\t\tif resp['binary'] is False:\n\t\t\tprint(resp['content'])\n\t\telse:\n\t\t\tprint(\"Response is a binary file\")\n\t\t\tprint(\"Cannot print!\")\n\tif outfile:\n\t\twith open(outfile, \"wb\") as fp:\n\t\t\tif resp['binary']:\n\t\t\t\tfp.write(resp['content'])\n\t\t\telse:\n\t\t\t\tfp.write(resp['content'].encode(\"UTF-8\"))", "docstring": "Fetch a specified URL's content, and output it to the console." }, { "code": "def add_loss(self, loss, name=None, regularization=False, add_summaries=True):\n _ = name\n if regularization:\n self._g.add_to_collection(GraphKeys.REGULARIZATION_LOSSES, loss)\n tf.add_to_collection(GraphKeys.LOSSES, loss)\n if add_summaries:\n self.add_scalar_summary(loss, 'loss')\n self.add_average_summary(loss, 'loss_average')", "docstring": "Append a loss to the total loss for the network.\n\n Args:\n loss: append this loss operation\n name: The name for this loss, defaults to loss.op.name\n regularization: Set to True if this is a regularization loss.\n add_summaries: Set to True if you want to see scalar and average summary." }, { "code": "def get_product_target_mappings_for_targets(self, targets):\n product_target_mappings = []\n for target in targets:\n for product in self._products_by_target[target]:\n product_target_mappings.append((product, target))\n return product_target_mappings", "docstring": "Gets the product-target associations for the given targets, preserving the input order.\n\n :API: public\n\n :param targets: The targets to lookup products for.\n :returns: The ordered (product, target) tuples." }, { "code": "def ed25519_private_key_to_string(key):\n return base64.b64encode(key.private_bytes(\n encoding=serialization.Encoding.Raw,\n format=serialization.PrivateFormat.Raw,\n encryption_algorithm=serialization.NoEncryption()\n ), None).decode('utf-8')", "docstring": "Convert an ed25519 private key to a base64-encoded string.\n\n Args:\n key (Ed25519PrivateKey): the key to write to the file.\n\n Returns:\n str: the key representation as a str" }, { "code": "def custom_background_code():\n while True:\n logger.info(\"Block %s / %s\", str(Blockchain.Default().Height), str(Blockchain.Default().HeaderHeight))\n sleep(15)", "docstring": "Custom code run in a background thread. Prints the current block height.\n\n This function is run in a daemonized thread, which means it can be instantly killed at any\n moment, whenever the main thread quits. If you need more safety, don't use a daemonized\n thread and handle exiting this thread in another way (eg. with signals and events)." }, { "code": "def build_sequence(self, xs, masks, init, is_left_to_right):\n states = []\n last = init\n if is_left_to_right:\n for i, xs_i in enumerate(xs):\n h = self.build(xs_i, last, masks[i])\n states.append(h)\n last = h\n else:\n for i in range(len(xs) - 1, -1, -1):\n h = self.build(xs[i], last, masks[i])\n states.insert(0, h)\n last = h\n return states", "docstring": "Build GRU sequence." }, { "code": "def available_for_entry_point(self, entry_point):\n if self.entry_point == ALL or entry_point == ALL:\n return True\n return entry_point in ensure_sequence(self.entry_point)", "docstring": "Check if the current function can be executed from a request to the given entry point" }, { "code": "def mean_date(dt_list):\n dt_list_sort = sorted(dt_list)\n dt_list_sort_rel = [dt - dt_list_sort[0] for dt in dt_list_sort]\n avg_timedelta = sum(dt_list_sort_rel, timedelta())/len(dt_list_sort_rel)\n return dt_list_sort[0] + avg_timedelta", "docstring": "Calcuate mean datetime from datetime list" }, { "code": "def correct_transition_matrix(T, reversible=None):\n r\n row_sums = T.sum(axis=1).A1\n max_sum = np.max(row_sums)\n if max_sum == 0.0:\n max_sum = 1.0\n return (T + scipy.sparse.diags(-row_sums+max_sum, 0)) / max_sum", "docstring": "r\"\"\"Normalize transition matrix\n\n Fixes a the row normalization of a transition matrix.\n To be used with the reversible estimators to fix an almost coverged\n transition matrix.\n\n Parameters\n ----------\n T : (M, M) ndarray\n matrix to correct\n reversible : boolean\n for future use\n\n Returns\n -------\n (M, M) ndarray\n corrected transition matrix" }, { "code": "def get_attributes(self):\n attr = ['chr', 'start', 'stop']\n if self.strandPos is not None:\n attr.append('strand')\n if self.otherPos:\n for i, o in enumerate(self.otherPos):\n attr.append(o[1])\n return attr", "docstring": "Returns the unordered list of attributes\n\n :return: list of strings" }, { "code": "def _fetch_messages(self):\n try:\n [_, msg] = self.socket.recv_multipart(flags=zmq.NOBLOCK)\n if Global.CONFIG_MANAGER.tracing_mode:\n Global.LOGGER.debug(\"fetched a new message\")\n self.fetched = self.fetched + 1\n obj = pickle.loads(msg)\n self._deliver_message(obj)\n return obj\n except zmq.error.Again:\n return None\n except Exception as new_exception:\n Global.LOGGER.error(new_exception)\n raise new_exception", "docstring": "Get an input message from the socket" }, { "code": "def get_tags_of_offer_per_page(self, offer_id, per_page=1000, page=1):\n return self._get_resource_per_page(\n resource=OFFER_TAGS,\n per_page=per_page,\n page=page,\n params={'offer_id': offer_id},\n )", "docstring": "Get tags of offer per page\n\n :param per_page: How many objects per page. Default: 1000\n :param page: Which page. Default: 1\n :param offer_id: the offer id\n :return: list" }, { "code": "def node_coord_in_direction(tile_id, direction):\n tile_coord = tile_id_to_coord(tile_id)\n for node_coord in nodes_touching_tile(tile_id):\n if tile_node_offset_to_direction(node_coord - tile_coord) == direction:\n return node_coord\n raise ValueError('No node found in direction={} at tile_id={}'.format(\n direction,\n tile_id\n ))", "docstring": "Returns the node coordinate in the given direction at the given tile identifier.\n\n :param tile_id: tile identifier, int\n :param direction: direction, str\n :return: node coord, int" }, { "code": "def insert(self, storagemodel) -> StorageTableModel:\n modeldefinition = self.getmodeldefinition(storagemodel, True)\n try:\n modeldefinition['tableservice'].insert_or_replace_entity(modeldefinition['tablename'], storagemodel.entity())\n storagemodel._exists = True\n except AzureMissingResourceHttpError as e:\n storagemodel._exists = False\n log.debug('can not insert or replace table entity: Table {}, PartitionKey {}, RowKey {} because {!s}'.format(modeldefinition['tablename'], storagemodel.getPartitionKey(), storagemodel.getRowKey(), e))\n except Exception as e:\n storagemodel._exists = False\n msg = 'can not insert or replace table entity: Table {}, PartitionKey {}, RowKey {} because {!s}'.format(modeldefinition['tablename'], storagemodel.PartitionKey, storagemodel.RowKey, e)\n raise AzureStorageWrapException(msg=msg)\n finally:\n return storagemodel", "docstring": "insert model into storage" }, { "code": "def item(p_queue, queue_id, host=None):\n if host is not None:\n return os.path.join(_path(host, _c.FSQ_QUEUE, root=hosts(p_queue)),\n valid_name(queue_id))\n return os.path.join(_path(p_queue, _c.FSQ_QUEUE), valid_name(queue_id))", "docstring": "Construct a path to a queued item" }, { "code": "def update(cls, draft_share_invite_api_key_id, status=None, sub_status=None,\n expiration=None, custom_headers=None):\n if custom_headers is None:\n custom_headers = {}\n api_client = client.ApiClient(cls._get_api_context())\n request_map = {\n cls.FIELD_STATUS: status,\n cls.FIELD_SUB_STATUS: sub_status,\n cls.FIELD_EXPIRATION: expiration\n }\n request_map_string = converter.class_to_json(request_map)\n request_map_string = cls._remove_field_for_request(request_map_string)\n request_bytes = request_map_string.encode()\n endpoint_url = cls._ENDPOINT_URL_UPDATE.format(cls._determine_user_id(),\n draft_share_invite_api_key_id)\n response_raw = api_client.put(endpoint_url, request_bytes,\n custom_headers)\n return BunqResponseDraftShareInviteApiKey.cast_from_bunq_response(\n cls._from_json(response_raw, cls._OBJECT_TYPE_PUT)\n )", "docstring": "Update a draft share invite. When sending status CANCELLED it is\n possible to cancel the draft share invite.\n\n :type user_id: int\n :type draft_share_invite_api_key_id: int\n :param status: The status of the draft share invite. Can be CANCELLED\n (the user cancels the draft share before it's used).\n :type status: str\n :param sub_status: The sub-status of the draft share invite. Can be\n NONE, ACCEPTED or REJECTED.\n :type sub_status: str\n :param expiration: The moment when this draft share invite expires.\n :type expiration: str\n :type custom_headers: dict[str, str]|None\n\n :rtype: BunqResponseDraftShareInviteApiKey" }, { "code": "def detect(filename, include_confidence=False):\n f = open(filename)\n detection = chardet.detect(f.read())\n f.close()\n encoding = detection.get('encoding')\n confidence = detection.get('confidence')\n if include_confidence:\n return (encoding, confidence)\n return encoding", "docstring": "Detect the encoding of a file.\n\n Returns only the predicted current encoding as a string.\n\n If `include_confidence` is True, \n Returns tuple containing: (str encoding, float confidence)" }, { "code": "def get_request_filename(request):\n if 'Content-Disposition' in request.info():\n disposition = request.info()['Content-Disposition']\n pieces = re.split(r'\\s*;\\s*', disposition)\n for piece in pieces:\n if piece.startswith('filename='):\n filename = piece[len('filename='):]\n if filename.startswith('\"'):\n filename = filename[1:]\n if filename.endswith('\"'):\n filename = filename[:-1]\n filename = filename.replace('\\\\\"', '\"')\n return filename\n return os.path.basename(urlsplit(request.url).path) or 'index.html'", "docstring": "Figure out the filename for an HTTP download." }, { "code": "def _wait_for_new_tasks(self, timeout=0, batch_timeout=0):\n new_queue_found = False\n start_time = batch_exit = time.time()\n while True:\n if batch_exit > start_time:\n pubsub_sleep = batch_exit - time.time()\n else:\n pubsub_sleep = start_time + timeout - time.time()\n message = self._pubsub.get_message(timeout=0 if pubsub_sleep < 0 or\n self._did_work\n else pubsub_sleep)\n while message:\n if message['type'] == 'message':\n new_queue_found, batch_exit = self._process_queue_message(\n message['data'], new_queue_found, batch_exit,\n start_time, timeout, batch_timeout\n )\n message = self._pubsub.get_message()\n if self._did_work:\n break\n elif time.time() >= batch_exit and new_queue_found:\n break\n elif time.time() - start_time > timeout:\n break", "docstring": "Check activity channel and wait as necessary.\n\n This method is also used to slow down the main processing loop to reduce\n the effects of rapidly sending Redis commands. This method will exit\n for any of these conditions:\n 1. _did_work is True, suggests there could be more work pending\n 2. Found new queue and after batch timeout. Note batch timeout\n can be zero so it will exit immediately.\n 3. Timeout seconds have passed, this is the maximum time to stay in\n this method" }, { "code": "def start(self):\n logger.info('Starting client.')\n self.dispatcher_greenlets = []\n for _, entry in self.config['baits'].items():\n for b in clientbase.ClientBase.__subclasses__():\n bait_name = b.__name__.lower()\n if bait_name in entry:\n bait_options = entry[bait_name]\n dispatcher = BaitDispatcher(b, bait_options)\n dispatcher.start()\n self.dispatcher_greenlets.append(dispatcher)\n logger.info('Adding {0} bait'.format(bait_name))\n logger.debug('Bait added with options: {0}'.format(bait_options))\n gevent.joinall(self.dispatcher_greenlets)", "docstring": "Starts sending client bait to the configured Honeypot." }, { "code": "def query(self, object_class=None, json=None, **kwargs):\n path = \"/directory-sync-service/v1/{}\".format(object_class)\n r = self._httpclient.request(\n method=\"POST\",\n url=self.url,\n json=json,\n path=path,\n **kwargs\n )\n return r", "docstring": "Query data stored in directory.\n\n Retrieves directory data by querying a Directory Sync Service\n cloud-based instance. The directory data is stored with the\n Directory Sync Service instance using an agent that is installed\n in the customer's network.This agent retrieves directory data\n from the customer's Active Directory, and then sends it to the\n cloud-based Directory Sync Service instance.\n\n Args:\n object_class (str): Directory object class.\n json (dict): Payload/request body.\n **kwargs: Supported :meth:`~pancloud.httpclient.HTTPClient.request` parameters.\n\n Returns:\n requests.Response: Requests Response() object.\n\n Examples:\n Coming soon." }, { "code": "def visible_line_width(self, position = Point):\r\n extra_char_width = len([ None for c in self[:position].line_buffer if 0x2013 <= ord(c) <= 0xFFFD])\r\n return len(self[:position].quoted_text()) + self[:position].line_buffer.count(u\"\\t\")*7 + extra_char_width", "docstring": "Return the visible width of the text in line buffer up to position." }, { "code": "def schemaNewValidCtxt(self):\n ret = libxml2mod.xmlSchemaNewValidCtxt(self._o)\n if ret is None:raise treeError('xmlSchemaNewValidCtxt() failed')\n __tmp = SchemaValidCtxt(_obj=ret)\n __tmp.schema = self\n return __tmp", "docstring": "Create an XML Schemas validation context based on the given\n schema." }, { "code": "def _apply_shadow_vars(avg_grads):\n ps_var_grads = []\n for grad, var in avg_grads:\n assert var.name.startswith('tower'), var.name\n my_name = '/'.join(var.name.split('/')[1:])\n my_name = get_op_tensor_name(my_name)[0]\n new_v = tf.get_variable(my_name, dtype=var.dtype.base_dtype,\n initializer=var.initial_value,\n trainable=True)\n ps_var_grads.append((grad, new_v))\n return ps_var_grads", "docstring": "Create shadow variables on PS, and replace variables in avg_grads\n by these shadow variables.\n\n Args:\n avg_grads: list of (grad, var) tuples" }, { "code": "def get_extended_metadata(self, item_id):\n response = self.soap_client.call(\n 'getExtendedMetadata',\n [('id', item_id)])\n return response.get('getExtendedMetadataResult', None)", "docstring": "Get extended metadata for a media item, such as related items.\n\n Args:\n item_id (str): The item for which metadata is required.\n\n Returns:\n ~collections.OrderedDict: The item's extended metadata or None.\n\n See also:\n The Sonos `getExtendedMetadata API\n `_" }, { "code": "def run_facter(self, key=None):\n args = [self.facter_path]\n args.append(\"--puppet\")\n if self.external_dir is not None:\n args.append('--external-dir')\n args.append(self.external_dir)\n if self.uses_yaml:\n args.append(\"--yaml\")\n if key is not None:\n args.append(key)\n proc = subprocess.Popen(args, stdout=subprocess.PIPE)\n results = proc.stdout.read()\n if self.uses_yaml:\n parsed_results = yaml.load(results)\n if key is not None:\n return parsed_results[key]\n else:\n return parsed_results\n results = results.decode()\n if key is not None:\n return results.strip()\n else:\n return dict(_parse_cli_facter_results(results))", "docstring": "Run the facter executable with an optional specfic\n fact. Output is parsed to yaml if available and\n selected. Puppet facts are always selected. Returns a\n dictionary if no key is given, and the value if a key is\n passed." }, { "code": "def dispatch_hook(cls, s=None, *_args, **_kwds):\n if s is None:\n return config.conf.raw_layer\n fb = orb(s[0])\n if fb & 0x80 != 0:\n return HPackIndexedHdr\n if fb & 0x40 != 0:\n return HPackLitHdrFldWithIncrIndexing\n if fb & 0x20 != 0:\n return HPackDynamicSizeUpdate\n return HPackLitHdrFldWithoutIndexing", "docstring": "dispatch_hook returns the subclass of HPackHeaders that must be used\n to dissect the string." }, { "code": "def _fixpath(root, base):\n return os.path.abspath(os.path.normpath(os.path.join(root, base)))", "docstring": "Return absolute, normalized, joined paths" }, { "code": "def _structure(self, source_code):\n def cutter(seq, block_size):\n for index in range(0, len(seq), block_size):\n lexem = seq[index:index+block_size]\n if len(lexem) == block_size:\n yield self.table_struct[seq[index:index+block_size]]\n return tuple(cutter(source_code, self.idnt_struct_size))", "docstring": "return structure in ACDP format." }, { "code": "def run(self):\n stdoutBak = sys.stdout\n streamResult = StringIO()\n sys.stdout = streamResult\n try:\n pycodestyle.Checker.check_all(self)\n finally:\n sys.stdout = stdoutBak", "docstring": "Run pycodestyle checker and record warnings." }, { "code": "def rmdir(self, pathobj):\n stat = self.stat(pathobj)\n if not stat.is_dir:\n raise OSError(20, \"Not a directory: '%s'\" % str(pathobj))\n url = str(pathobj) + '/'\n text, code = self.rest_del(url, session=pathobj.session, verify=pathobj.verify, cert=pathobj.cert)\n if code not in [200, 202, 204]:\n raise RuntimeError(\"Failed to delete directory: '%s'\" % text)", "docstring": "Removes a directory" }, { "code": "def instances_get(opts, plugins, url_file_input, out):\n instances = OrderedDict()\n preferred_order = ['wordpress', 'joomla', 'drupal']\n for cms_name in preferred_order:\n for plugin in plugins:\n plugin_name = plugin.__name__.lower()\n if cms_name == plugin_name:\n instances[plugin_name] = instance_get(plugin, opts,\n url_file_input, out)\n for plugin in plugins:\n plugin_name = plugin.__name__.lower()\n if plugin_name not in preferred_order:\n instances[plugin_name] = instance_get(plugin, opts,\n url_file_input, out)\n return instances", "docstring": "Creates and returns an ordered dictionary containing instances for all available\n scanning plugins, sort of ordered by popularity.\n @param opts: options as returned by self._options.\n @param plugins: plugins as returned by plugins_util.plugins_base_get.\n @param url_file_input: boolean value which indicates whether we are\n scanning an individual URL or a file. This is used to determine\n kwargs required.\n @param out: self.out" }, { "code": "def stop(self):\n self._cease.set()\n time.sleep(0.1)\n self._isRunning = False", "docstring": "Stop the periodic runner" }, { "code": "def to_dict(self):\n return {\"address\": self.address,\n \"port\": self.port,\n \"condition\": self.condition,\n \"type\": self.type,\n \"id\": self.id,\n }", "docstring": "Convert this Node to a dict representation for passing to the API." }, { "code": "def read_wav(self, filename):\n wave_input = None\n try:\n wave_input = wave.open(filename, 'r')\n wave_frames = bytearray(\n wave_input.readframes(wave_input.getnframes()))\n self.sample_data = [x >> 4 for x in wave_frames]\n finally:\n if wave_input is not None:\n wave_input.close()", "docstring": "Read sample data for this sample from a WAV file.\n\n :param filename: the file from which to read" }, { "code": "def _find_rtd_version():\n vstr = 'latest'\n try:\n import ginga\n from bs4 import BeautifulSoup\n except ImportError:\n return vstr\n if not minversion(ginga, '2.6.0'):\n return vstr\n url = 'https://readthedocs.org/projects/ginga/downloads/'\n with urllib.request.urlopen(url) as r:\n soup = BeautifulSoup(r, 'html.parser')\n all_rtd_vernums = []\n for link in soup.find_all('a'):\n href = link.get('href')\n if 'htmlzip' not in href:\n continue\n s = href.split('/')[-2]\n if s.startswith('v'):\n all_rtd_vernums.append(s)\n all_rtd_vernums.sort(reverse=True)\n ginga_ver = ginga.__version__\n for rtd_ver in all_rtd_vernums:\n if ginga_ver > rtd_ver[1:]:\n break\n else:\n vstr = rtd_ver\n return vstr", "docstring": "Find closest RTD doc version." }, { "code": "def _check_match(self, name, version_string) -> bool:\n if not name or not version_string:\n return False\n try:\n version = Version(version_string)\n except InvalidVersion:\n logger.debug(f\"Package {name}=={version_string} has an invalid version\")\n return False\n for requirement in self.blacklist_release_requirements:\n if name != requirement.name:\n continue\n if version in requirement.specifier:\n logger.debug(\n f\"MATCH: Release {name}=={version} matches specifier \"\n f\"{requirement.specifier}\"\n )\n return True\n return False", "docstring": "Check if the package name and version matches against a blacklisted\n package version specifier.\n\n Parameters\n ==========\n name: str\n Package name\n\n version: str\n Package version\n\n Returns\n =======\n bool:\n True if it matches, False otherwise." }, { "code": "def cancel_offer(self, offer_id):\n return self._create_put_request(\n resource=OFFERS,\n billomat_id=offer_id,\n command=CANCEL,\n )", "docstring": "Cancelles an offer\n\n :param offer_id: the offer id\n :return Response" }, { "code": "def _schedule(self, action: Callable, seconds: int=0) -> int:\n self.aid += 1\n if seconds > 0:\n nxt = time.perf_counter() + seconds\n if nxt < self.aqNextCheck:\n self.aqNextCheck = nxt\n logger.trace(\"{} scheduling action {} with id {} to run in {} \"\n \"seconds\".format(self, get_func_name(action),\n self.aid, seconds))\n self.aqStash.append((nxt, (action, self.aid)))\n else:\n logger.trace(\"{} scheduling action {} with id {} to run now\".\n format(self, get_func_name(action), self.aid))\n self.actionQueue.append((action, self.aid))\n if action not in self.scheduled:\n self.scheduled[action] = []\n self.scheduled[action].append(self.aid)\n return self.aid", "docstring": "Schedule an action to be executed after `seconds` seconds.\n\n :param action: a callable to be scheduled\n :param seconds: the time in seconds after which the action must be executed" }, { "code": "def addFeatureSet(self, featureSet):\n id_ = featureSet.getId()\n self._featureSetIdMap[id_] = featureSet\n self._featureSetIds.append(id_)\n name = featureSet.getLocalId()\n self._featureSetNameMap[name] = featureSet", "docstring": "Adds the specified featureSet to this dataset." }, { "code": "def _set_route(self, ip_dest, next_hop, **kwargs):\n commands = self._build_commands(ip_dest, next_hop, **kwargs)\n delete = kwargs.get('delete', False)\n default = kwargs.get('default', False)\n if delete:\n commands = \"no \" + commands\n else:\n if default:\n commands = \"default \" + commands\n return self.configure(commands)", "docstring": "Configure a static route\n\n Args:\n ip_dest (string): The ip address of the destination in the\n form of A.B.C.D/E\n next_hop (string): The next hop interface or ip address\n **kwargs['next_hop_ip'] (string): The next hop address on\n destination interface\n **kwargs['distance'] (string): Administrative distance for this\n route\n **kwargs['tag'] (string): Route tag\n **kwargs['route_name'] (string): Route name\n **kwargs['delete'] (boolean): If true, deletes the specified route\n instead of creating or setting values for the route\n **kwargs['default'] (boolean): If true, defaults the specified\n route instead of creating or setting values for the route\n\n Returns:\n True if the operation succeeds, otherwise False." }, { "code": "def createRtiFromFileName(fileName):\n cls, rtiRegItem = detectRtiFromFileName(fileName)\n if cls is None:\n logger.warn(\"Unable to import plugin {}: {}\"\n .format(rtiRegItem.fullName, rtiRegItem.exception))\n rti = UnknownFileRti.createFromFileName(fileName)\n rti.setException(rtiRegItem.exception)\n else:\n rti = cls.createFromFileName(fileName)\n assert rti, \"Sanity check failed (createRtiFromFileName). Please report this bug.\"\n return rti", "docstring": "Determines the type of RepoTreeItem to use given a file name and creates it.\n Uses a DirectoryRti for directories and an UnknownFileRti if the file\n extension doesn't match one of the registered RTI extensions." }, { "code": "def eigenvalues_rev(T, k, ncv=None, mu=None):\n r\n if mu is None:\n mu = stationary_distribution(T)\n if np.any(mu <= 0):\n raise ValueError('Cannot symmetrize transition matrix')\n smu = np.sqrt(mu)\n D = diags(smu, 0)\n Dinv = diags(1.0/smu, 0)\n S = (D.dot(T)).dot(Dinv)\n evals = scipy.sparse.linalg.eigsh(S, k=k, ncv=ncv, which='LM', return_eigenvectors=False)\n return evals", "docstring": "r\"\"\"Compute the eigenvalues of a reversible, sparse transition matrix.\n\n Parameters\n ----------\n T : (M, M) scipy.sparse matrix\n Transition matrix\n k : int\n Number of eigenvalues to compute.\n ncv : int, optional\n The number of Lanczos vectors generated, `ncv` must be greater than k;\n it is recommended that ncv > 2*k\n mu : (M,) ndarray, optional\n Stationary distribution of T\n\n Returns\n -------\n v : (k,) ndarray\n Eigenvalues of T\n\n Raises\n ------\n ValueError\n If stationary distribution is nonpositive.\n\n Notes\n -----\n The first k eigenvalues of largest magnitude are computed." }, { "code": "def torrent_from_url(self, url, cache=True, prefetch=False):\n if self._use_cache(cache) and url in self._torrent_cache:\n return self._torrent_cache[url]\n torrent = Torrent(url, cache, prefetch)\n if cache:\n self._torrent_cache[url] = torrent\n return torrent", "docstring": "Create a Torrent object from a given URL.\n\n If the cache option is set, check to see if we already have a Torrent\n object representing it. If prefetch is set, automatically query the\n torrent's info page to fill in the torrent object. (If prefetch is\n false, then the torrent page will be queried lazily on-demand.)" }, { "code": "def validate_matrix(self, data):\n is_grid_search = (\n data.get('grid_search') is not None or\n (data.get('grid_search') is None and\n data.get('random_search') is None and\n data.get('hyperband') is None and\n data.get('bo') is None)\n )\n is_bo = data.get('bo') is not None\n validate_matrix(data.get('matrix'), is_grid_search=is_grid_search, is_bo=is_bo)", "docstring": "Validates matrix data and creates the config objects" }, { "code": "def outputDeflections(self):\n try:\n self.wOutFile\n if self.Verbose:\n print(\"Output filename provided.\")\n except:\n try:\n self.wOutFile = self.configGet(\"string\", \"output\", \"DeflectionOut\", optional=True)\n except:\n if self.Debug:\n print(\"No output filename provided:\")\n print(\" not writing any deflection output to file\")\n if self.wOutFile:\n if self.wOutFile[-4:] == '.npy':\n from numpy import save\n save(self.wOutFile,self.w)\n else:\n from numpy import savetxt\n savetxt(self.wOutFile,self.w,fmt='%.3f')\n if self.Verbose:\n print(\"Saving deflections --> \" + self.wOutFile)", "docstring": "Outputs a grid of deflections if an output directory is defined in the \n configuration file\n \n If the filename given in the configuration file ends in \".npy\", then a binary \n numpy grid will be exported.\n \n Otherwise, an ASCII grid will be exported." }, { "code": "def removeComments(element):\n global _num_bytes_saved_in_comments\n num = 0\n if isinstance(element, xml.dom.minidom.Comment):\n _num_bytes_saved_in_comments += len(element.data)\n element.parentNode.removeChild(element)\n num += 1\n else:\n for subelement in element.childNodes[:]:\n num += removeComments(subelement)\n return num", "docstring": "Removes comments from the element and its children." }, { "code": "def calibration(self):\n self.calibration_cache_path()\n if self.job().is_dax():\n self.add_var_opt('glob-calibration-data','')\n cache_filename=self.get_calibration()\n pat = re.compile(r'(file://.*)')\n f = open(cache_filename, 'r')\n lines = f.readlines()\n for line in lines:\n m = pat.search(line)\n if not m:\n raise IOError\n url = m.group(1)\n path = urlparse.urlparse(url)[2]\n calibration_lfn = os.path.basename(path)\n self.add_input_file(calibration_lfn)\n else:\n self.add_var_opt('calibration-cache', self.__calibration_cache)\n self.__calibration = self.__calibration_cache\n self.add_input_file(self.__calibration)", "docstring": "Set the path to the calibration cache file for the given IFO.\n During S2 the Hanford 2km IFO had two calibration epochs, so\n if the start time is during S2, we use the correct cache file." }, { "code": "def _ensure_image_registry(self, image):\n image_with_registry = image.copy()\n if self.parent_registry:\n if image.registry and image.registry != self.parent_registry:\n error = (\n \"Registry specified in dockerfile image doesn't match configured one. \"\n \"Dockerfile: '%s'; expected registry: '%s'\"\n % (image, self.parent_registry))\n self.log.error(\"%s\", error)\n raise RuntimeError(error)\n image_with_registry.registry = self.parent_registry\n return image_with_registry", "docstring": "If plugin configured with a parent registry, ensure the image uses it" }, { "code": "def get_next_revision(self, session_id, revision, delta):\n session = self.sessions[session_id]\n session.state = State.connected\n if delta == revision:\n session.revision = max(session.revision, revision)\n self.next_revision_available.wait()\n return self.revision", "docstring": "Determine the next revision number for a given session id, revision\n and delta.\n\n In case the client is up-to-date, this method will block until the next\n revision is available.\n\n :param int session_id: Session identifier\n :param int revision: Client revision number\n :param int delta: Client revision delta (old client version number)\n :return: Next revision number\n :rtype: int" }, { "code": "def _compute_derivatives(self):\n derivatives = []\n for i, (timestamp, value) in enumerate(self.time_series_items):\n if i > 0:\n pre_item = self.time_series_items[i - 1]\n pre_timestamp = pre_item[0]\n pre_value = pre_item[1]\n td = timestamp - pre_timestamp\n derivative = (value - pre_value) / td if td != 0 else value - pre_value\n derivative = abs(derivative)\n derivatives.append(derivative)\n if derivatives:\n derivatives.insert(0, derivatives[0])\n self.derivatives = derivatives", "docstring": "Compute derivatives of the time series." }, { "code": "def get_current_word(self, completion=False):\r\n ret = self.get_current_word_and_position(completion)\r\n if ret is not None:\r\n return ret[0]", "docstring": "Return current word, i.e. word at cursor position" }, { "code": "def iloc(cls, dataset, index):\n rows, cols = index\n scalar = False\n if isinstance(cols, slice):\n cols = [d.name for d in dataset.dimensions()][cols]\n elif np.isscalar(cols):\n scalar = np.isscalar(rows)\n cols = [dataset.get_dimension(cols).name]\n else:\n cols = [dataset.get_dimension(d).name for d in index[1]]\n if np.isscalar(rows):\n rows = [rows]\n data = OrderedDict()\n for c in cols:\n data[c] = dataset.data[c].compute().iloc[rows].values\n if scalar:\n return data[cols[0]][0]\n return tuple(data.values())", "docstring": "Dask does not support iloc, therefore iloc will execute\n the call graph and lose the laziness of the operation." }, { "code": "def validate(self, ticket=None, raise_=False):\n rv = Receipt.objects.filter(pk=self.pk).validate(ticket)\n self.refresh_from_db()\n if raise_ and rv:\n raise exceptions.ValidationError(rv[0])\n return rv", "docstring": "Validates this receipt.\n\n This is a shortcut to :class:`~.ReceiptQuerySet`'s method of the same\n name. Calling this validates only this instance.\n\n :param AuthTicket ticket: Use this ticket. If None, one will be loaded\n or created automatically.\n :param bool raise_: If True, an exception will be raised when\n validation fails." }, { "code": "def filtered_attrs(module, *, modules=False, private=False, dunder=False,\n common=False):\n attr_names = set()\n for name, value in module.__dict__.items():\n if not common and name in STANDARD_MODULE_ATTRS:\n continue\n if name.startswith('_'):\n if name.endswith('_'):\n if not dunder:\n continue\n elif not private:\n continue\n if not modules and isinstance(value, types.ModuleType):\n continue\n attr_names.add(name)\n return frozenset(attr_names)", "docstring": "Return a collection of attributes on 'module'.\n\n If 'modules' is false then module instances are excluded. If 'private' is\n false then attributes starting with, but not ending in, '_' will be\n excluded. With 'dunder' set to false then attributes starting and ending\n with '_' are left out. The 'common' argument controls whether attributes\n found in STANDARD_MODULE_ATTRS are returned." }, { "code": "def _bse_cli_get_versions(args):\n name = args.basis.lower()\n metadata = api.get_metadata(args.data_dir)\n if not name in metadata:\n raise KeyError(\n \"Basis set {} does not exist. For a complete list of basis sets, use the 'list-basis-sets' command\".format(\n name))\n version_data = {k: v['revdesc'] for k, v in metadata[name]['versions'].items()}\n if args.no_description:\n liststr = version_data.keys()\n else:\n liststr = format_columns(version_data.items())\n return '\\n'.join(liststr)", "docstring": "Handles the get-versions subcommand" }, { "code": "def timestamp(self, timestamp):\n clone = copy.deepcopy(self)\n clone._timestamp = timestamp\n return clone", "docstring": "Allows for custom timestamps to be saved with the record." }, { "code": "def validate_dispatcher(args):\n nni_config = Config(get_config_filename(args)).get_config('experimentConfig')\n if nni_config.get('tuner') and nni_config['tuner'].get('builtinTunerName'):\n dispatcher_name = nni_config['tuner']['builtinTunerName']\n elif nni_config.get('advisor') and nni_config['advisor'].get('builtinAdvisorName'):\n dispatcher_name = nni_config['advisor']['builtinAdvisorName']\n else:\n return\n if dispatcher_name not in TUNERS_SUPPORTING_IMPORT_DATA:\n if dispatcher_name in TUNERS_NO_NEED_TO_IMPORT_DATA:\n print_warning(\"There is no need to import data for %s\" % dispatcher_name)\n exit(0)\n else:\n print_error(\"%s does not support importing addtional data\" % dispatcher_name)\n exit(1)", "docstring": "validate if the dispatcher of the experiment supports importing data" }, { "code": "def clear_all_events(self):\n self.lock.acquire()\n self.event_dict.clear()\n self.lock.release()", "docstring": "Clear all event queues and their cached events." }, { "code": "def get_tag_cloud(context, steps=6, min_count=None,\n template='zinnia/tags/tag_cloud.html'):\n tags = Tag.objects.usage_for_queryset(\n Entry.published.all(), counts=True,\n min_count=min_count)\n return {'template': template,\n 'tags': calculate_cloud(tags, steps),\n 'context_tag': context.get('tag')}", "docstring": "Return a cloud of published tags." }, { "code": "def should_see_id_in_seconds(self, element_id, timeout):\n def check_element():\n assert ElementSelector(\n world.browser,\n 'id(\"%s\")' % element_id,\n filter_displayed=True,\n ), \"Expected element with given id.\"\n wait_for(check_element)(timeout=int(timeout))", "docstring": "Assert an element with the given ``id`` is visible within n seconds." }, { "code": "def show_guiref(self):\r\n from qtconsole.usage import gui_reference\r\n self.main.help.show_rich_text(gui_reference, collapse=True)", "docstring": "Show qtconsole help" }, { "code": "def loadNetworkbyID(self, id, callback=None, errback=None):\n import ns1.ipam\n network = ns1.ipam.Network(self.config, id=id)\n return network.load(callback=callback, errback=errback)", "docstring": "Load an existing Network by ID into a high level Network object\n\n :param int id: id of an existing Network" }, { "code": "def retry(self, retries, task_f, check_f=bool, wait_f=None):\n for attempt in range(retries):\n ret = task_f()\n if check_f(ret):\n return ret\n if attempt < retries - 1 and wait_f is not None:\n wait_f(attempt)\n raise RetryException(\"Giving up after {} failed attempt(s)\".format(retries))", "docstring": "Try a function up to n times.\n Raise an exception if it does not pass in time\n\n :param retries int: The number of times to retry\n :param task_f func: The function to be run and observed\n :param func()bool check_f: a function to check if task_f is complete\n :param func()bool wait_f: a function to run between checks" }, { "code": "def map_or(self, callback: Callable[[T], U], default: A) -> Union[U, A]:\n return callback(self._val) if self._is_some else default", "docstring": "Applies the ``callback`` to the contained value or returns ``default``.\n\n Args:\n callback: The callback to apply to the contained value.\n default: The default value.\n\n Returns:\n The ``callback`` result if the contained value is ``Some``,\n otherwise ``default``.\n\n Notes:\n If you wish to use the result of a function call as ``default``,\n it is recommended to use :py:meth:`map_or_else` instead.\n\n Examples:\n >>> Some(0).map_or(lambda x: x + 1, 1000)\n 1\n >>> NONE.map_or(lambda x: x * x, 1)\n 1" }, { "code": "def display(self):\n self.pretty(self._timings, 'Raw Redis Commands')\n print()\n for key, value in self._commands.items():\n self.pretty(value, 'Qless \"%s\" Command' % key)\n print()", "docstring": "Print the results of this profiling" }, { "code": "def license_cleanup(text):\n if not text:\n return None\n text = text.rsplit(':', 1)[-1]\n replacements = [\n 'licenses',\n 'license',\n 'licences',\n 'licence',\n 'software',\n ',',\n ]\n for replacement in replacements:\n text = text.replace(replacement, '')\n text = text.strip().upper()\n text = text.replace(' ', '_')\n text = text.replace('-', '_')\n if any(trigger.upper() in text for trigger in BAD_LICENSES):\n return None\n return text", "docstring": "Tidy up a license string\n\n e.g. \"::OSI:: mit software license\" -> \"MIT\"" }, { "code": "def _deserialize(self, value, attr, data):\n token_builder = URLSafeTimedSerializer(\n current_app.config['SECRET_KEY'],\n salt=data['verb'],\n )\n result = token_builder.loads(value, max_age=current_app.config[\n 'OAISERVER_RESUMPTION_TOKEN_EXPIRE_TIME'])\n result['token'] = value\n result['kwargs'] = self.root.load(result['kwargs'], partial=True).data\n return result", "docstring": "Serialize resumption token." }, { "code": "def get_label(self, indices=None):\n if indices is None:\n indices = list(range(0, self.get_sample_size()))\n elif isinstance(indices, collections.Iterable):\n indices = sorted(list(set(indices)))\n else:\n indices = [indices]\n if len(indices) == 0:\n return []\n partitions = self.get_partitions(self.persistence)\n labels = self.X.shape[0] * [None]\n for label, partition_indices in partitions.items():\n for idx in np.intersect1d(partition_indices, indices):\n labels[idx] = label\n labels = np.array(labels)\n if len(indices) == 1:\n return labels[indices][0]\n return labels[indices]", "docstring": "Returns the label pair indices requested by the user\n @ In, indices, a list of non-negative integers specifying\n the row indices to return\n @ Out, a list of integer 2-tuples specifying the minimum and\n maximum index of the specified rows." }, { "code": "def get_pyserial_version(self):\n pyserial_version = pkg_resources.require(\"pyserial\")[0].version\n version = 3.0\n match = self.re_float.search(pyserial_version)\n if match:\n try:\n version = float(match.group(0))\n except ValueError:\n version = 3.0\n return version", "docstring": "! Retrieve pyserial module version\n @return Returns float with pyserial module number" }, { "code": "def copy_layer(source, target):\n out_feature = QgsFeature()\n target.startEditing()\n request = QgsFeatureRequest()\n aggregation_layer = False\n if source.keywords.get('layer_purpose') == 'aggregation':\n try:\n use_selected_only = source.use_selected_features_only\n except AttributeError:\n use_selected_only = False\n if use_selected_only and source.selectedFeatureCount() > 0:\n request.setFilterFids(source.selectedFeatureIds())\n aggregation_layer = True\n for i, feature in enumerate(source.getFeatures(request)):\n geom = feature.geometry()\n if aggregation_layer and feature.hasGeometry():\n was_valid, geom = geometry_checker(geom)\n if not geom:\n LOGGER.info(\n 'One geometry in the aggregation layer is still invalid '\n 'after cleaning.')\n out_feature.setGeometry(geom)\n out_feature.setAttributes(feature.attributes())\n target.addFeature(out_feature)\n target.commitChanges()", "docstring": "Copy a vector layer to another one.\n\n :param source: The vector layer to copy.\n :type source: QgsVectorLayer\n\n :param target: The destination.\n :type source: QgsVectorLayer" }, { "code": "def size_filter(labeled_grid, min_size):\n out_grid = np.zeros(labeled_grid.shape, dtype=int)\n slices = find_objects(labeled_grid)\n j = 1\n for i, s in enumerate(slices):\n box = labeled_grid[s]\n size = np.count_nonzero(box.ravel() == (i + 1))\n if size >= min_size and box.shape[0] > 1 and box.shape[1] > 1:\n out_grid[np.where(labeled_grid == i + 1)] = j\n j += 1\n return out_grid", "docstring": "Remove labeled objects that do not meet size threshold criteria.\n\n Args:\n labeled_grid: 2D output from label method.\n min_size: minimum size of object in pixels.\n\n Returns:\n labeled grid with smaller objects removed." }, { "code": "def scan_used_functions(example_file, gallery_conf):\n example_code_obj = identify_names(example_file)\n if example_code_obj:\n codeobj_fname = example_file[:-3] + '_codeobj.pickle.new'\n with open(codeobj_fname, 'wb') as fid:\n pickle.dump(example_code_obj, fid, pickle.HIGHEST_PROTOCOL)\n _replace_md5(codeobj_fname)\n backrefs = set('{module_short}.{name}'.format(**entry)\n for entry in example_code_obj.values()\n if entry['module'].startswith(gallery_conf['doc_module']))\n return backrefs", "docstring": "save variables so we can later add links to the documentation" }, { "code": "def typewrite(message, interval=0.0, pause=None, _pause=True):\n interval = float(interval)\n _failSafeCheck()\n for c in message:\n if len(c) > 1:\n c = c.lower()\n press(c, _pause=False)\n time.sleep(interval)\n _failSafeCheck()\n _autoPause(pause, _pause)", "docstring": "Performs a keyboard key press down, followed by a release, for each of\n the characters in message.\n\n The message argument can also be list of strings, in which case any valid\n keyboard name can be used.\n\n Since this performs a sequence of keyboard presses and does not hold down\n keys, it cannot be used to perform keyboard shortcuts. Use the hotkey()\n function for that.\n\n Args:\n message (str, list): If a string, then the characters to be pressed. If a\n list, then the key names of the keys to press in order. The valid names\n are listed in KEYBOARD_KEYS.\n interval (float, optional): The number of seconds in between each press.\n 0.0 by default, for no pause in between presses.\n\n Returns:\n None" }, { "code": "def _get_app_module(self):\n def configure(binder):\n binder.bind(ServiceApplication, to=self, scope=singleton)\n binder.bind(Config, to=self.config, scope=singleton)\n return configure", "docstring": "Returns a module which binds the current app and configuration.\n\n :return: configuration callback\n :rtype: Callable" }, { "code": "def get(self, key):\n check_not_none(key, \"key can't be None\")\n key_data = self._to_data(key)\n return self._encode_invoke_on_key(multi_map_get_codec, key_data, key=key_data,\n thread_id=thread_id())", "docstring": "Returns the list of values associated with the key. ``None`` if this map does not contain this key.\n\n **Warning:\n This method uses hashCode and equals of the binary form of the key, not the actual implementations of hashCode\n and equals defined in the key's class.**\n\n **Warning-2:\n The list is NOT backed by the multimap, so changes to the map are list reflected in the collection, and\n vice-versa.**\n\n :param key: (object), the specified key.\n :return: (Sequence), the list of the values associated with the specified key." }, { "code": "def SampleSum(dists, n):\n pmf = MakePmfFromList(RandomSum(dists) for i in xrange(n))\n return pmf", "docstring": "Draws a sample of sums from a list of distributions.\n\n dists: sequence of Pmf or Cdf objects\n n: sample size\n\n returns: new Pmf of sums" }, { "code": "def source(self, value):\n if not isinstance(value, tuple) or len(value) != 2:\n raise AttributeError\n self._source = value", "docstring": "Set the source of the message.\n\n :type value: tuple\n :param value: (ip, port)\n :raise AttributeError: if value is not a ip and a port." }, { "code": "def set_peer_link(self, value=None, default=False, disable=False):\n return self._configure_mlag('peer-link', value, default, disable)", "docstring": "Configures the mlag peer-link value\n\n Args:\n value (str): The value to configure the peer-link\n default (bool): Configures the peer-link using the\n default keyword\n disable (bool): Negates the peer-link using the no keyword\n\n Returns:\n bool: Returns True if the commands complete successfully" }, { "code": "def _css_helper(self):\n entries = [entry for entry in self._plugin_manager.call_hook(\"css\") if entry is not None]\n entries += self._get_ctx()[\"css\"]\n entries = [\"\" for entry in entries]\n return \"\\n\".join(entries)", "docstring": "Add CSS links for the current page and for the plugins" }, { "code": "def _get_stats_from_socket(self, name):\n try:\n json_blob = subprocess.check_output(\n [self.config['ceph_binary'],\n '--admin-daemon',\n name,\n 'perf',\n 'dump',\n ])\n except subprocess.CalledProcessError as err:\n self.log.info('Could not get stats from %s: %s',\n name, err)\n self.log.exception('Could not get stats from %s' % name)\n return {}\n try:\n json_data = json.loads(json_blob)\n except Exception as err:\n self.log.info('Could not parse stats from %s: %s',\n name, err)\n self.log.exception('Could not parse stats from %s' % name)\n return {}\n return json_data", "docstring": "Return the parsed JSON data returned when ceph is told to\n dump the stats from the named socket.\n\n In the event of an error error, the exception is logged, and\n an empty result set is returned." }, { "code": "def inventory(self, all=False, ssid=None):\n if all or self.api_key is None:\n if ssid is not None:\n return self._ssid_inventory(self.full_inventory, ssid)\n else:\n return self.full_inventory\n else:\n if ssid is not None:\n return self._ssid_inventory(self.self_inventory, ssid)\n else:\n return self.self_inventory", "docstring": "Returns a node inventory. If an API key is specified, only the nodes\n provisioned by this key will be returned.\n\n :return: { inventory }" }, { "code": "def __store_cash_balances_per_currency(self, cash_balances):\n cash = self.model.get_cash_asset_class()\n for cur_symbol in cash_balances:\n item = CashBalance(cur_symbol)\n item.parent = cash\n quantity = cash_balances[cur_symbol][\"total\"]\n item.value = Decimal(quantity)\n item.currency = cur_symbol\n cash.stocks.append(item)\n self.model.stocks.append(item)", "docstring": "Store balance per currency as Stock records under Cash class" }, { "code": "def _create_response_record(self, response):\n record = dict()\n record['id'] = response['id']\n record['type'] = response['type']\n record['name'] = self._full_name(response['name'])\n if 'content' in response:\n record['content'] = response['content'] or \"\"\n if 'ttl' in response:\n record['ttl'] = response['ttl']\n if 'prio' in response:\n record['priority'] = response['prio']\n return record", "docstring": "Creates record for lexicon API calls" }, { "code": "def calcDrawingProbs(self):\n wmg = self.wmg\n phi = self.phi\n weights = []\n for i in range(0, len(wmg.keys())):\n weights.append(phi**i)\n totalWeight = sum(weights)\n for i in range(0, len(wmg.keys())):\n weights[i] = weights[i]/totalWeight\n return weights", "docstring": "Returns a vector that contains the probabily of an item being from each position. We say\n that every item in a order vector is drawn with weight phi^i where i is its position." }, { "code": "def generate(env):\n SCons.Tool.createSharedLibBuilder(env)\n SCons.Tool.createProgBuilder(env)\n env['LINK'] = '$CC'\n env['LINKFLAGS'] = SCons.Util.CLVar('')\n env['LINKCOM'] = '$LINK -q $LINKFLAGS -e$TARGET $SOURCES $LIBS'\n env['LIBDIRPREFIX']=''\n env['LIBDIRSUFFIX']=''\n env['LIBLINKPREFIX']=''\n env['LIBLINKSUFFIX']='$LIBSUFFIX'", "docstring": "Add Builders and construction variables for Borland ilink to an\n Environment." }, { "code": "def timedelta_seconds(timedelta):\r\n return (timedelta.total_seconds() if hasattr(timedelta, \"total_seconds\")\r\n else timedelta.days * 24 * 3600 + timedelta.seconds +\r\n timedelta.microseconds / 1000000.)", "docstring": "Returns the total timedelta duration in seconds." }, { "code": "def group(self):\n split_count = self._url.lower().find(\"/content/\")\n len_count = len('/content/')\n gURL = self._url[:self._url.lower().find(\"/content/\")] + \\\n \"/community/\" + self._url[split_count+ len_count:]\n return CommunityGroup(url=gURL,\n securityHandler=self._securityHandler,\n proxy_url=self._proxy_url,\n proxy_port=self._proxy_port)", "docstring": "returns the community.Group class for the current group" }, { "code": "def get_thermostat_state_by_id(self, id_):\n return next((state for state in self.thermostat_states\n if state.id == id_), None)", "docstring": "Retrieves a thermostat state object by its id\n\n :param id_: The id of the thermostat state\n :return: The thermostat state object" }, { "code": "def get_cluster_port_names(self, cluster_name):\r\n port_names = list()\r\n for host_name in self.get_hosts_by_clusters()[cluster_name]:\r\n port_names.extend(self.get_hosts_by_name(host_name))\r\n return port_names", "docstring": "return a list of the port names under XIV CLuster" }, { "code": "def find_link(self, href_pattern, make_absolute=True):\n if make_absolute:\n self.tree.make_links_absolute(self.doc.url)\n if isinstance(href_pattern, six.text_type):\n raise GrabMisuseError('Method `find_link` accepts only '\n 'byte-string argument')\n href_pattern = make_unicode(href_pattern)\n for elem, _, link, _ in self.tree.iterlinks():\n if elem.tag == 'a' and href_pattern in link:\n return link\n return None", "docstring": "Find link in response body which href value matches ``href_pattern``.\n\n Returns found url or None." }, { "code": "def update(self, **kwargs):\n ret_val = super(ManagerUtilsQuerySet, self).update(**kwargs)\n post_bulk_operation.send(sender=self.model, model=self.model)\n return ret_val", "docstring": "Overrides Django's update method to emit a post_bulk_operation signal when it completes." }, { "code": "def unsubscribe(self, topic):\n if self.sock == NC.INVALID_SOCKET:\n return NC.ERR_NO_CONN\n self.logger.info(\"UNSUBSCRIBE: %s\", topic)\n return self.send_unsubscribe(False, [utf8encode(topic)])", "docstring": "Unsubscribe to some topic." }, { "code": "def write(notebook, file_or_stream, fmt, version=nbformat.NO_CONVERT, **kwargs):\n text = u'' + writes(notebook, fmt, version, **kwargs)\n file_or_stream.write(text)\n if not text.endswith(u'\\n'):\n file_or_stream.write(u'\\n')", "docstring": "Write a notebook to a file" }, { "code": "def _parse_signed_int_components(buf):\n sign_bit = 0\n value = 0\n first = True\n while True:\n ch = buf.read(1)\n if ch == b'':\n break\n octet = ord(ch)\n if first:\n if octet & _SIGNED_INT_SIGN_MASK:\n sign_bit = 1\n value = octet & _SIGNED_INT_SIGN_VALUE_MASK\n first = False\n else:\n value <<= 8\n value |= octet\n return sign_bit, value", "docstring": "Parses the remainder of a file-like object as a signed magnitude value.\n\n Returns:\n Returns a pair of the sign bit and the unsigned magnitude." }, { "code": "def rprof(self):\n if self.istep not in self.sdat.rprof.index.levels[0]:\n return None\n return self.sdat.rprof.loc[self.istep]", "docstring": "Radial profiles data of the time step.\n\n Set to None if no radial profiles data is available for this time step." }, { "code": "def dict_stack(dict_list, key_prefix=''):\n r\n dict_stacked_ = defaultdict(list)\n for dict_ in dict_list:\n for key, val in six.iteritems(dict_):\n dict_stacked_[key_prefix + key].append(val)\n dict_stacked = dict(dict_stacked_)\n return dict_stacked", "docstring": "r\"\"\"\n stacks values from two dicts into a new dict where the values are list of\n the input values. the keys are the same.\n\n DEPRICATE in favor of dict_stack2\n\n Args:\n dict_list (list): list of dicts with similar keys\n\n Returns:\n dict dict_stacked\n\n CommandLine:\n python -m utool.util_dict --test-dict_stack\n python -m utool.util_dict --test-dict_stack:1\n\n Example:\n >>> # ENABLE_DOCTEST\n >>> from utool.util_dict import * # NOQA\n >>> import utool as ut\n >>> dict1_ = {'a': 1, 'b': 2}\n >>> dict2_ = {'a': 2, 'b': 3, 'c': 4}\n >>> dict_stacked = dict_stack([dict1_, dict2_])\n >>> result = ut.repr2(dict_stacked, sorted_=True)\n >>> print(result)\n {'a': [1, 2], 'b': [2, 3], 'c': [4]}\n\n Example1:\n >>> # ENABLE_DOCTEST\n >>> from utool.util_dict import * # NOQA\n >>> import utool as ut\n >>> # Get equivalent behavior with dict_stack2?\n >>> # Almost, as long as None is not part of the list\n >>> dict1_ = {'a': 1, 'b': 2}\n >>> dict2_ = {'a': 2, 'b': 3, 'c': 4}\n >>> dict_stacked_ = dict_stack2([dict1_, dict2_])\n >>> dict_stacked = {key: ut.filter_Nones(val) for key, val in dict_stacked_.items()}\n >>> result = ut.repr2(dict_stacked, sorted_=True)\n >>> print(result)\n {'a': [1, 2], 'b': [2, 3], 'c': [4]}" }, { "code": "def within_polygon(self, polygon, distance=None, **kwargs):\n if distance:\n zone_polygon = polygon.dilate(distance)\n else:\n zone_polygon = polygon\n upper_depth, lower_depth = _check_depth_limits(kwargs)\n valid_depth = np.logical_and(\n self.catalogue.data['depth'] >= upper_depth,\n self.catalogue.data['depth'] < lower_depth)\n catalogue_mesh = Mesh(self.catalogue.data['longitude'],\n self.catalogue.data['latitude'],\n self.catalogue.data['depth'])\n valid_id = np.logical_and(valid_depth,\n zone_polygon.intersects(catalogue_mesh))\n return self.select_catalogue(valid_id)", "docstring": "Select earthquakes within polygon\n\n :param polygon:\n Centre point as instance of nhlib.geo.polygon.Polygon class\n\n :param float distance:\n Buffer distance (km) (can take negative values)\n\n :returns:\n Instance of :class:`openquake.hmtk.seismicity.catalogue.Catalogue`\n containing only selected events" }, { "code": "def annotate(self, sent):\n preds = []\n words = []\n for word, fv in self.sent2examples(sent):\n probs = self.predictor(fv)\n tags = probs.argsort()\n tag = self.ID_TAG[tags[-1]]\n words.append(word)\n preds.append(tag)\n annotations = zip(words, preds)\n return annotations", "docstring": "Annotate a squence of words with entity tags.\n\n Args:\n sent: sequence of strings/words." }, { "code": "def generate(variables, template):\n env = jinja2.Environment(undefined=jinja2.StrictUndefined)\n for c in expand(variables):\n c['rc'] = rc\n yield env.from_string(template).render(c)", "docstring": "Yields a resolved \"template\" for each config set and dumps on output\n\n This function will extrapolate the ``template`` file using the contents of\n ``variables`` and will output individual (extrapolated, expanded) files in\n the output directory ``output``.\n\n\n Parameters:\n\n variables (str): A string stream containing the variables to parse, in YAML\n format as explained on :py:func:`expand`.\n\n template (str): A string stream containing the template to extrapolate\n\n\n Yields:\n\n str: A generated template you can save\n\n\n Raises:\n\n jinja2.UndefinedError: if a variable used in the template is undefined" }, { "code": "def transform(self, data=None):\n if data is None:\n return self.xform_data\n else:\n formatted = format_data(\n data,\n semantic=self.semantic,\n vectorizer=self.vectorizer,\n corpus=self.corpus,\n ppca=True)\n norm = normalizer(formatted, normalize=self.normalize)\n reduction = reducer(\n norm,\n reduce=self.reduce,\n ndims=self.reduce['params']['n_components'])\n return aligner(reduction, align=self.align)", "docstring": "Return transformed data, or transform new data using the same model\n parameters\n\n Parameters\n ----------\n data : numpy array, pandas dataframe or list of arrays/dfs\n The data to transform. If no data is passed, the xform_data from\n the DataGeometry object will be returned.\n\n Returns\n ----------\n xformed_data : list of numpy arrays\n The transformed data" }, { "code": "def _function_add_node(self, cfg_node, function_addr):\n snippet = self._to_snippet(cfg_node=cfg_node)\n self.kb.functions._add_node(function_addr, snippet)", "docstring": "Adds node to function manager, converting address to CodeNode if\n possible\n\n :param CFGNode cfg_node: A CFGNode instance.\n :param int function_addr: Address of the current function.\n :return: None" }, { "code": "def _py_ex_argtype(executable):\n result = []\n for p in executable.ordered_parameters:\n atypes = p.argtypes\n if atypes is not None:\n result.extend(p.argtypes)\n else:\n print((\"No argtypes for: {}\".format(p.definition())))\n if type(executable).__name__ == \"Function\":\n result.extend(executable.argtypes) \n return result", "docstring": "Returns the code to create the argtype to assign to the methods argtypes\n attribute." }, { "code": "def check_config(self, config, name=''):\n config = config.get(self.config_name, {})\n extras = set(config.keys()).difference(self.default_config)\n if 'config' not in self.services and extras:\n raise ConfigurationError(\n 'Unsupported config options for \"%s\": %s'\n % (self.config_name, ', '.join(extras)))\n missing = set(self.default_config).difference(config)\n if missing:\n raise ConfigurationError(\n 'Missing config options for \"%s\": %s'\n % (self.config_name, ', '.join(missing)))\n duplicates = set(config.keys()).intersection(set(self.services))\n if duplicates:\n raise ConfigurationError(\n 'Disallowed config options for \"%s\": %s'\n % (self.config_name, ', '.join(duplicates)))", "docstring": "Check that the configuration for this object is valid.\n\n This is a more restrictive check than for most :mod:`yakonfig`\n objects. It will raise :exc:`yakonfig.ConfigurationError` if\n `config` contains any keys that are not in the underlying\n callable's parameter list (that is, extra unused configuration\n options). This will also raise an exception if `config`\n contains keys that duplicate parameters that should be\n provided by the factory.\n\n .. note:: This last behavior is subject to change; future\n versions of the library may allow configuration to\n provide local configuration for a factory-provided\n object.\n\n :param dict config: the parent configuration dictionary,\n probably contains :attr:`config_name` as a key\n :param str name: qualified name of this object in the configuration\n :raise: :exc:`yakonfig.ConfigurationError` if excess parameters exist" }, { "code": "def skipline(self):\n position = self.tell()\n prefix = self._fix()\n self.seek(prefix, 1)\n suffix = self._fix()\n if prefix != suffix:\n raise IOError(_FIX_ERROR)\n return position, prefix", "docstring": "Skip the next line and returns position and size of line.\n Raises IOError if pre- and suffix of line do not match." }, { "code": "def unmatched_quotes_in_line(text):\n text = text.replace(\"\\\\'\", \"\")\n text = text.replace('\\\\\"', '')\n if text.count('\"') % 2:\n return '\"'\n elif text.count(\"'\") % 2:\n return \"'\"\n else:\n return ''", "docstring": "Return whether a string has open quotes.\n\n This simply counts whether the number of quote characters of either\n type in the string is odd.\n\n Take from the IPython project (in IPython/core/completer.py in v0.13)\n Spyder team: Add some changes to deal with escaped quotes\n\n - Copyright (C) 2008-2011 IPython Development Team\n - Copyright (C) 2001-2007 Fernando Perez. \n - Copyright (C) 2001 Python Software Foundation, www.python.org\n\n Distributed under the terms of the BSD License." }, { "code": "def get_processing_block_ids():\n ids = []\n for key in sorted(DB.keys(pattern='scheduling_block/*')):\n config = json.loads(DB.get(key))\n for processing_block in config['processing_blocks']:\n ids.append(processing_block['id'])\n return ids", "docstring": "Return an array of Processing Block ids" }, { "code": "def _handle_info(self, *args, **kwargs):\n if 'version' in kwargs:\n self.api_version = kwargs['version']\n print(\"Initialized API with version %s\" % self.api_version)\n return\n try:\n info_code = str(kwargs['code'])\n except KeyError:\n raise FaultyPayloadError(\"_handle_info: %s\" % kwargs)\n if not info_code.startswith('2'):\n raise ValueError(\"Info Code must start with 2! %s\", kwargs)\n output_msg = \"_handle_info(): %s\" % kwargs\n log.info(output_msg)\n try:\n self._code_handlers[info_code]()\n except KeyError:\n raise UnknownWSSInfo(output_msg)", "docstring": "Handles info messages and executed corresponding code" }, { "code": "def fetch(self):\n returnResults = []\n results = self._query.run()\n for result in results:\n if self._join:\n item = self._model.fromRawEntry(**result[\"left\"])\n joined = self._join.fromRawEntry(**result[\"right\"])\n item.protectedItems = self._joinedField\n item[self._joinedField] = joined\n else:\n item = self._model.fromRawEntry(**result)\n returnResults.append(item)\n self._documents = returnResults\n return self._documents", "docstring": "Fetches the query and then tries to wrap the data in the model, joining\n as needed, if applicable." }, { "code": "def system(self):\n url = self._url + \"/system\"\n return _System(url=url,\n securityHandler=self._securityHandler,\n proxy_url=self._proxy_url,\n proxy_port=self._proxy_port)", "docstring": "Creates a reference to the System operations for Portal" }, { "code": "def get_endpoints_using_catalog_api(domain, token):\n headers = {\"X-App-Token\": token}\n uri = \"http://api.us.socrata.com/api/catalog/v1?domains={0}&offset={1}&limit=1000\"\n ret = []\n endpoints_thus_far = set()\n offset = 0\n while True:\n try:\n r = requests.get(uri.format(domain, offset), headers=headers)\n r.raise_for_status()\n except requests.HTTPError:\n raise requests.HTTPError(\"An HTTP error was raised during Socrata API ingestion.\".format(domain))\n data = r.json()\n endpoints_returned = {r['resource']['id'] for r in data['results']}\n new_endpoints = endpoints_returned.difference(endpoints_thus_far)\n if len(new_endpoints) >= 999:\n ret += data['results']\n endpoints_thus_far.update(new_endpoints)\n offset += 1000\n continue\n else:\n ret += [r for r in data['results'] if r['resource']['id'] in new_endpoints]\n break\n return ret", "docstring": "Implements a raw HTTP GET against the entire Socrata portal for the domain in question. This method uses the\n second of the two ways of getting this information, the catalog API.\n\n Parameters\n ----------\n domain: str\n A Socrata data portal domain. \"data.seattle.gov\" or \"data.cityofnewyork.us\" for example.\n token: str\n A Socrata application token. Application tokens can be registered by going onto the Socrata portal in\n question, creating an account, logging in, going to developer tools, and spawning a token.\n\n Returns\n -------\n Portal dataset metadata from the catalog API." }, { "code": "def warp_locations(locations, y_center=None, return_ellipsoid=False, verbose=False):\n locations = np.asarray(locations)\n if y_center is None:\n c, r = _fit_ellipsoid_full(locations)\n else:\n c, r = _fit_ellipsoid_partial(locations, y_center)\n elliptic_locations = _project_on_ellipsoid(c, r, locations)\n if verbose:\n print('Head ellipsoid center:', c)\n print('Head ellipsoid radii:', r)\n distance = np.sqrt(np.sum((locations - elliptic_locations)**2, axis=1))\n print('Minimum electrode displacement:', np.min(distance))\n print('Average electrode displacement:', np.mean(distance))\n print('Maximum electrode displacement:', np.max(distance))\n spherical_locations = (elliptic_locations - c) / r\n if return_ellipsoid:\n return spherical_locations, c, r\n return spherical_locations", "docstring": "Warp EEG electrode locations to spherical layout.\n\n EEG Electrodes are warped to a spherical layout in three steps:\n 1. An ellipsoid is least-squares-fitted to the electrode locations.\n 2. Electrodes are displaced to the nearest point on the ellipsoid's surface.\n 3. The ellipsoid is transformed to a sphere, causing the new locations to lie exactly on a spherical surface\n with unit radius.\n\n This procedure intends to minimize electrode displacement in the original coordinate space. Simply projecting\n electrodes on a sphere (e.g. by normalizing the x/y/z coordinates) typically gives much larger displacements.\n\n Parameters\n ----------\n locations : array-like, shape = [n_electrodes, 3]\n Eeach row of `locations` corresponds to the location of an EEG electrode in cartesian x/y/z coordinates.\n y_center : float, optional\n Fix the y-coordinate of the ellipsoid's center to this value (optional). This is useful to align the ellipsoid\n with the central electrodes.\n return_ellipsoid : bool, optional\n If `true` center and radii of the ellipsoid are returned.\n\n Returns\n -------\n newlocs : array-like, shape = [n_electrodes, 3]\n Electrode locations on unit sphere.\n c : array-like, shape = [3], (only returned if `return_ellipsoid` evaluates to `True`)\n Center of the ellipsoid in the original location's coordinate space.\n r : array-like, shape = [3], (only returned if `return_ellipsoid` evaluates to `True`)\n Radii (x, y, z) of the ellipsoid in the original location's coordinate space." }, { "code": "def all_library_calls(self):\n if self._all_library_calls is None:\n self._all_library_calls = self._explore_functions(lambda x: x.library_calls)\n return self._all_library_calls", "docstring": "recursive version of library calls" }, { "code": "def reply_inform(cls, req_msg, *args):\n return cls(cls.INFORM, req_msg.name, args, req_msg.mid)", "docstring": "Helper method for creating inform messages in reply to a request.\n\n Copies the message name and message identifier from request message.\n\n Parameters\n ----------\n req_msg : katcp.core.Message instance\n The request message that this inform if in reply to\n args : list of strings\n The message arguments except name" }, { "code": "def cancel_room(self, booking_id):\n resp = self._request(\"POST\", \"/1.1/space/cancel/{}\".format(booking_id))\n return resp.json()", "docstring": "Cancel a room given a booking id.\n\n :param booking_id: A booking id or a list of booking ids (separated by commas) to cancel.\n :type booking_id: str" }, { "code": "def build(self):\n if self.colour:\n embed = discord.Embed(\n title=self.title,\n type='rich',\n description=self.description,\n colour=self.colour)\n else:\n embed = discord.Embed(\n title=self.title,\n type='rich',\n description=self.description)\n if self.thumbnail:\n embed.set_thumbnail(url=self.thumbnail)\n if self.image:\n embed.set_image(url=self.image)\n embed.set_author(\n name=\"Modis\",\n url=\"https://musicbyango.com/modis/\",\n icon_url=\"http://musicbyango.com/modis/dp/modis64t.png\")\n for pack in self.datapacks:\n embed.add_field(\n name=pack[0],\n value=pack[1],\n inline=pack[2]\n )\n return embed", "docstring": "Builds Discord embed GUI\n\n Returns:\n discord.Embed: Built GUI" }, { "code": "def printParams(paramDictionary, all=False, log=None):\n if log is not None:\n def output(msg):\n log.info(msg)\n else:\n def output(msg):\n print(msg)\n if not paramDictionary:\n output('No parameters were supplied')\n else:\n for key in sorted(paramDictionary):\n if all or (not isinstance(paramDictionary[key], dict)) \\\n and key[0] != '_':\n output('\\t' + '\\t'.join([str(key) + ' :',\n str(paramDictionary[key])]))\n if log is None:\n output('\\n')", "docstring": "Print nicely the parameters from the dictionary." }, { "code": "def check_num(self, checks, radl):\n prefixes = {}\n for f in self.features:\n if not isinstance(f, Feature):\n continue\n (prefix, sep, tail) = f.prop.partition(\".\")\n if not sep or prefix not in checks:\n continue\n checks0 = checks[prefix]\n (num, sep, suffix) = tail.partition(\".\")\n try:\n num = int(num)\n except:\n raise RADLParseException(\n \"Invalid property name; expected an index.\", line=f.line)\n if not sep or suffix not in checks0:\n continue\n f._check(checks0[suffix], radl)\n if prefix not in prefixes:\n prefixes[prefix] = set()\n prefixes[prefix].add(num)\n for prefix, nums in prefixes.items():\n if min(nums) != 0 or max(nums) != len(nums) - 1:\n raise RADLParseException(\n \"Invalid indices values in properties '%s'\" % prefix)\n return prefixes", "docstring": "Check types, operators and units in features with numbers.\n\n Args:\n\n - checks(dict of dict of str:tuples): keys are property name prefixes, and the\n values are dict with keys are property name suffixes and values are iterable\n as in ``_check_feature``.\n - radl: passed to ``_check_feature``." }, { "code": "def template(self):\n\t\ts = Template(self._IPTABLES_TEMPLATE)\n\t\treturn s.substitute(filtertable='\\n'.join(self.filters),\n\t\t\t\t\t\t\trawtable='\\n'.join(self.raw),\n\t\t\t\t\t\t\tmangletable='\\n'.join(self.mangle),\n\t\t\t\t\t\t\tnattable='\\n'.join(self.nat),\n\t\t\t\t\t\t\tdate=datetime.today())", "docstring": "Create a rules file in iptables-restore format" }, { "code": "def bb_get_instr_max_width(basic_block):\n asm_mnemonic_max_width = 0\n for instr in basic_block:\n if len(instr.mnemonic) > asm_mnemonic_max_width:\n asm_mnemonic_max_width = len(instr.mnemonic)\n return asm_mnemonic_max_width", "docstring": "Get maximum instruction mnemonic width" }, { "code": "def _get_object_key(self, p_object):\n matched_key = None\n matched_index = None\n if hasattr(p_object, self._searchNames[0]):\n return getattr(p_object, self._searchNames[0])\n for x in xrange(len(self._searchNames)):\n key = self._searchNames[x]\n if hasattr(p_object, key):\n matched_key = key\n matched_index = x\n if matched_key is None:\n raise KeyError()\n if matched_index != 0 and self._searchOptimize:\n self._searchNames.insert(0, self._searchNames.pop(matched_index))\n return getattr(p_object, matched_key)", "docstring": "Get key from object" }, { "code": "def grep_file(query, item):\n return ['%s: %s' % (item, line) for line in open(item)\n if re.search(query, line)]", "docstring": "This function performs the actual grep on a given file." }, { "code": "def _make_sync_method(name):\n def sync_wrapper(self, *args, **kwds):\n method = getattr(self, name)\n future = method(*args, **kwds)\n return future.get_result()\n return sync_wrapper", "docstring": "Helper to synthesize a synchronous method from an async method name.\n\n Used by the @add_sync_methods class decorator below.\n\n Args:\n name: The name of the synchronous method.\n\n Returns:\n A method (with first argument 'self') that retrieves and calls\n self., passing its own arguments, expects it to return a\n Future, and then waits for and returns that Future's result." }, { "code": "def save_credentials(self, profile):\n filename = profile_path(S3_PROFILE_ID, profile)\n creds = {\n \"access_key\": self.access_key,\n \"secret_key\": self.secret_key\n }\n dump_to_json(filename, creds)", "docstring": "Saves credentials to a dotfile so you can open them grab them later.\n\n Parameters\n ----------\n profile: str\n name for your profile (i.e. \"dev\", \"prod\")" }, { "code": "def _create_serial_ports(serial_ports):\n ports = []\n keys = range(-9000, -9050, -1)\n if serial_ports:\n devs = [serial['adapter'] for serial in serial_ports]\n log.trace('Creating serial ports %s', devs)\n for port, key in zip(serial_ports, keys):\n serial_port_device = _apply_serial_port(port, key, 'add')\n ports.append(serial_port_device)\n return ports", "docstring": "Returns a list of vim.vm.device.VirtualDeviceSpec objects representing the\n serial ports to be created for a virtual machine\n\n serial_ports\n Serial port properties" }, { "code": "def warning(self, msg, indent=0, **kwargs):\n return self.logger.warning(self._indent(msg, indent), **kwargs)", "docstring": "invoke ``self.logger.warning``" }, { "code": "def get_top_tags(self, limit=None, cacheable=True):\n doc = _Request(self, \"tag.getTopTags\").execute(cacheable)\n seq = []\n for node in doc.getElementsByTagName(\"tag\"):\n if limit and len(seq) >= limit:\n break\n tag = Tag(_extract(node, \"name\"), self)\n weight = _number(_extract(node, \"count\"))\n seq.append(TopItem(tag, weight))\n return seq", "docstring": "Returns the most used tags as a sequence of TopItem objects." }, { "code": "def set_extent_location(self, new_location, main_vd_extent, reserve_vd_extent):\n if not self._initialized:\n raise pycdlibexception.PyCdlibInternalError('UDF Anchor Volume Structure not yet initialized')\n self.new_extent_loc = new_location\n self.desc_tag.tag_location = new_location\n self.main_vd_extent = main_vd_extent\n self.reserve_vd_extent = reserve_vd_extent", "docstring": "A method to set a new location for this Anchor Volume Structure.\n\n Parameters:\n new_location - The new extent that this Anchor Volume Structure should be located at.\n main_vd_extent - The extent containing the main Volume Descriptors.\n reserve_vd_extent - The extent containing the reserve Volume Descriptors.\n Returns:\n Nothing." }, { "code": "def destination(self):\n return os.path.join(os.path.abspath(self.outdir), self.filename)", "docstring": "Get the destination path.\n\n This is the property should be calculated every time it is used because\n a user could change the outdir and filename dynamically." }, { "code": "def write(self, obj, **kwargs):\n super().write(obj, **kwargs)\n for name, ss in obj.items():\n key = 'sparse_series_{name}'.format(name=name)\n if key not in self.group._v_children:\n node = self._handle.create_group(self.group, key)\n else:\n node = getattr(self.group, key)\n s = SparseSeriesFixed(self.parent, node)\n s.write(ss)\n self.attrs.default_fill_value = obj.default_fill_value\n self.attrs.default_kind = obj.default_kind\n self.write_index('columns', obj.columns)", "docstring": "write it as a collection of individual sparse series" }, { "code": "def add2python(self, module=None, up=0, down=None, front=False,\n must_exist=True):\n if module:\n try:\n return import_module(module)\n except ImportError:\n pass\n dir = self.dir().ancestor(up)\n if down:\n dir = dir.join(*down)\n if dir.isdir():\n if dir not in sys.path:\n if front:\n sys.path.insert(0, dir)\n else:\n sys.path.append(dir)\n elif must_exist:\n raise ImportError('Directory {0} not available'.format(dir))\n else:\n return None\n if module:\n try:\n return import_module(module)\n except ImportError:\n if must_exist:\n raise", "docstring": "Add a directory to the python path.\n\n :parameter module: Optional module name to try to import once we\n have found the directory\n :parameter up: number of level to go up the directory three from\n :attr:`local_path`.\n :parameter down: Optional tuple of directory names to travel down\n once we have gone *up* levels.\n :parameter front: Boolean indicating if we want to insert the new\n path at the front of ``sys.path`` using\n ``sys.path.insert(0,path)``.\n :parameter must_exist: Boolean indicating if the module must exists." }, { "code": "def _linux_stp(br, state):\n brctl = _tool_path('brctl')\n return __salt__['cmd.run']('{0} stp {1} {2}'.format(brctl, br, state),\n python_shell=False)", "docstring": "Internal, sets STP state" }, { "code": "def fail_request(self, orig_request, message, start_response):\n cors_handler = self._create_cors_handler(orig_request)\n return util.send_wsgi_error_response(\n message, start_response, cors_handler=cors_handler)", "docstring": "Write an immediate failure response to outfile, no redirect.\n\n This calls start_response and returns the error body.\n\n Args:\n orig_request: An ApiRequest, the original request from the user.\n message: A string containing the error message to be displayed to user.\n start_response: A function with semantics defined in PEP-333.\n\n Returns:\n A string containing the body of the error response." }, { "code": "def adj_nodes_aws(aws_nodes):\n for node in aws_nodes:\n node.cloud = \"aws\"\n node.cloud_disp = \"AWS\"\n node.private_ips = ip_to_str(node.private_ips)\n node.public_ips = ip_to_str(node.public_ips)\n node.zone = node.extra['availability']\n node.size = node.extra['instance_type']\n node.type = node.extra['instance_lifecycle']\n return aws_nodes", "docstring": "Adjust details specific to AWS." }, { "code": "def timestamp(num_params, p_levels, k_choices, N):\n string = \"_v%s_l%s_gs%s_k%s_N%s_%s.txt\" % (num_params,\n p_levels,\n k_choices,\n N,\n dt.strftime(dt.now(),\n \"%d%m%y%H%M%S\"))\n return string", "docstring": "Returns a uniform timestamp with parameter values for file identification" }, { "code": "def mod(self):\n if self._mod is None:\n self._mod = self.compile_and_import_binary()\n return self._mod", "docstring": "Cached compiled binary of the Generic_Code class.\n\n To clear cache invoke :meth:`clear_mod_cache`." }, { "code": "def get_users(self, fetch=True):\n return Users(self.resource.users, self.client, populate=fetch)", "docstring": "Return this Applications's users object, populating it if fetch\n is True." }, { "code": "def setCmd(self, cmd):\n cmd = cmd.upper()\n if cmd not in VALID_COMMANDS:\n raise FrameError(\"The cmd '%s' is not valid! It must be one of '%s' (STOMP v%s).\" % (\n cmd, VALID_COMMANDS, STOMP_VERSION)\n )\n else:\n self._cmd = cmd", "docstring": "Check the cmd is valid, FrameError will be raised if its not." }, { "code": "def expression_list_to_conjunction(expression_list):\n if not isinstance(expression_list, list):\n raise AssertionError(u'Expected `list`, Received {}.'.format(expression_list))\n if len(expression_list) == 0:\n return TrueLiteral\n if not isinstance(expression_list[0], Expression):\n raise AssertionError(u'Non-Expression object {} found in expression_list'\n .format(expression_list[0]))\n if len(expression_list) == 1:\n return expression_list[0]\n else:\n return BinaryComposition(u'&&',\n expression_list_to_conjunction(expression_list[1:]),\n expression_list[0])", "docstring": "Convert a list of expressions to an Expression that is the conjunction of all of them." }, { "code": "def modify(self, vals):\n self.vals = vals.view(np.ndarray).copy()\n y = self.model.predict(self.vals)[0]\n self.data_visualize.modify(y)\n self.latent_handle.set_data(self.vals[0,self.latent_index[0]], self.vals[0,self.latent_index[1]])\n self.axes.figure.canvas.draw()", "docstring": "When latent values are modified update the latent representation and ulso update the output visualization." }, { "code": "def to_feature(self, name=None, feature_type='misc_feature'):\n if name is None:\n if not self.name:\n raise ValueError('name attribute missing from DNA instance'\n ' and arguments')\n name = self.name\n return Feature(name, start=0, stop=len(self),\n feature_type=feature_type)", "docstring": "Create a feature from the current object.\n\n :param name: Name for the new feature. Must be specified if the DNA\n instance has no .name attribute.\n :type name: str\n :param feature_type: The type of feature (genbank standard).\n :type feature_type: str" }, { "code": "def account(transition, direction=Direction.BIDIRECTIONAL):\n if direction != Direction.BIDIRECTIONAL:\n return directed_account(transition, direction)\n return Account(directed_account(transition, Direction.CAUSE) +\n directed_account(transition, Direction.EFFECT))", "docstring": "Return the set of all causal links for a |Transition|.\n\n Args:\n transition (Transition): The transition of interest.\n\n Keyword Args:\n direction (Direction): By default the account contains actual causes\n and actual effects." }, { "code": "def from_file(cls, filename=\"CTRL\", **kwargs):\n with zopen(filename, \"rt\") as f:\n contents = f.read()\n return LMTOCtrl.from_string(contents, **kwargs)", "docstring": "Creates a CTRL file object from an existing file.\n\n Args:\n filename: The name of the CTRL file. Defaults to 'CTRL'.\n\n Returns:\n An LMTOCtrl object." }, { "code": "async def detach_tip(data):\n global session\n if not feature_flags.use_protocol_api_v2():\n pipette = session.pipettes[session.current_mount]\n if not pipette.tip_attached:\n log.warning('detach tip called with no tip')\n pipette._remove_tip(session.tip_length)\n else:\n session.adapter.remove_tip(session.current_mount)\n if session.cp:\n session.cp = CriticalPoint.NOZZLE\n session.tip_length = None\n return web.json_response({'message': \"Tip removed\"}, status=200)", "docstring": "Detach the tip from the current pipette\n\n :param data: Information obtained from a POST request.\n The content type is application/json.\n The correct packet form should be as follows:\n {\n 'token': UUID token from current session start\n 'command': 'detach tip'\n }" }, { "code": "def attention_lm_decoder(decoder_input,\n decoder_self_attention_bias,\n hparams,\n name=\"decoder\"):\n x = decoder_input\n with tf.variable_scope(name):\n for layer in range(hparams.num_hidden_layers):\n with tf.variable_scope(\"layer_%d\" % layer):\n with tf.variable_scope(\"self_attention\"):\n y = common_attention.multihead_attention(\n common_layers.layer_preprocess(\n x, hparams), None, decoder_self_attention_bias,\n hparams.attention_key_channels or hparams.hidden_size,\n hparams.attention_value_channels or hparams.hidden_size,\n hparams.hidden_size, hparams.num_heads, hparams.attention_dropout)\n x = common_layers.layer_postprocess(x, y, hparams)\n with tf.variable_scope(\"ffn\"):\n y = common_layers.conv_hidden_relu(\n common_layers.layer_preprocess(x, hparams),\n hparams.filter_size,\n hparams.hidden_size,\n dropout=hparams.relu_dropout)\n x = common_layers.layer_postprocess(x, y, hparams)\n return common_layers.layer_preprocess(x, hparams)", "docstring": "A stack of attention_lm layers.\n\n Args:\n decoder_input: a Tensor\n decoder_self_attention_bias: bias Tensor for self-attention\n (see common_attention.attention_bias())\n hparams: hyperparameters for model\n name: a string\n\n Returns:\n y: a Tensors" }, { "code": "def partition_ordered(sequence, key=None):\n yield from ((k, list(g)) for k, g in groupby(sequence, key=key))", "docstring": "Partition ordered sequence by key.\n\n Sequence is expected to already be ordered.\n\n Parameters\n ----------\n sequence: iterable data.\n key: partition key function\n\n Yields\n -------\n iterable tuple(s) of partition key, data list pairs.\n\n Examples\n --------\n 1. By object attributes.\n\n Partition sequence of objects by a height and weight attributes\n into an ordered dict.\n\n >> attributes = ('height', 'weight')\n >> OrderedDict(partition_ordered(sequence, attrgetter(*attributes)))\n\n 2. By index items.\n\n Partition sequence by the first character index of each element.\n\n >> index = 0\n >> sequence = ['112', '124', '289', '220', 'Z23']\n >> list(partition_ordered(sequence, itemgetter(index)))" }, { "code": "def Rz_matrix(theta):\n return np.array([\n [np.cos(theta), -np.sin(theta), 0],\n [np.sin(theta), np.cos(theta), 0],\n [0, 0, 1]\n ])", "docstring": "Rotation matrix around the Z axis" }, { "code": "def _any(objs, query):\n for obj in objs:\n if isinstance(obj, Document):\n if _any(obj.roots, query):\n return True\n else:\n if any(query(ref) for ref in obj.references()):\n return True\n else:\n return False", "docstring": "Whether any of a collection of objects satisfies a given query predicate\n\n Args:\n objs (seq[Model or Document]) :\n\n query (callable)\n\n Returns:\n True, if ``query(obj)`` is True for some object in ``objs``, else False" }, { "code": "def decrease_user_property(self, user_id, property_name, value=0, headers=None, endpoint_url=None):\n endpoint_url = endpoint_url or self._endpoint_url\n url = endpoint_url + \"/users/\" + user_id + \"/properties/\" + property_name + \"/decrease/\" + value.__str__()\n headers = headers or self._default_headers(content_type=\"\")\n response = requests.post(url, headers=headers)\n return response", "docstring": "Decrease a user's property by a value.\n\n :param str user_id: identified user's ID\n :param str property_name: user property name to increase\n :param number value: amount by which to decrease the property\n :param dict headers: custom request headers (if isn't set default values are used)\n :param str endpoint_url: where to send the request (if isn't set default value is used)\n :return: Response" }, { "code": "def frag2text(endpoint, stype, selector,\n clean=False, raw=False, verbose=False):\n try:\n return main(endpoint, stype, selector, clean, raw, verbose)\n except StandardError as err:\n return err", "docstring": "returns Markdown text of selected fragment.\n\n Args:\n endpoint: URL, file, or HTML string\n stype: { 'css' | 'xpath' }\n selector: CSS selector or XPath expression\n Returns:\n Markdown text\n Options:\n clean: cleans fragment (lxml.html.clean defaults)\n raw: returns raw HTML fragment\n verbose: show http status, encoding, headers" }, { "code": "def _resolve_subkeys(key, separator=\".\"):\n parts = key.split(separator, 1)\n if len(parts) > 1:\n return parts\n else:\n return parts[0], None", "docstring": "Resolve a potentially nested key.\n\n If the key contains the ``separator`` (e.g. ``.``) then the key will be\n split on the first instance of the subkey::\n\n >>> _resolve_subkeys('a.b.c')\n ('a', 'b.c')\n >>> _resolve_subkeys('d|e|f', separator='|')\n ('d', 'e|f')\n\n If not, the subkey will be :data:`None`::\n\n >>> _resolve_subkeys('foo')\n ('foo', None)\n\n Args:\n key (str): A string that may or may not contain the separator.\n separator (str): The namespace separator. Defaults to `.`.\n\n Returns:\n Tuple[str, str]: The key and subkey(s)." }, { "code": "def generalized_negative_binomial(mu=1, alpha=1, shape=_Null, dtype=_Null, **kwargs):\n return _random_helper(_internal._random_generalized_negative_binomial,\n _internal._sample_generalized_negative_binomial,\n [mu, alpha], shape, dtype, kwargs)", "docstring": "Draw random samples from a generalized negative binomial distribution.\n\n Samples are distributed according to a generalized negative binomial\n distribution parametrized by *mu* (mean) and *alpha* (dispersion).\n *alpha* is defined as *1/k* where *k* is the failure limit of the\n number of unsuccessful experiments (generalized to real numbers).\n Samples will always be returned as a floating point data type.\n\n Parameters\n ----------\n mu : float or Symbol, optional\n Mean of the negative binomial distribution.\n alpha : float or Symbol, optional\n Alpha (dispersion) parameter of the negative binomial distribution.\n shape : int or tuple of ints, optional\n The number of samples to draw. If shape is, e.g., `(m, n)` and `mu` and\n `alpha` are scalars, output shape will be `(m, n)`. If `mu` and `alpha`\n are Symbols with shape, e.g., `(x, y)`, then output will have shape\n `(x, y, m, n)`, where `m*n` samples are drawn for each `[mu, alpha)` pair.\n dtype : {'float16', 'float32', 'float64'}, optional\n Data type of output samples. Default is 'float32'\n\n Returns\n -------\n Symbol\n If input `shape` has dimensions, e.g., `(m, n)`, and `mu` and\n `alpha` are scalars, returned Symbol will resolve to shape `(m, n)`. If `mu`\n and `alpha` are Symbols with shape, e.g., `(x, y)`, returned Symbol will resolve\n to shape `(x, y, m, n)`, where `m*n` samples are drawn for each `[mu, alpha)` pair." }, { "code": "def warning_handler(self, handler):\n if not self.opened():\n handler = handler or util.noop\n self._warning_handler = enums.JLinkFunctions.LOG_PROTOTYPE(handler)\n self._dll.JLINKARM_SetWarnOutHandler(self._warning_handler)", "docstring": "Setter for the warning handler function.\n\n If the DLL is open, this function is a no-op, so it should be called\n prior to calling ``open()``.\n\n Args:\n self (JLink): the ``JLink`` instance\n handler (function): function to call on warning messages\n\n Returns:\n ``None``" }, { "code": "def nansum(values, axis=None, skipna=True, min_count=0, mask=None):\n values, mask, dtype, dtype_max, _ = _get_values(values,\n skipna, 0, mask=mask)\n dtype_sum = dtype_max\n if is_float_dtype(dtype):\n dtype_sum = dtype\n elif is_timedelta64_dtype(dtype):\n dtype_sum = np.float64\n the_sum = values.sum(axis, dtype=dtype_sum)\n the_sum = _maybe_null_out(the_sum, axis, mask, min_count=min_count)\n return _wrap_results(the_sum, dtype)", "docstring": "Sum the elements along an axis ignoring NaNs\n\n Parameters\n ----------\n values : ndarray[dtype]\n axis: int, optional\n skipna : bool, default True\n min_count: int, default 0\n mask : ndarray[bool], optional\n nan-mask if known\n\n Returns\n -------\n result : dtype\n\n Examples\n --------\n >>> import pandas.core.nanops as nanops\n >>> s = pd.Series([1, 2, np.nan])\n >>> nanops.nansum(s)\n 3.0" }, { "code": "def merge_figures(figures):\n\tfigure={}\n\tdata=[]\n\tfor fig in figures:\n\t\tfor trace in fig['data']:\n\t\t\tdata.append(trace)\n\tlayout=get_base_layout(figures)\n\tfigure['data']=data\n\tfigure['layout']=layout\n\treturn figure", "docstring": "Generates a single Figure from a list of figures\n\n\tParameters:\n\t-----------\n\t\tfigures : list(Figures)\n\t\t\tList of figures to be merged." }, { "code": "def clear_masters(self):\n packages = []\n for mas in Utils().remove_dbs(self.packages):\n if mas not in self.dependencies:\n packages.append(mas)\n self.packages = packages", "docstring": "Clear master packages if already exist in dependencies\n or if added to install two or more times" }, { "code": "def is_empty(self):\n return (not self.breakpoint and not self.code_analysis\n and not self.todo and not self.bookmarks)", "docstring": "Return whether the block of user data is empty." }, { "code": "def initialize_remaining_constants(self, value=0):\n remaining = []\n for node, _inputs, _outputs in self.iterate_bfs():\n streams = node.input_streams() + [node.stream]\n for stream in streams:\n if stream.stream_type is not DataStream.ConstantType:\n continue\n if stream not in self.constant_database:\n self.add_constant(stream, value)\n remaining.append(stream)\n return remaining", "docstring": "Ensure that all constant streams referenced in the sensor graph have a value.\n\n Constant streams that are automatically created by the compiler are initialized\n as part of the compilation process but it's possible that the user references\n other constant streams but never assigns them an explicit initial value. This\n function will initialize them all to a default value (0 if not passed) and\n return the streams that were so initialized.\n\n Args:\n value (int): Optional value to use to initialize all uninitialized constants.\n Defaults to 0 if not passed.\n\n Returns:\n list(DataStream): A list of all of the constant streams that were not previously\n initialized and were initialized to the given value in this function." }, { "code": "def get_default():\n if not is_configured():\n raise JutException('No configurations available, please run `jut config add`')\n for configuration in _CONFIG.sections():\n if _CONFIG.has_option(configuration, 'default'):\n return dict(_CONFIG.items(configuration))", "docstring": "return the attributes associated with the default configuration" }, { "code": "def forward(self, channel, date_s, fragment):\n\t\ttime_s, sep, nick = fragment.rpartition('.')\n\t\ttime = datetime.datetime.strptime(time_s, '%H.%M.%S')\n\t\tdate = datetime.datetime.strptime(date_s, '%Y-%m-%d')\n\t\tdt = datetime.datetime.combine(date, time.time())\n\t\tloc_dt = self.timezone.localize(dt)\n\t\tutc_dt = loc_dt.astimezone(pytz.utc)\n\t\turl_tmpl = '/day/{channel}/{target_date}\n\t\turl = url_tmpl.format(\n\t\t\ttarget_date=utc_dt.date().isoformat(),\n\t\t\ttarget_time=utc_dt.time().strftime('%H.%M.%S'),\n\t\t\t**locals()\n\t\t)\n\t\traise cherrypy.HTTPRedirect(url, 301)", "docstring": "Given an HREF in the legacy timezone, redirect to an href for UTC." }, { "code": "def FilterMessages(\n self,\n Channel,\n FromID,\n ToID,\n Mode):\n try:\n res = self.__m_dllBasic.CAN_FilterMessages(Channel,FromID,ToID,Mode)\n return TPCANStatus(res)\n except:\n logger.error(\"Exception on PCANBasic.FilterMessages\")\n raise", "docstring": "Configures the reception filter\n\n Remarks:\n The message filter will be expanded with every call to this function.\n If it is desired to reset the filter, please use the 'SetValue' function.\n\n Parameters:\n Channel : A TPCANHandle representing a PCAN Channel\n FromID : A c_uint value with the lowest CAN ID to be received\n ToID : A c_uint value with the highest CAN ID to be received\n Mode : A TPCANMode representing the message type (Standard, 11-bit\n identifier, or Extended, 29-bit identifier)\n\n Returns:\n A TPCANStatus error code" }, { "code": "def _create_token(token_type, value, lineno, lexpos):\n token = lex.LexToken()\n token.type = token_type\n token.value = value\n token.lineno = lineno\n token.lexpos = lexpos\n return token", "docstring": "Helper for creating ply.lex.LexToken objects. Unfortunately, LexToken\n does not have a constructor defined to make settings these values easy." }, { "code": "def _accumulate_sufficient_statistics(self, stats, X, framelogprob,\n posteriors, fwdlattice, bwdlattice):\n stats['nobs'] += 1\n if 's' in self.params:\n stats['start'] += posteriors[0]\n if 't' in self.params:\n n_samples, n_components = framelogprob.shape\n if n_samples <= 1:\n return\n log_xi_sum = np.full((n_components, n_components), -np.inf)\n _hmmc._compute_log_xi_sum(n_samples, n_components, fwdlattice,\n log_mask_zero(self.transmat_),\n bwdlattice, framelogprob,\n log_xi_sum)\n with np.errstate(under=\"ignore\"):\n stats['trans'] += np.exp(log_xi_sum)", "docstring": "Updates sufficient statistics from a given sample.\n\n Parameters\n ----------\n stats : dict\n Sufficient statistics as returned by\n :meth:`~base._BaseHMM._initialize_sufficient_statistics`.\n\n X : array, shape (n_samples, n_features)\n Sample sequence.\n\n framelogprob : array, shape (n_samples, n_components)\n Log-probabilities of each sample under each of the model states.\n\n posteriors : array, shape (n_samples, n_components)\n Posterior probabilities of each sample being generated by each\n of the model states.\n\n fwdlattice, bwdlattice : array, shape (n_samples, n_components)\n Log-forward and log-backward probabilities." }, { "code": "def find_steam_location():\n if registry is None:\n return None\n key = registry.CreateKey(registry.HKEY_CURRENT_USER,\"Software\\Valve\\Steam\")\n return registry.QueryValueEx(key,\"SteamPath\")[0]", "docstring": "Finds the location of the current Steam installation on Windows machines.\n Returns None for any non-Windows machines, or for Windows machines where\n Steam is not installed." }, { "code": "def deregister():\n for type_, cls in get_pairs():\n if type(units.registry.get(type_)) is cls:\n units.registry.pop(type_)\n for unit, formatter in _mpl_units.items():\n if type(formatter) not in {DatetimeConverter, PeriodConverter,\n TimeConverter}:\n units.registry[unit] = formatter", "docstring": "Remove pandas' formatters and converters\n\n Removes the custom converters added by :func:`register`. This\n attempts to set the state of the registry back to the state before\n pandas registered its own units. Converters for pandas' own types like\n Timestamp and Period are removed completely. Converters for types\n pandas overwrites, like ``datetime.datetime``, are restored to their\n original value.\n\n See Also\n --------\n deregister_matplotlib_converters" }, { "code": "def print_rendered_results(results_dict):\n class _HubComponentEncoder(json.JSONEncoder):\n def default(self, o):\n if isinstance(o, base.HubComponent):\n return repr(o)\n return json.JSONEncoder.default(self, o)\n formatted = json.dumps(results_dict, indent=4, cls=_HubComponentEncoder)\n for s in formatted.splitlines():\n print(s.rstrip())", "docstring": "Pretty-prints the rendered results dictionary.\n\n Rendered results can be multiply-nested dictionaries; this uses JSON\n serialization to print a nice representation." }, { "code": "def prepare_impact_function(self):\n impact_function = ImpactFunction()\n impact_function.callback = self.progress_callback\n impact_function.hazard = self.parent.hazard_layer\n impact_function.exposure = self.parent.exposure_layer\n aggregation = self.parent.aggregation_layer\n if aggregation:\n impact_function.aggregation = aggregation\n impact_function.use_selected_features_only = (\n setting('useSelectedFeaturesOnly', False, bool))\n else:\n impact_function.crs = self.extent.crs\n mode = setting('analysis_extents_mode')\n if self.extent.user_extent:\n wkt = self.extent.user_extent.asWkt()\n impact_function.requested_extent = wkt_to_rectangle(wkt)\n elif mode == HAZARD_EXPOSURE_VIEW:\n impact_function.requested_extent = (\n self.iface.mapCanvas().extent())\n elif mode == EXPOSURE:\n impact_function.use_exposure_view_only = True\n impact_function.debug_mode = False\n return impact_function", "docstring": "Create analysis as a representation of current situation of IFCW." }, { "code": "def update(self):\n stats = self.get_init_value()\n if self.input_method == 'local':\n stats['cpu'] = cpu_percent.get()\n stats['percpu'] = cpu_percent.get(percpu=True)\n stats['mem'] = psutil.virtual_memory().percent\n stats['swap'] = psutil.swap_memory().percent\n elif self.input_method == 'snmp':\n pass\n if cpuinfo_tag:\n cpu_info = cpuinfo.get_cpu_info()\n if cpu_info is not None:\n stats['cpu_name'] = cpu_info.get('brand', 'CPU')\n if 'hz_actual_raw' in cpu_info:\n stats['cpu_hz_current'] = cpu_info['hz_actual_raw'][0]\n if 'hz_advertised_raw' in cpu_info:\n stats['cpu_hz'] = cpu_info['hz_advertised_raw'][0]\n self.stats = stats\n return self.stats", "docstring": "Update quicklook stats using the input method." }, { "code": "def set_ipcsem_params(self, ftok=None, persistent=None):\n self._set('ftok', ftok)\n self._set('persistent-ipcsem', persistent, cast=bool)\n return self._section", "docstring": "Sets ipcsem lock engine params.\n\n :param str|unicode ftok: Set the ipcsem key via ftok() for avoiding duplicates.\n\n :param bool persistent: Do not remove ipcsem's on shutdown." }, { "code": "def is_broker_action_done(action, rid=None, unit=None):\n rdata = relation_get(rid, unit) or {}\n broker_rsp = rdata.get(get_broker_rsp_key())\n if not broker_rsp:\n return False\n rsp = CephBrokerRsp(broker_rsp)\n unit_name = local_unit().partition('/')[2]\n key = \"unit_{}_ceph_broker_action.{}\".format(unit_name, action)\n kvstore = kv()\n val = kvstore.get(key=key)\n if val and val == rsp.request_id:\n return True\n return False", "docstring": "Check whether broker action has completed yet.\n\n @param action: name of action to be performed\n @returns True if action complete otherwise False" }, { "code": "def get_proficiencies_for_objectives(self, objective_ids):\n collection = JSONClientValidated('learning',\n collection='Proficiency',\n runtime=self._runtime)\n result = collection.find(\n dict({'objectiveId': str(objective_ids)},\n **self._view_filter())).sort('_id', ASCENDING)\n return objects.ProficiencyList(result, runtime=self._runtime)", "docstring": "Gets a ``ProficiencyList`` relating to the given objectives.\n\n arg: objective_ids (osid.id.IdList): the objective ``Ids``\n return: (osid.learning.ProficiencyList) - the returned\n ``Proficiency`` list\n raise: NullArgument - ``objective_ids`` is ``null``\n raise: OperationFailed - unable to complete request\n raise: PermissionDenied - authorization failure\n *compliance: mandatory -- This method must be implemented.*" }, { "code": "def get_pg_core(connection_string, *, cursor_factory=None, edit_connection=None):\n import psycopg2 as pq\n from psycopg2.extras import NamedTupleCursor\n def opener():\n cn = pq.connect(connection_string)\n cn.cursor_factory = cursor_factory or NamedTupleCursor\n if edit_connection:\n edit_connection(cn)\n return cn\n return InjectedDataAccessCore(\n opener,\n default_connection_closer,\n (\"%({0})s\", \"%s\", \"{0}::{1}\"),\n empty_params=None,\n supports_timezones=True,\n supports_returning_syntax=True,\n get_autocommit=get_pg_autocommit,\n set_autocommit=set_pg_autocommit)", "docstring": "Creates a simple PostgreSQL core. Requires the psycopg2 library." }, { "code": "def getDiskFreeSpace(\n self,\n freeBytesAvailable,\n totalNumberOfBytes,\n totalNumberOfFreeBytes,\n dokanFileInfo,\n ):\n ret = self.operations('getDiskFreeSpace')\n ctypes.memmove(\n freeBytesAvailable,\n ctypes.byref(ctypes.c_longlong(ret['freeBytesAvailable'])),\n ctypes.sizeof(ctypes.c_longlong),\n )\n ctypes.memmove(\n totalNumberOfBytes,\n ctypes.byref(ctypes.c_longlong(ret['totalNumberOfBytes'])),\n ctypes.sizeof(ctypes.c_longlong),\n )\n ctypes.memmove(\n totalNumberOfFreeBytes,\n ctypes.byref(ctypes.c_longlong(ret['totalNumberOfFreeBytes'])),\n ctypes.sizeof(ctypes.c_longlong),\n )\n return d1_onedrive.impl.drivers.dokan.const.DOKAN_SUCCESS", "docstring": "Get the amount of free space on this volume.\n\n :param freeBytesAvailable: pointer for free bytes available\n :type freeBytesAvailable: ctypes.c_void_p\n :param totalNumberOfBytes: pointer for total number of bytes\n :type totalNumberOfBytes: ctypes.c_void_p\n :param totalNumberOfFreeBytes: pointer for total number of free bytes\n :type totalNumberOfFreeBytes: ctypes.c_void_p\n :param dokanFileInfo: used by Dokan\n :type dokanFileInfo: PDOKAN_FILE_INFO\n :return: error code\n :rtype: ctypes.c_int" }, { "code": "def async_session_handler(self, signal: str) -> None:\n if signal == 'data':\n self.async_event_handler(self.websocket.data)\n elif signal == 'state':\n if self.async_connection_status_callback:\n self.async_connection_status_callback(\n self.websocket.state == 'running')", "docstring": "Signalling from websocket.\n\n data - new data available for processing.\n state - network state has changed." }, { "code": "def countExtn(fimg, extname='SCI'):\n closefits = False\n if isinstance(fimg, string_types):\n fimg = fits.open(fimg)\n closefits = True\n n = 0\n for e in fimg:\n if 'extname' in e.header and e.header['extname'] == extname:\n n += 1\n if closefits:\n fimg.close()\n return n", "docstring": "Return the number of 'extname' extensions, defaulting to counting the\n number of SCI extensions." }, { "code": "def frame2string(frame):\n lineno = frame.f_lineno\n co = frame.f_code\n filename = co.co_filename\n name = co.co_name\n s = '\\tFile \"{0}\", line {1}, in {2}'.format(filename, lineno, name)\n line = linecache.getline(filename, lineno, frame.f_globals).lstrip()\n return s + '\\n\\t\\t' + line", "docstring": "Return info about frame.\n\n Keyword arg:\n frame\n\n Return string in format:\n\n File {file name}, line {line number}, in \n {name of parent of code object} {newline}\n Line from file at line number" }, { "code": "def __init_url(self):\n portals_self_url = \"{}/portals/self\".format(self._url)\n params = {\n \"f\" :\"json\"\n }\n if not self._securityHandler is None:\n params['token'] = self._securityHandler.token\n res = self._get(url=portals_self_url,\n param_dict=params,\n securityHandler=self._securityHandler,\n proxy_url=self._proxy_url,\n proxy_port=self._proxy_port)\n if \"helperServices\" in res:\n helper_services = res.get(\"helperServices\")\n if \"hydrology\" in helper_services:\n analysis_service = helper_services.get(\"elevation\")\n if \"url\" in analysis_service:\n self._analysis_url = analysis_service.get(\"url\")\n self._gpService = GPService(url=self._analysis_url,\n securityHandler=self._securityHandler,\n proxy_url=self._proxy_url,\n proxy_port=self._proxy_port,\n initialize=False)", "docstring": "loads the information into the class" }, { "code": "def get_ignored_lines(self):\n ignored_lines = set()\n for line_number, line in enumerate(self.content.split('\\n'), 1):\n if (\n WHITELIST_REGEX['yaml'].search(line)\n or (\n self.exclude_lines_regex and\n self.exclude_lines_regex.search(line)\n )\n ):\n ignored_lines.add(line_number)\n return ignored_lines", "docstring": "Return a set of integers that refer to line numbers that were\n whitelisted by the user and should be ignored.\n\n We need to parse the file separately from PyYAML parsing because\n the parser drops the comments (at least up to version 3.13):\n https://github.com/yaml/pyyaml/blob/a2d481b8dbd2b352cb001f07091ccf669227290f/lib3/yaml/scanner.py#L749\n\n :return: set" }, { "code": "def uuid(self, type, val):\n picker = lambda x: x.get('uuid', x)\n return self._get((type, val), picker)", "docstring": "Return the item-uuid for a identifier" }, { "code": "def fail_hosts(self, hosts_to_fail, activated_count=None):\n if not hosts_to_fail:\n return\n activated_count = activated_count or len(self.activated_hosts)\n logger.debug('Failing hosts: {0}'.format(', '.join(\n (host.name for host in hosts_to_fail),\n )))\n self.active_hosts -= hosts_to_fail\n active_hosts = self.active_hosts\n if not active_hosts:\n raise PyinfraError('No hosts remaining!')\n if self.config.FAIL_PERCENT is not None:\n percent_failed = (\n 1 - len(active_hosts) / activated_count\n ) * 100\n if percent_failed > self.config.FAIL_PERCENT:\n raise PyinfraError('Over {0}% of hosts failed ({1}%)'.format(\n self.config.FAIL_PERCENT,\n int(round(percent_failed)),\n ))", "docstring": "Flag a ``set`` of hosts as failed, error for ``config.FAIL_PERCENT``." }, { "code": "def Initialize(self):\n super(GRRFlow, self).Initialize()\n self._client_version = None\n self._client_os = None\n self._client_knowledge_base = None\n if \"r\" in self.mode:\n state = self.Get(self.Schema.FLOW_STATE_DICT)\n self.context = self.Get(self.Schema.FLOW_CONTEXT)\n self.runner_args = self.Get(self.Schema.FLOW_RUNNER_ARGS)\n args = self.Get(self.Schema.FLOW_ARGS)\n if args:\n self.args = args.payload\n if state:\n self.state = AttributedDict(state.ToDict())\n else:\n self.state = AttributedDict()\n self.Load()\n if self.state is None:\n self.state = AttributedDict()", "docstring": "The initialization method." }, { "code": "def _delay(self):\n if not self.next_scheduled:\n self.next_scheduled = self.clock_func() + self.interval\n return\n while True:\n current = self.clock_func()\n if current >= self.next_scheduled:\n extratime = current - self.next_scheduled\n self.next_scheduled = current + self.interval - extratime\n return\n delay_amt = self.next_scheduled - current\n if self.allow_negative_sleep or delay_amt >= 0: \n self.sleep_func(self.next_scheduled - current)", "docstring": "Delay for between zero and self.interval time units" }, { "code": "def OnCellTextRotation(self, event):\n with undo.group(_(\"Rotation\")):\n self.grid.actions.toggle_attr(\"angle\")\n self.grid.ForceRefresh()\n self.grid.update_attribute_toolbar()\n if is_gtk():\n try:\n wx.Yield()\n except:\n pass\n event.Skip()", "docstring": "Cell text rotation event handler" }, { "code": "def filter_inactive_ports(query):\n port_model = models_v2.Port\n query = (query\n .filter(port_model.status == n_const.PORT_STATUS_ACTIVE))\n return query", "docstring": "Filter ports that aren't in active status" }, { "code": "def _irc_upper(self, in_string):\n conv_string = self._translate(in_string)\n if self._upper_trans is not None:\n conv_string = in_string.translate(self._upper_trans)\n return str.upper(conv_string)", "docstring": "Convert us to our upper-case equivalent, given our std." }, { "code": "def drop_all(self):\n log.info('dropping tables in %s', self.engine.url)\n self.session.commit()\n models.Base.metadata.drop_all(self.engine)\n self.session.commit()", "docstring": "Drops all tables in the database" }, { "code": "def lookup_announce_alias(name):\n for alias, urls in announce.items():\n if alias.lower() == name.lower():\n return alias, urls\n raise KeyError(\"Unknown alias %s\" % (name,))", "docstring": "Get canonical alias name and announce URL list for the given alias." }, { "code": "def parse_client_cert_pair(config_value):\n if not config_value:\n return\n client_cert = config_value.split(':')\n if len(client_cert) != 2:\n tips = ('client_cert should be formatted like '\n '\"/path/to/cert.pem:/path/to/key.pem\"')\n raise ValueError('{0!r} is invalid.\\n{1}'.format(config_value, tips))\n return tuple(client_cert)", "docstring": "Parses the client cert pair from config item.\n\n :param config_value: the string value of config item.\n :returns: tuple or none." }, { "code": "def apply(self, node):\n new_node = self.run(node)\n return self.update, new_node", "docstring": "Apply transformation and return if an update happened." }, { "code": "def _check_classes(self):\n try:\n self.classes = self.imdbs[0].classes\n self.num_classes = len(self.classes)\n except AttributeError:\n pass\n if self.num_classes > 0:\n for db in self.imdbs:\n assert self.classes == db.classes, \"Multiple imdb must have same classes\"", "docstring": "check input imdbs, make sure they have same classes" }, { "code": "def _list_paths(self, bucket, prefix):\n s3 = self.s3\n kwargs = {\"Bucket\": bucket, \"Prefix\": prefix}\n if self.list_objects:\n list_objects_api = \"list_objects\"\n else:\n list_objects_api = \"list_objects_v2\"\n paginator = s3.get_paginator(list_objects_api)\n for page in paginator.paginate(**kwargs):\n contents = page.get(\"Contents\", None)\n if not contents:\n continue\n for item in contents:\n yield item[\"Key\"]", "docstring": "Read config for list object api, paginate through list objects." }, { "code": "def is_asdf(raw):\n reverse = raw[::-1]\n asdf = ''.join(ASDF)\n return raw in asdf or reverse in asdf", "docstring": "If the password is in the order on keyboard." }, { "code": "def get_vcl_html(self, service_id, version_number, name):\n\t\tcontent = self._fetch(\"/service/%s/version/%d/vcl/%s/content\" % (service_id, version_number, name))\n\t\treturn content.get(\"content\", None)", "docstring": "Get the uploaded VCL for a particular service and version with HTML syntax highlighting." }, { "code": "def sideral(date, longitude=0., model='mean', eop_correction=True, terms=106):\n theta = _sideral(date, longitude, model, eop_correction, terms)\n return rot3(np.deg2rad(-theta))", "docstring": "Sideral time as a rotation matrix" }, { "code": "def _setDefaults(self):\n for configName, configDict in self.configs.items():\n self._setConfig(configName, configDict['default'])", "docstring": "Sets all the expected configuration options on the config object as either the requested default value, or None." }, { "code": "def update(uid, post_data):\n raw_rec = TabTag.get(TabTag.uid == uid)\n entry = TabTag.update(\n name=post_data['name'] if 'name' in post_data else raw_rec.name,\n slug=post_data['slug'] if 'slug' in post_data else raw_rec.slug,\n order=post_data['order'] if 'order' in post_data else raw_rec.order,\n kind=post_data['kind'] if 'kind' in post_data else raw_rec.kind,\n pid=post_data['pid'],\n ).where(TabTag.uid == uid)\n entry.execute()", "docstring": "Update the category." }, { "code": "def save_and_restore(self, _func=None, **config_values):\n functools = self._modules['functools']\n if not _func:\n return functools.partial(self.save_and_restore, **config_values)\n @functools.wraps(_func)\n def _saving_wrapper(*args, **kwargs):\n saved_config = dict(self._loaded_values)\n try:\n self.load_from_dict(config_values)\n return _func(*args, **kwargs)\n finally:\n self._loaded_values = saved_config\n return _saving_wrapper", "docstring": "Decorator for saving conf state and restoring it after a function.\n\n This decorator is primarily for use in tests, where conf keys may be updated\n for individual test cases, but those values need to be reverted after the\n test case is done.\n\n Examples:\n\n conf.declare('my_conf_key')\n\n @conf.save_and_restore\n def MyTestFunc():\n conf.load(my_conf_key='baz')\n SomeFuncUnderTestThatUsesMyConfKey()\n\n conf.load(my_conf_key='foo')\n MyTestFunc()\n print conf.my_conf_key # Prints 'foo', *NOT* 'baz'\n\n # Without the save_and_restore decorator, MyTestFunc() would have had the\n # side effect of altering the conf value of 'my_conf_key' to 'baz'.\n\n # Config keys can also be initialized for the context inline at decoration\n # time. This is the same as setting them at the beginning of the\n # function, but is a little clearer syntax if you know ahead of time what\n # config keys and values you need to set.\n\n @conf.save_and_restore(my_conf_key='baz')\n def MyOtherTestFunc():\n print conf.my_conf_key # Prints 'baz'\n\n MyOtherTestFunc()\n print conf.my_conf_key # Prints 'foo' again, for the same reason.\n\n\n Args:\n _func: The function to wrap. The returned wrapper will invoke the\n function and restore the config to the state it was in at invocation.\n **config_values: Config keys can be set inline at decoration time, see\n examples. Note that config keys can't begin with underscore, so\n there can be no name collision with _func.\n\n Returns:\n Wrapper to replace _func, as per Python decorator semantics." }, { "code": "def go_to_next_cell(self):\r\n cursor = self.textCursor()\r\n cursor.movePosition(QTextCursor.NextBlock)\r\n cur_pos = prev_pos = cursor.position()\r\n while not self.is_cell_separator(cursor):\r\n cursor.movePosition(QTextCursor.NextBlock)\r\n prev_pos = cur_pos\r\n cur_pos = cursor.position()\r\n if cur_pos == prev_pos:\r\n return\r\n self.setTextCursor(cursor)", "docstring": "Go to the next cell of lines" }, { "code": "def get_tensors(object_):\n if torch.is_tensor(object_):\n return [object_]\n elif isinstance(object_, (str, float, int)):\n return []\n tensors = set()\n if isinstance(object_, collections.abc.Mapping):\n for value in object_.values():\n tensors.update(get_tensors(value))\n elif isinstance(object_, collections.abc.Iterable):\n for value in object_:\n tensors.update(get_tensors(value))\n else:\n members = [\n value for key, value in inspect.getmembers(object_)\n if not isinstance(value, (collections.abc.Callable, type(None)))\n ]\n tensors.update(get_tensors(members))\n return tensors", "docstring": "Get all tensors associated with ``object_``\n\n Args:\n object_ (any): Any object to look for tensors.\n\n Returns:\n (list of torch.tensor): List of tensors that are associated with ``object_``." }, { "code": "def validate_description(xml_data):\n try:\n root = ET.fromstring('' + xml_data + '')\n except StdlibParseError as e:\n raise ParseError(str(e))\n return _parse_desc(root)", "docstring": "Validate the description for validity" }, { "code": "def formatfooter(self, previous_month, next_month):\n footer = '' \\\n '%s' \\\n ' ' \\\n '%s' \\\n ''\n if previous_month:\n previous_content = '%s' % (\n reverse('zinnia:entry_archive_month', args=[\n previous_month.strftime('%Y'),\n previous_month.strftime('%m')]),\n date_format(previous_month, 'YEAR_MONTH_FORMAT'))\n else:\n previous_content = ' '\n if next_month:\n next_content = '%s' % (\n reverse('zinnia:entry_archive_month', args=[\n next_month.strftime('%Y'),\n next_month.strftime('%m')]),\n date_format(next_month, 'YEAR_MONTH_FORMAT'))\n else:\n next_content = ' '\n return footer % (previous_content, next_content)", "docstring": "Return a footer for a previous and next month." }, { "code": "def second_order_score(y, mean, scale, shape, skewness):\n return ((y-mean)/float(scale*np.abs(y-mean))) / (-(np.power(y-mean,2) - np.power(np.abs(mean-y),2))/(scale*np.power(np.abs(mean-y),3)))", "docstring": "GAS Laplace Update term potentially using second-order information - native Python function\n\n Parameters\n ----------\n y : float\n datapoint for the time series\n\n mean : float\n location parameter for the Laplace distribution\n\n scale : float\n scale parameter for the Laplace distribution\n\n shape : float\n tail thickness parameter for the Laplace distribution\n\n skewness : float\n skewness parameter for the Laplace distribution\n\n Returns\n ----------\n - Adjusted score of the Laplace family" }, { "code": "def set_text(self, text):\r\n text = text.strip()\r\n new_text = self.text() + text\r\n self.setText(new_text)", "docstring": "Set the filter text." }, { "code": "async def start_worker(\n self,\n cmd: List[str],\n input_source: str,\n output: Optional[str] = None,\n extra_cmd: Optional[str] = None,\n pattern: Optional[str] = None,\n reading: str = FFMPEG_STDERR,\n ) -> None:\n if self.is_running:\n _LOGGER.warning(\"Can't start worker. It is allready running!\")\n return\n if reading == FFMPEG_STDERR:\n stdout = False\n stderr = True\n else:\n stdout = True\n stderr = False\n await self.open(\n cmd=cmd,\n input_source=input_source,\n output=output,\n extra_cmd=extra_cmd,\n stdout_pipe=stdout,\n stderr_pipe=stderr,\n )\n self._input = await self.get_reader(reading)\n self._read_task = self._loop.create_task(self._process_lines(pattern))\n self._loop.create_task(self._worker_process())", "docstring": "Start ffmpeg do process data from output." }, { "code": "def id_to_root_name(id):\n name = root_names.get(id)\n if not name:\n name = repr(id)\n return name", "docstring": "Convert a PDG ID to a string with root markup." }, { "code": "def footer_length(header):\n footer_length = 0\n if header.algorithm.signing_algorithm_info is not None:\n footer_length += 2\n footer_length += header.algorithm.signature_len\n return footer_length", "docstring": "Calculates the ciphertext message footer length, given a complete header.\n\n :param header: Complete message header object\n :type header: aws_encryption_sdk.structures.MessageHeader\n :rtype: int" }, { "code": "def rotate_around(self, axis, theta):\n x, y, z = self.x, self.y, self.z\n u, v, w = axis.x, axis.y, axis.z\n r2 = u**2 + v**2 + w**2\n r = math.sqrt(r2)\n ct = math.cos(theta)\n st = math.sin(theta) / r\n dt = (u * x + v * y + w * z) * (1 - ct) / r2\n return Vector3((u * dt + x * ct + (-w * y + v * z) * st),\n (v * dt + y * ct + (w * x - u * z) * st),\n (w * dt + z * ct + (-v * x + u * y) * st))", "docstring": "Return the vector rotated around axis through angle theta.\n\n Right hand rule applies." }, { "code": "def __get_min_reads(current_provisioning, min_provisioned_reads, log_tag):\n reads = 1\n if min_provisioned_reads:\n reads = int(min_provisioned_reads)\n if reads > int(current_provisioning * 2):\n reads = int(current_provisioning * 2)\n logger.debug(\n '{0} - '\n 'Cannot reach min-provisioned-reads as max scale up '\n 'is 100% of current provisioning'.format(log_tag))\n logger.debug(\n '{0} - Setting min provisioned reads to {1}'.format(\n log_tag, min_provisioned_reads))\n return reads", "docstring": "Get the minimum number of reads to current_provisioning\n\n :type current_provisioning: int\n :param current_provisioning: Current provisioned reads\n :type min_provisioned_reads: int\n :param min_provisioned_reads: Configured min provisioned reads\n :type log_tag: str\n :param log_tag: Prefix for the log\n :returns: int -- Minimum number of reads" }, { "code": "def main(*args):\n args = args or sys.argv[1:]\n params = PARSER.parse_args(args)\n from .log import setup_logging\n setup_logging(params.level.upper())\n from .core import Starter\n starter = Starter(params)\n if not starter.params.TEMPLATES or starter.params.list:\n setup_logging('WARN')\n for t in sorted(starter.iterate_templates()):\n logging.warn(\"%s -- %s\", t.name, t.params.get(\n 'description', 'no description'))\n return True\n try:\n starter.copy()\n except Exception as e:\n logging.error(e)\n sys.exit(1)", "docstring": "Enter point." }, { "code": "def create_index(self, indexname=None, index_conf=None):\n if indexname is None:\n indexname = self.index_name\n log.debug(\"Creating new index: '{0}'\".format(indexname))\n if index_conf is None:\n index_conf = {'settings': self.settings,\n 'mappings': {'book': {'properties': self.properties}}}\n try:\n self.es.indices.create(index=indexname, body=index_conf)\n except TransportError as te:\n if te.error.startswith(\"IndexAlreadyExistsException\"):\n raise Exception(\"Cannot create index '{}', already exists\".format(indexname))\n else:\n raise", "docstring": "Create the index\n\n Create the index with given configuration.\n If `indexname` is provided it will be used as the new index name\n instead of the class one (:py:attr:`DB.index_name`)\n\n :param index_conf: configuration to be used in index creation. If this\n is not specified the default index configuration will be used.\n :raises Exception: if the index already exists." }, { "code": "def get_changeset(self, **options):\n cid = options.get('changeset_id', None)\n return self.repo.get_changeset(cid)", "docstring": "Returns changeset for given ``options``." }, { "code": "def setCurrentIndex(self, index):\n super(XViewPanel, self).setCurrentIndex(index)\n self.tabBar().setCurrentIndex(index)", "docstring": "Sets the current index on self and on the tab bar to keep the two insync.\n\n :param index | " }, { "code": "def process_checkpoint(self, msg: Checkpoint, sender: str) -> bool:\n self.logger.info('{} processing checkpoint {} from {}'.format(self, msg, sender))\n result, reason = self.validator.validate_checkpoint_msg(msg)\n if result == DISCARD:\n self.discard(msg, \"{} discard message {} from {} \"\n \"with the reason: {}\".format(self, msg, sender, reason),\n self.logger.trace)\n elif result == PROCESS:\n self._do_process_checkpoint(msg, sender)\n else:\n self.logger.debug(\"{} stashing checkpoint message {} with \"\n \"the reason: {}\".format(self, msg, reason))\n self.stasher.stash((msg, sender), result)\n return False\n return True", "docstring": "Process checkpoint messages\n\n :return: whether processed (True) or stashed (False)" }, { "code": "def get_crimes_no_location(self, force, date=None, category=None):\n if not isinstance(force, Force):\n force = Force(self, id=force)\n if isinstance(category, CrimeCategory):\n category = category.id\n kwargs = {\n 'force': force.id,\n 'category': category or 'all-crime',\n }\n crimes = []\n if date is not None:\n kwargs['date'] = date\n for c in self.service.request('GET', 'crimes-no-location', **kwargs):\n crimes.append(NoLocationCrime(self, data=c))\n return crimes", "docstring": "Get crimes with no location for a force. Uses the crimes-no-location_\n API call.\n\n .. _crimes-no-location:\n https://data.police.uk/docs/method/crimes-no-location/\n\n :rtype: list\n :param force: The force to get no-location crimes for.\n :type force: str or Force\n :param date: The month in which the crimes were reported in the format\n ``YYYY-MM`` (the latest date is used if ``None``).\n :type date: str or None\n :param category: The category of the crimes to filter by (either by ID\n or CrimeCategory object)\n :type category: str or CrimeCategory\n :return: A ``list`` of :class:`crime.NoLocationCrime` objects which\n were reported in the given month, by the specified force, but\n which don't have a location." }, { "code": "def _clear_state(self, seed=None):\n self.start_time = time()\n self.run_stats = []\n self.best_index = -1\n self.best_score = -1\n self.best_config = None\n self.search_space = None\n if seed is not None:\n self.rng = random.Random(seed)", "docstring": "Clears the state, starts clock" }, { "code": "def match_events(ref, est, window, distance=None):\n if distance is not None:\n hits = np.where(distance(ref, est) <= window)\n else:\n hits = _fast_hit_windows(ref, est, window)\n G = {}\n for ref_i, est_i in zip(*hits):\n if est_i not in G:\n G[est_i] = []\n G[est_i].append(ref_i)\n matching = sorted(_bipartite_match(G).items())\n return matching", "docstring": "Compute a maximum matching between reference and estimated event times,\n subject to a window constraint.\n\n Given two lists of event times ``ref`` and ``est``, we seek the largest set\n of correspondences ``(ref[i], est[j])`` such that\n ``distance(ref[i], est[j]) <= window``, and each\n ``ref[i]`` and ``est[j]`` is matched at most once.\n\n This is useful for computing precision/recall metrics in beat tracking,\n onset detection, and segmentation.\n\n Parameters\n ----------\n ref : np.ndarray, shape=(n,)\n Array of reference values\n est : np.ndarray, shape=(m,)\n Array of estimated values\n window : float > 0\n Size of the window.\n distance : function\n function that computes the outer distance of ref and est.\n By default uses ``|ref[i] - est[j]|``\n\n Returns\n -------\n matching : list of tuples\n A list of matched reference and event numbers.\n ``matching[i] == (i, j)`` where ``ref[i]`` matches ``est[j]``." }, { "code": "def pvector_field(item_type, optional=False, initial=()):\n return _sequence_field(CheckedPVector, item_type, optional,\n initial)", "docstring": "Create checked ``PVector`` field.\n\n :param item_type: The required type for the items in the vector.\n :param optional: If true, ``None`` can be used as a value for\n this field.\n :param initial: Initial value to pass to factory if no value is given\n for the field.\n\n :return: A ``field`` containing a ``CheckedPVector`` of the given type." }, { "code": "def reprocess_tree_node(self, tree_node, tx_context=None):\n if not tx_context:\n tx_context = collections.defaultdict(dict)\n if tree_node.parent is None:\n return tx_context\n if tree_node.timeperiod in tx_context[tree_node.process_name]:\n return tx_context\n if tree_node.job_record.is_embryo:\n pass\n else:\n state_machine_name = context.process_context[tree_node.process_name].state_machine_name\n state_machine = self.state_machines[state_machine_name]\n state_machine.reprocess_job(tree_node.job_record)\n tx_context[tree_node.process_name][tree_node.timeperiod] = tree_node\n self.reprocess_tree_node(tree_node.parent, tx_context)\n dependant_nodes = self._find_dependant_tree_nodes(tree_node)\n for node in dependant_nodes:\n self.reprocess_tree_node(node, tx_context)\n return tx_context", "docstring": "method reprocesses the node and all its dependants and parent nodes" }, { "code": "def user_list_membership(self, username, member_type=\"USER\",\n recursive=True, max_return_count=999):\n return self.client.service.getUserListMembership(\n username,\n member_type,\n recursive,\n max_return_count,\n self.proxy_id\n )", "docstring": "Get info for lists a user is a member of.\n\n This is similar to :meth:`user_lists` but with a few differences:\n\n #. It returns list info objects instead of list names.\n #. It has an option to fully resolve a user's list hierarchy. That\n is, if a user is a member of a nested list, this method can\n retrieve both the nested list and the parent lists that contain\n the nested list.\n\n Args:\n username (str): The MIT username of the user\n member_type(str): The type of user, \"USER\" or \"STRING\"\n recursive(bool): Whether to fully resolve the list hierarchy\n max_return_count(int): limit the number of items returned\n\n Returns:\n list of dicts: info dicts, one per list." }, { "code": "def remove_rules(self, description):\n rm = []\n description = description.lower()\n for i in range(0, len(self.extract_rules)):\n if self.extract_rules[i]['regex'].search(description):\n rm.append(i)\n for i in rm:\n self.extract_rules.pop(i)\n return len(rm)", "docstring": "Remove all rules that match a specified description.\n\n @description - The description to match against.\n\n Returns the number of rules removed." }, { "code": "def get_tags(self):\n res = self.get_request('/tag')\n return [Tag(cloud_manager=self, **tag) for tag in res['tags']['tag']]", "docstring": "List all tags as Tag objects." }, { "code": "def readTempC(self):\n\t\tt = self._device.readU16BE(MCP9808_REG_AMBIENT_TEMP)\n\t\tself._logger.debug('Raw ambient temp register value: 0x{0:04X}'.format(t & 0xFFFF))\n\t\ttemp = (t & 0x0FFF) / 16.0\n\t\tif t & 0x1000:\n\t\t\ttemp -= 256.0\n\t\treturn temp", "docstring": "Read sensor and return its value in degrees celsius." }, { "code": "def _RecurseKey(self, recur_item, root='', depth=15):\n if depth < 1:\n logger.debug('Recursion limit hit for key: {0:s}'.format(root))\n return\n if isinstance(recur_item, (list, tuple)):\n for recur in recur_item:\n for key in self._RecurseKey(recur, root, depth):\n yield key\n return\n if not hasattr(recur_item, 'iteritems'):\n return\n for key, value in iter(recur_item.items()):\n yield root, key, value\n if isinstance(value, dict):\n value = [value]\n if isinstance(value, list):\n for item in value:\n if isinstance(item, dict):\n for keyval in self._RecurseKey(\n item, root=root + '/' + key, depth=depth - 1):\n yield keyval", "docstring": "Flattens nested dictionaries and lists by yielding their values.\n\n The hierarchy of a bencode file is a series of nested dictionaries and\n lists. This is a helper function helps plugins navigate the structure\n without having to reimplement their own recursive methods.\n\n This method implements an overridable depth limit to prevent processing\n extremely deeply nested dictionaries. If the limit is reached a debug\n message is logged indicating which key processing stopped on.\n\n Args:\n recur_item (object): object to be checked for additional nested items.\n root (str): the pathname of the current working key.\n depth (int): a counter to ensure we stop at the maximum recursion depth.\n\n Yields:\n tuple: containing:\n str: root\n str: key\n str: value" }, { "code": "def ghissue_role(name, rawtext, text, lineno, inliner, options={}, content=[]):\n try:\n issue_num = int(text)\n if issue_num <= 0:\n raise ValueError\n except ValueError:\n msg = inliner.reporter.error(\n 'GitHub issue number must be a number greater than or equal to 1; '\n '\"%s\" is invalid.' % text, line=lineno)\n prb = inliner.problematic(rawtext, rawtext, msg)\n return [prb], [msg]\n app = inliner.document.settings.env.app\n if 'pull' in name.lower():\n category = 'pull'\n elif 'issue' in name.lower():\n category = 'issues'\n else:\n msg = inliner.reporter.error(\n 'GitHub roles include \"ghpull\" and \"ghissue\", '\n '\"%s\" is invalid.' % name, line=lineno)\n prb = inliner.problematic(rawtext, rawtext, msg)\n return [prb], [msg]\n node = make_link_node(rawtext, app, category, str(issue_num), options)\n return [node], []", "docstring": "Link to a GitHub issue.\n\n Returns 2 part tuple containing list of nodes to insert into the\n document and a list of system messages. Both are allowed to be\n empty.\n\n :param name: The role name used in the document.\n :param rawtext: The entire markup snippet, with role.\n :param text: The text marked with the role.\n :param lineno: The line number where rawtext appears in the input.\n :param inliner: The inliner instance that called us.\n :param options: Directive options for customization.\n :param content: The directive content for customization." }, { "code": "def reverse_tree(tree):\n rtree = defaultdict(list)\n child_keys = set(c.key for c in flatten(tree.values()))\n for k, vs in tree.items():\n for v in vs:\n node = find_tree_root(rtree, v.key) or v\n rtree[node].append(k.as_required_by(v))\n if k.key not in child_keys:\n rtree[k.as_requirement()] = []\n return rtree", "docstring": "Reverse the dependency tree.\n\n ie. the keys of the resulting dict are objects of type\n ReqPackage and the values are lists of DistPackage objects.\n\n :param dict tree: the pkg dependency tree obtained by calling\n `construct_tree` function\n :returns: reversed tree\n :rtype: dict" }, { "code": "def remove_temp_copy(self):\n if self.is_temp and self.root_dir is not None:\n shutil.rmtree(self.root_dir)\n self.root_dir = None", "docstring": "Removes a temporary copy of the MAGICC version shipped with Pymagicc." }, { "code": "def parse_cluster(self, global_params, region, cluster):\n cluster_name = cluster.pop('CacheClusterId')\n cluster['name'] = cluster_name\n if 'CacheSubnetGroupName' in cluster:\n subnet_group = api_clients[region].describe_cache_subnet_groups(CacheSubnetGroupName = cluster['CacheSubnetGroupName'])['CacheSubnetGroups'][0]\n vpc_id = subnet_group['VpcId']\n else:\n vpc_id = ec2_classic\n subnet_group = None\n manage_dictionary(self.vpcs, vpc_id, VPCConfig(self.vpc_resource_types))\n self.vpcs[vpc_id].clusters[cluster_name] = cluster\n if subnet_group:\n self.vpcs[vpc_id].subnet_groups[subnet_group['CacheSubnetGroupName']] = subnet_group", "docstring": "Parse a single ElastiCache cluster\n\n :param global_params: Parameters shared for all regions\n :param region: Name of the AWS region\n :param cluster: ElastiCache cluster" }, { "code": "def wrap(self, width):\n res = []\n prev_state = set()\n part = []\n cwidth = 0\n for char, _width, state in zip(self._string, self._width, self._state):\n if cwidth + _width > width:\n if prev_state:\n part.append(self.ANSI_RESET)\n res.append(\"\".join(part))\n prev_state = set()\n part = []\n cwidth = 0\n cwidth += _width\n if prev_state == state:\n pass\n elif prev_state <= state:\n part.extend(state - prev_state)\n else:\n part.append(self.ANSI_RESET)\n part.extend(state)\n prev_state = state\n part.append(char)\n if prev_state:\n part.append(self.ANSI_RESET)\n if part:\n res.append(\"\".join(part))\n return res", "docstring": "Returns a partition of the string based on `width`" }, { "code": "def unkown_field(self, value=None):\n if value is not None:\n try:\n value = str(value)\n except ValueError:\n raise ValueError('value {} need to be of type str '\n 'for field `unkown_field`'.format(value))\n if ',' in value:\n raise ValueError('value should not contain a comma '\n 'for field `unkown_field`')\n self._unkown_field = value", "docstring": "Corresponds to IDD Field `unkown_field` Empty field in data.\n\n Args:\n value (str): value for IDD Field `unkown_field`\n if `value` is None it will not be checked against the\n specification and is assumed to be a missing value\n\n Raises:\n ValueError: if `value` is not a valid value" }, { "code": "def parse_request_body(self, body):\n PARSING_FUNCTIONS = {\n 'application/json': json.loads,\n 'text/json': json.loads,\n 'application/x-www-form-urlencoded': self.parse_querystring,\n }\n content_type = self.headers.get('content-type', '')\n do_parse = PARSING_FUNCTIONS.get(content_type, FALLBACK_FUNCTION)\n try:\n body = decode_utf8(body)\n return do_parse(body)\n except (Exception, BaseException):\n return body", "docstring": "Attempt to parse the post based on the content-type passed.\n Return the regular body if not\n\n :param body: string\n :returns: a python object such as dict or list in case the deserialization suceeded. Else returns the given param ``body``" }, { "code": "def handle_current_state(self):\n if getattr(self, '_current_state_hydrated_changed', False) and self.save_on_change:\n new_base_state = json.dumps(getattr(self, '_current_state_hydrated', {}))\n if new_base_state != self.base_state:\n self.base_state = new_base_state\n self.save()", "docstring": "Check to see if the current hydrated state and the saved state are different.\n\n If they are, then persist the current state in the database by saving the model instance." }, { "code": "def create_superuser(\n self, username, email, short_name, full_name,\n institute, password, **extra_fields):\n return self._create_user(\n username=username, email=email,\n institute=institute, password=password,\n short_name=short_name, full_name=full_name,\n is_admin=True, **extra_fields)", "docstring": "Creates a new person with super powers." }, { "code": "def python_value(self, value):\n value = super(JSONField, self).python_value(value)\n if value is not None:\n return flask.json.loads(value, **self._load_kwargs)", "docstring": "Return the JSON in the database as a ``dict``.\n\n Returns:\n dict: The field run through json.loads" }, { "code": "def on_replace_scene(self, event: events.ReplaceScene, signal):\n self.stop_scene()\n self.start_scene(event.new_scene, event.kwargs)", "docstring": "Replace the running scene with a new one." }, { "code": "def set_experiment_winner(experiment):\n redis = _get_redis_connection()\n experiment = Experiment.find(redis, experiment)\n if experiment:\n alternative_name = request.form.get('alternative')\n alternative = Alternative(redis, alternative_name, experiment.name)\n if alternative.name in experiment.alternative_names:\n experiment.winner = alternative.name\n return redirect(url_for('.index'))", "docstring": "Mark an alternative as the winner of the experiment." }, { "code": "def append(self, cls, infer_hidden: bool = False, **kwargs) -> Encoder:\n params = dict(kwargs)\n if infer_hidden:\n params['num_hidden'] = self.get_num_hidden()\n sig_params = inspect.signature(cls.__init__).parameters\n if 'dtype' in sig_params and 'dtype' not in kwargs:\n params['dtype'] = self.dtype\n encoder = cls(**params)\n self.encoders.append(encoder)\n return encoder", "docstring": "Extends sequence with new Encoder. 'dtype' gets passed into Encoder instance if not present in parameters\n and supported by specific Encoder type.\n\n :param cls: Encoder type.\n :param infer_hidden: If number of hidden should be inferred from previous encoder.\n :param kwargs: Named arbitrary parameters for Encoder.\n\n :return: Instance of Encoder." }, { "code": "def _delete_network(self, request, network):\n try:\n api.neutron.network_delete(request, network.id)\n LOG.debug('Delete the created network %s '\n 'due to subnet creation failure.', network.id)\n msg = _('Delete the created network \"%s\" '\n 'due to subnet creation failure.') % network.name\n redirect = self.get_failure_url()\n messages.info(request, msg)\n raise exceptions.Http302(redirect)\n except Exception as e:\n LOG.info('Failed to delete network %(id)s: %(exc)s',\n {'id': network.id, 'exc': e})\n msg = _('Failed to delete network \"%s\"') % network.name\n redirect = self.get_failure_url()\n exceptions.handle(request, msg, redirect=redirect)", "docstring": "Delete the created network when subnet creation failed." }, { "code": "def FromMilliseconds(self, millis):\n self._NormalizeDuration(\n millis // _MILLIS_PER_SECOND,\n (millis % _MILLIS_PER_SECOND) * _NANOS_PER_MILLISECOND)", "docstring": "Converts milliseconds to Duration." }, { "code": "def ready(zone):\n ret = {'status': True}\n res = __salt__['cmd.run_all']('zoneadm {zone} ready'.format(\n zone='-u {0}'.format(zone) if _is_uuid(zone) else '-z {0}'.format(zone),\n ))\n ret['status'] = res['retcode'] == 0\n ret['message'] = res['stdout'] if ret['status'] else res['stderr']\n ret['message'] = ret['message'].replace('zoneadm: ', '')\n if ret['message'] == '':\n del ret['message']\n return ret", "docstring": "Prepares a zone for running applications.\n\n zone : string\n name or uuid of the zone\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' zoneadm.ready clementine" }, { "code": "def gauss_box_model(x, amplitude=1.0, mean=0.0, stddev=1.0, hpix=0.5):\n z = (x - mean) / stddev\n z2 = z + hpix / stddev\n z1 = z - hpix / stddev\n return amplitude * (norm.cdf(z2) - norm.cdf(z1))", "docstring": "Integrate a Gaussian profile." }, { "code": "def _get_rating(self, entry):\n r_info = ''\n for string in entry[2].strings:\n r_info += string\n rating, share = r_info.split('/')\n return (rating, share.strip('*'))", "docstring": "Get the rating and share for a specific row" }, { "code": "def groups(self, user, include=None):\n return self._query_zendesk(self.endpoint.groups, 'group', id=user, include=include)", "docstring": "Retrieve the groups for this user.\n\n :param include: list of objects to sideload. `Side-loading API Docs \n `__.\n :param user: User object or id" }, { "code": "def replace_text_dir(self, directory, to_replace, replacement, file_type=None):\n if not file_type:\n file_type = \"*.tex\"\n for file in glob.iglob(os.path.join(directory, file_type)):\n self.replace_text(file, to_replace, replacement)", "docstring": "Replaces a string with its replacement in all the files in the directory\n\n :param directory: the directory in which the files have to be modified\n :param to_replace: the string to be replaced in the files\n :param replacement: the string which replaces 'to_replace' in the files\n :param file_type: file pattern to match the files in which the string has to be replaced" }, { "code": "def raise_error_if_unphysical(f):\n def wrapper(self, *args, **kwargs):\n if self.k_vrh < 0 or self.g_vrh < 0:\n raise ValueError(\"Bulk or shear modulus is negative, property \"\n \"cannot be determined\")\n return f(self, *args, **kwargs)\n return wrapper", "docstring": "Wrapper for functions or properties that should raise an error\n if tensor is unphysical." }, { "code": "def initialize_private_canvas(self, private_canvas):\n if self.t_.get('show_pan_position', False):\n self.show_pan_mark(True)\n if self.t_.get('show_focus_indicator', False):\n self.show_focus_indicator(True)", "docstring": "Initialize the private canvas used by this instance." }, { "code": "def stop(self):\n if not self.running:\n return\n self.logger.debug(\"stopping main task of %r\", self, stack_info=True)\n self._main_task.cancel()", "docstring": "Stop the client. This sends a signal to the clients main task which\n makes it terminate.\n\n It may take some cycles through the event loop to stop the client\n task. To check whether the task has actually stopped, query\n :attr:`running`." }, { "code": "def _adjust_nstep(n_step, gamma, obs, actions, rewards, new_obs, dones):\n assert not any(dones[:-1]), \"Unexpected done in middle of trajectory\"\n traj_length = len(rewards)\n for i in range(traj_length):\n for j in range(1, n_step):\n if i + j < traj_length:\n new_obs[i] = new_obs[i + j]\n dones[i] = dones[i + j]\n rewards[i] += gamma**j * rewards[i + j]", "docstring": "Rewrites the given trajectory fragments to encode n-step rewards.\n\n reward[i] = (\n reward[i] * gamma**0 +\n reward[i+1] * gamma**1 +\n ... +\n reward[i+n_step-1] * gamma**(n_step-1))\n\n The ith new_obs is also adjusted to point to the (i+n_step-1)'th new obs.\n\n At the end of the trajectory, n is truncated to fit in the traj length." }, { "code": "def _cmp_bystrlen_reverse(a, b):\n if len(a) > len(b):\n return -1\n elif len(a) < len(b):\n return 1\n else:\n return 0", "docstring": "A private \"cmp\" function to be used by the \"sort\" function of a\n list when ordering the titles found in a knowledge base by string-\n length - LONGEST -> SHORTEST.\n @param a: (string)\n @param b: (string)\n @return: (integer) - 0 if len(a) == len(b); 1 if len(a) < len(b);\n -1 if len(a) > len(b);" }, { "code": "def decode(self, data):\n return Zchunk(lib.zarmour_decode(self._as_parameter_, data), True)", "docstring": "Decode an armoured string into a chunk. The decoded output is\nnull-terminated, so it may be treated as a string, if that's what\nit was prior to encoding." }, { "code": "def duration(self):\n if not self.started:\n return None\n start = self.started\n end = self.completed\n if not end:\n end = datetime.utcnow()\n return end - start", "docstring": "Return a timedelta for this task.\n\n Measure the time between this task's start and end time, or \"now\"\n if the task has not yet finished.\n\n :returns: timedelta object, or None if the task has not even started." }, { "code": "def check_dynamic_route_exists(pattern, routes_to_check, parameters):\n for ndx, route in enumerate(routes_to_check):\n if route.pattern == pattern and route.parameters == parameters:\n return ndx, route\n else:\n return -1, None", "docstring": "Check if a URL pattern exists in a list of routes provided based on\n the comparison of URL pattern and the parameters.\n\n :param pattern: URL parameter pattern\n :param routes_to_check: list of dynamic routes either hashable or\n unhashable routes.\n :param parameters: List of :class:`Parameter` items\n :return: Tuple of index and route if matching route exists else\n -1 for index and None for route" }, { "code": "def add_hostname_cn(self):\n ip = unit_get('private-address')\n addresses = [ip]\n vip = get_vip_in_network(resolve_network_cidr(ip))\n if vip:\n addresses.append(vip)\n self.hostname_entry = {\n 'cn': get_hostname(ip),\n 'addresses': addresses}", "docstring": "Add a request for the hostname of the machine" }, { "code": "def generator_to_list(fn):\n def wrapper(*args, **kw):\n return list(fn(*args, **kw))\n return wrapper", "docstring": "This decorator is for flat_list function.\n It converts returned generator to list." }, { "code": "def update_voice_model(self,\n customization_id,\n name=None,\n description=None,\n words=None,\n **kwargs):\n if customization_id is None:\n raise ValueError('customization_id must be provided')\n if words is not None:\n words = [self._convert_model(x, Word) for x in words]\n headers = {}\n if 'headers' in kwargs:\n headers.update(kwargs.get('headers'))\n sdk_headers = get_sdk_headers('text_to_speech', 'V1',\n 'update_voice_model')\n headers.update(sdk_headers)\n data = {'name': name, 'description': description, 'words': words}\n url = '/v1/customizations/{0}'.format(\n *self._encode_path_vars(customization_id))\n response = self.request(\n method='POST',\n url=url,\n headers=headers,\n json=data,\n accept_json=True)\n return response", "docstring": "Update a custom model.\n\n Updates information for the specified custom voice model. You can update metadata\n such as the name and description of the voice model. You can also update the words\n in the model and their translations. Adding a new translation for a word that\n already exists in a custom model overwrites the word's existing translation. A\n custom model can contain no more than 20,000 entries. You must use credentials for\n the instance of the service that owns a model to update it.\n You can define sounds-like or phonetic translations for words. A sounds-like\n translation consists of one or more words that, when combined, sound like the\n word. Phonetic translations are based on the SSML phoneme format for representing\n a word. You can specify them in standard International Phonetic Alphabet (IPA)\n representation\n <phoneme alphabet=\\\"ipa\\\"\n ph=\\\"təmˈɑto\\\"></phoneme>\n or in the proprietary IBM Symbolic Phonetic Representation (SPR)\n <phoneme alphabet=\\\"ibm\\\"\n ph=\\\"1gAstroEntxrYFXs\\\"></phoneme>\n **Note:** This method is currently a beta release.\n **See also:**\n * [Updating a custom\n model](https://cloud.ibm.com/docs/services/text-to-speech/custom-models.html#cuModelsUpdate)\n * [Adding words to a Japanese custom\n model](https://cloud.ibm.com/docs/services/text-to-speech/custom-entries.html#cuJapaneseAdd)\n * [Understanding\n customization](https://cloud.ibm.com/docs/services/text-to-speech/custom-intro.html).\n\n :param str customization_id: The customization ID (GUID) of the custom voice\n model. You must make the request with service credentials created for the instance\n of the service that owns the custom model.\n :param str name: A new name for the custom voice model.\n :param str description: A new description for the custom voice model.\n :param list[Word] words: An array of `Word` objects that provides the words and\n their translations that are to be added or updated for the custom voice model.\n Pass an empty array to make no additions or updates.\n :param dict headers: A `dict` containing the request headers\n :return: A `DetailedResponse` containing the result, headers and HTTP status code.\n :rtype: DetailedResponse" }, { "code": "def _sideral(date, longitude=0., model='mean', eop_correction=True, terms=106):\n t = date.change_scale('UT1').julian_century\n theta = 67310.54841 + (876600 * 3600 + 8640184.812866) * t + 0.093104 * t ** 2\\\n - 6.2e-6 * t ** 3\n theta /= 240.\n if model == 'apparent':\n theta += equinox(date, eop_correction, terms)\n theta += longitude\n theta %= 360.\n return theta", "docstring": "Get the sideral time at a defined date\n\n Args:\n date (Date):\n longitude (float): Longitude of the observer (in degrees)\n East positive/West negative.\n model (str): 'mean' or 'apparent' for GMST and GAST respectively\n Return:\n float: Sideral time in degrees\n\n GMST: Greenwich Mean Sideral Time\n LST: Local Sideral Time (Mean)\n GAST: Greenwich Apparent Sideral Time" }, { "code": "def _parse_image_multilogs_string(config, ret, repo):\n image_logs, infos = [], None\n if ret and ret.strip().startswith('{') and ret.strip().endswith('}'):\n pushd = 0\n buf = ''\n for char in ret:\n buf += char\n if char == '{':\n pushd += 1\n if char == '}':\n pushd -= 1\n if pushd == 0:\n try:\n buf = json.loads(buf)\n except Exception:\n pass\n image_logs.append(buf)\n buf = ''\n image_logs.reverse()\n for l in image_logs:\n if isinstance(l, dict):\n if l.get('status') == 'Download complete' and l.get('id'):\n infos = _get_image_infos(config, repo)\n break\n return image_logs, infos", "docstring": "Parse image log strings into grokable data" }, { "code": "def shift_up(self, times=1):\n try:\n return Location(self._rank + times, self._file)\n except IndexError as e:\n raise IndexError(e)", "docstring": "Finds Location shifted up by 1\n\n :rtype: Location" }, { "code": "def create_stemmer(self, isDev=False):\n words = self.get_words(isDev)\n dictionary = ArrayDictionary(words)\n stemmer = Stemmer(dictionary)\n resultCache = ArrayCache()\n cachedStemmer = CachedStemmer(resultCache, stemmer)\n return cachedStemmer", "docstring": "Returns Stemmer instance" }, { "code": "def setup_tree(ctx, verbose=None, root=None, tree_dir=None, modules_dir=None):\n print('Setting up the tree')\n ctx.run('python bin/setup_tree.py -t {0} -r {1} -m {2}'.format(tree_dir, root, modules_dir))", "docstring": "Sets up the SDSS tree enviroment" }, { "code": "def pipeline_id_from_name(name, region=None, key=None, keyid=None, profile=None):\n r = {}\n result_pipelines = list_pipelines()\n if 'error' in result_pipelines:\n return result_pipelines\n for pipeline in result_pipelines['result']:\n if pipeline['name'] == name:\n r['result'] = pipeline['id']\n return r\n r['error'] = 'No pipeline found with name={0}'.format(name)\n return r", "docstring": "Get the pipeline id, if it exists, for the given name.\n\n CLI example:\n\n .. code-block:: bash\n\n salt myminion boto_datapipeline.pipeline_id_from_name my_pipeline_name" }, { "code": "def stitchModules(module, fallbackModule):\n for name, attr in fallbackModule.__dict__.items():\n if name not in module.__dict__:\n module.__dict__[name] = attr", "docstring": "complete missing attributes with those in fallbackModule\n\n imagine you have 2 modules: a and b\n a is some kind of an individualised module of b - but will maybe\n not contain all attributes of b.\n in this case a should use the attributes from b\n\n >>> a.var1 = 'individual 1'\n\n # what we now want is to all all missing attributes from b to a:\n\n >>> stitchModules(a,b)\n\n >>> print a.var1\n individual 1\n >>> print a.var2\n standard 2" }, { "code": "def _print_download_progress_msg(self, msg, flush=False):\n if self._interactive_mode():\n self._max_prog_str = max(self._max_prog_str, len(msg))\n sys.stdout.write(\"\\r%-{}s\".format(self._max_prog_str) % msg)\n sys.stdout.flush()\n if flush:\n print(\"\\n\")\n else:\n logging.info(msg)", "docstring": "Prints a message about download progress either to the console or TF log.\n\n Args:\n msg: Message to print.\n flush: Indicates whether to flush the output (only used in interactive\n mode)." }, { "code": "def template_filter(self, param=None):\n def deco(func):\n name = param or func.__name__\n self.filters[name] = func\n return func\n return deco", "docstring": "Returns a decorator that adds the wrapped function to dictionary of template filters.\n\n The wrapped function is keyed by either the supplied param (if supplied)\n or by the wrapped functions name.\n\n :param param: Optional name to use instead of the name of the function to be wrapped\n :return: A decorator to wrap a template filter function\n :rtype: callable" }, { "code": "def update(self):\n if not self.calendar_id:\n return False\n url = self.build_url(self._endpoints.get('calendar'))\n data = {\n self._cc('name'): self.name,\n self._cc('color'): self._cc(self.color.value\n if isinstance(self.color, CalendarColor)\n else self.color)\n }\n response = self.con.patch(url, data=data)\n return bool(response)", "docstring": "Updates this calendar. Only name and color can be changed.\n\n :return: Success / Failure\n :rtype: bool" }, { "code": "def as_child(cls, global_config, parent=None):\n try:\n setproctitle('rejester worker')\n random.seed()\n yakonfig.set_default_config([yakonfig, dblogger, rejester],\n config=global_config)\n worker = cls(yakonfig.get_global_config(rejester.config_name))\n worker.register(parent=parent)\n did_work = worker.run(set_title=True)\n worker.unregister()\n if did_work:\n sys.exit(cls.EXIT_SUCCESS)\n else:\n sys.exit(cls.EXIT_BORED)\n except Exception, e:\n if len(logging.root.handlers) > 0:\n logger.critical('failed to do any work', exc_info=e)\n sys.exit(cls.EXIT_EXCEPTION)", "docstring": "Run a single job in a child process.\n\n This method never returns; it always calls :func:`sys.exit`\n with an error code that says what it did." }, { "code": "def getDisplayName(self):\n if self.alias == \"\":\n return self.name\n return self.name + \" as \" + self.alias", "docstring": "Provides a name for display purpose respecting the alias" }, { "code": "def boost_error_level(version, error, segments, eci, is_sa=False):\n if error not in (consts.ERROR_LEVEL_H, None) and len(segments) == 1:\n levels = [consts.ERROR_LEVEL_L, consts.ERROR_LEVEL_M,\n consts.ERROR_LEVEL_Q, consts.ERROR_LEVEL_H]\n if version < 1:\n levels.pop()\n if version < consts.VERSION_M4:\n levels.pop()\n data_length = segments.bit_length_with_overhead(version, eci, is_sa=is_sa)\n for level in levels[levels.index(error)+1:]:\n try:\n found = consts.SYMBOL_CAPACITY[version][level] >= data_length\n except KeyError:\n break\n if found:\n error = level\n return error", "docstring": "\\\n Increases the error level if possible.\n\n :param int version: Version constant.\n :param int|None error: Error level constant or ``None``\n :param Segments segments: Instance of :py:class:`Segments`\n :param bool eci: Indicates if ECI designator should be written.\n :param bool is_sa: Indicates if Structured Append mode ist used." }, { "code": "def get_url(self, datatype, verb, urltype, params={}, api_host=None, api_version=None):\n api_version = api_version or 'v1'\n api_host = api_host or self.host\n subst = params.copy()\n subst['api_host'] = api_host\n subst['api_version'] = api_version\n url = \"https://{api_host}/services/api/{api_version}\"\n url += self.get_url_path(datatype, verb, urltype, params, api_version)\n return url.format(**subst)", "docstring": "Returns a fully formed url\n\n :param datatype: a string identifying the data the url will access.\n :param verb: the HTTP verb needed for use with the url.\n :param urltype: an adjective used to the nature of the request.\n :param \\*\\*params: substitution variables for the URL.\n :return: string\n :rtype: A fully formed url." }, { "code": "def set(self, key: bytes, value: bytes) -> Tuple[Hash32]:\n validate_is_bytes(key)\n validate_length(key, self._key_size)\n validate_is_bytes(value)\n path = to_int(key)\n node = value\n _, branch = self._get(key)\n proof_update = []\n target_bit = 1\n for sibling_node in reversed(branch):\n node_hash = keccak(node)\n proof_update.append(node_hash)\n self.db[node_hash] = node\n if (path & target_bit):\n node = sibling_node + node_hash\n else:\n node = node_hash + sibling_node\n target_bit <<= 1\n self.root_hash = keccak(node)\n self.db[self.root_hash] = node\n return tuple(reversed(proof_update))", "docstring": "Returns all updated hashes in root->leaf order" }, { "code": "def jira(test_key):\n def decorator(test_item):\n def modified_test(*args, **kwargs):\n save_jira_conf()\n try:\n test_item(*args, **kwargs)\n except Exception as e:\n error_message = get_error_message_from_exception(e)\n test_comment = \"The test '{}' has failed: {}\".format(args[0].get_method_name(), error_message)\n add_jira_status(test_key, 'Fail', test_comment)\n raise\n add_jira_status(test_key, 'Pass', None)\n modified_test.__name__ = test_item.__name__\n return modified_test\n return decorator", "docstring": "Decorator to update test status in Jira\n\n :param test_key: test case key in Jira\n :returns: jira test" }, { "code": "def destroy(self):\n if not hasattr(self, 'server') or not self.server:\n raise Exception(\n)\n return self.server.cloud_manager.delete_firewall_rule(\n self.server.uuid,\n self.position\n )", "docstring": "Remove this FirewallRule from the API.\n\n This instance must be associated with a server for this method to work,\n which is done by instantiating via server.get_firewall_rules()." }, { "code": "def _attempt_to_raise_license_error(data_dir):\n if isinstance(data_dir, bytes):\n data_dir = _decode(data_dir)\n data_dir = os.path.join(data_dir, 'Data')\n current_date = dt.date.today().strftime('%Y%m%d')\n timestamp = dt.datetime.today().strftime('[%Y-%m-%d %H:%M:%S]')\n data_files = os.listdir(data_dir)\n for f in data_files:\n if f == (current_date + '.err'):\n file_name = os.path.join(data_dir, f)\n with fopen(file_name) as error_file:\n for line in error_file:\n if not line.startswith(timestamp):\n continue\n if 'Not valid license' in line:\n raise LicenseError('Your license appears to have '\n 'expired. Try running \"pynlpir '\n 'update\".')\n elif 'Can not open License file' in line:\n raise LicenseError('Your license appears to be '\n 'missing. Try running \"pynlpir '\n 'update\".')", "docstring": "Raise an error if NLPIR has detected a missing or expired license.\n\n :param str data_dir: The directory containing NLPIR's `Data` directory.\n :raises LicenseError: The NLPIR license appears to be missing or expired." }, { "code": "def get_smart_invite(self, smart_invite_id, recipient_email):\n params = {\n 'smart_invite_id': smart_invite_id,\n 'recipient_email': recipient_email\n }\n return self.request_handler.get('smart_invites', params=params, use_api_key=True).json()", "docstring": "Gets the details for a smart invite.\n\n :param string smart_invite_id: - A String uniquely identifying the event for your\n application (note: this is NOT an ID generated by Cronofy).\n :param string recipient_email: - The email address for the recipient to get details for." }, { "code": "def circles_pycairo(width, height, color):\n cairo_color = color / rgb(255, 255, 255)\n surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)\n ctx = cairo.Context(surface)\n ctx.new_path()\n ctx.set_source_rgb(cairo_color.red, cairo_color.green, cairo_color.blue)\n ctx.arc(width / 2, height / 2, width / 2, 0, 2 * pi)\n ctx.fill()\n surface.write_to_png('circles.png')", "docstring": "Implementation of circle border with PyCairo." }, { "code": "def _append_object_entry(obj, list_name, entry):\n obj_list = getattr(obj, list_name, None)\n if obj_list is None:\n obj_list = []\n setattr(obj, list_name, obj_list)\n assert isinstance(obj_list, list)\n if entry not in obj_list:\n obj_list.append(entry)", "docstring": "Appends the given entry in the given object list.\n Creates the list field if needed.\n\n :param obj: The object that contains the list\n :param list_name: The name of the list member in *obj*\n :param entry: The entry to be added to the list\n :raise ValueError: Invalid attribute content" }, { "code": "def search(\n self,\n q=\"yellow flower\",\n lang=\"en\",\n video_type=\"all\",\n category=\"\",\n min_width=0,\n min_height=0,\n editors_choice=\"false\",\n safesearch=\"false\",\n order=\"popular\",\n page=1,\n per_page=20,\n callback=\"\",\n pretty=\"false\",\n ):\n payload = {\n \"key\": self.api_key,\n \"q\": q,\n \"lang\": lang,\n \"video_type\": video_type,\n \"category\": category,\n \"min_width\": min_width,\n \"min_height\": min_height,\n \"editors_choice\": editors_choice,\n \"safesearch\": safesearch,\n \"order\": order,\n \"page\": page,\n \"per_page\": per_page,\n \"callback\": callback,\n \"pretty\": pretty,\n }\n resp = get(self.root_url + \"videos/\", params=payload)\n if resp.status_code == 200:\n return resp.json()\n else:\n raise ValueError(resp.text)", "docstring": "returns videos API data in dict\n\n Videos search\n\n :param q :type str :desc A URL encoded search term. If omitted,\n all images are returned. This value may not exceed 100 characters.\n Example: \"yellow+flower\"\n Default: \"yellow+flower\"\n\n :param lang :type str :desc Language code of the language to be searched in.\n Accepted values: cs, da, de, en, es, fr, id, it, hu, nl, no, pl, pt, ro, sk, fi,\n sv, tr, vi, th, bg, ru, el, ja, ko, zh\n Default: \"en\"\n For more info, see https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes\n\n :param video_type :type str :desc Filter results by video type.\n Accepted values: \"all\", \"film\", \"animation\"\n Default: \"all\"\n\n :param category :type str :desc Filter results by category.\n Accepted values: fashion, nature, backgrounds, science, education, people,\n feelings, religion, health, places, animals, industry, food, computer, sports,\n transportation, travel, buildings, business, music\n\n :param min_width :type int :desc Minimum image width\n Default: 0\n\n :param min_height :type int :desc Minimum image height\n Default: 0\n\n :param editors_choice :type bool (python-pixabay use \"true\" and \"false\" string instead)\n :desc Select images that have received\n an Editor's Choice award.\n Accepted values: \"true\", \"false\"\n Default: \"false\"\n\n :param safesearch :type bool (python-pixabay use \"true\" and \"false\" string instead)\n :desc A flag indicating that only images suitable\n for all ages should be returned.\n Accepted values: \"true\", \"false\"\n Default: \"false\"\n\n :param order :type str :desc How the results should be ordered.\n Accepted values: \"popular\", \"latest\"\n Default: \"popular\"\n\n :param page :type int :desc Returned search results are paginated.\n Use this parameter to select the page number.\n Default: 1\n\n :param per_page :type int :desc Determine the number of results per page.\n Accepted values: 3 - 200\n Default: 20\n\n :param callback :type str :desc JSONP callback function name\n\n :param pretty :type bool (python-pixabay use \"true\" and \"false\" string instead)\n :desc Indent JSON output. This option should not\n be used in production.\n Accepted values: \"true\", \"false\"\n Default: \"false\"\n\n Code Example\n >>> from pixabay import Video\n >>>\n >>> video = Video(\"api_key\")\n >>> video.search(q=\"apple\", page=1)" }, { "code": "def download_spt_forecast(self, extract_directory):\n needed_vars = (self.spt_watershed_name,\n self.spt_subbasin_name,\n self.spt_forecast_date_string,\n self.ckan_engine_url,\n self.ckan_api_key,\n self.ckan_owner_organization)\n if None not in needed_vars:\n er_manager = ECMWFRAPIDDatasetManager(self.ckan_engine_url,\n self.ckan_api_key,\n self.ckan_owner_organization)\n er_manager.download_prediction_dataset(watershed=self.spt_watershed_name,\n subbasin=self.spt_subbasin_name,\n date_string=self.spt_forecast_date_string,\n extract_directory=extract_directory)\n return glob(os.path.join(extract_directory, self.spt_forecast_date_string, \"Qout*52.nc\"))[0]\n elif needed_vars.count(None) == len(needed_vars):\n log.info(\"Skipping streamflow forecast download ...\")\n return None\n else:\n raise ValueError(\"To download the forecasts, you need to set: \\n\"\n \"spt_watershed_name, spt_subbasin_name, spt_forecast_date_string \\n\"\n \"ckan_engine_url, ckan_api_key, and ckan_owner_organization.\")", "docstring": "Downloads Streamflow Prediction Tool forecast data" }, { "code": "def setCenter(self, loc):\n offset = self.getCenter().getOffset(loc)\n return self.setLocation(self.getTopLeft().offset(offset))", "docstring": "Move this region so it is centered on ``loc``" }, { "code": "def get_branding(self, branding_id):\n connection = Connection(self.token)\n connection.set_url(self.production, self.BRANDINGS_ID_URL % branding_id)\n return connection.get_request()", "docstring": "Get a concrete branding\n @branding_id: Id of the branding to fetch\n @return Branding" }, { "code": "def _event_funcs(self, event: str) -> Iterable[Callable]:\n for func in self._events[event]:\n yield func", "docstring": "Returns an Iterable of the functions subscribed to a event.\n\n :param event: Name of the event.\n :type event: str\n\n :return: A iterable to do things with.\n :rtype: Iterable" }, { "code": "def _api_itemvalue(self, plugin, item, value=None, history=False, nb=0):\n response.content_type = 'application/json; charset=utf-8'\n if plugin not in self.plugins_list:\n abort(400, \"Unknown plugin %s (available plugins: %s)\" % (plugin, self.plugins_list))\n self.__update__()\n if value is None:\n if history:\n ret = self.stats.get_plugin(plugin).get_stats_history(item, nb=int(nb))\n else:\n ret = self.stats.get_plugin(plugin).get_stats_item(item)\n if ret is None:\n abort(404, \"Cannot get item %s%s in plugin %s\" % (item, 'history ' if history else '', plugin))\n else:\n if history:\n ret = None\n else:\n ret = self.stats.get_plugin(plugin).get_stats_value(item, value)\n if ret is None:\n abort(404, \"Cannot get item %s(%s=%s) in plugin %s\" % ('history ' if history else '', item, value, plugin))\n return ret", "docstring": "Father method for _api_item and _api_value." }, { "code": "def nonoverlap(item_a, time_a, item_b, time_b, max_value):\n return np.minimum(1 - item_a.count_overlap(time_a, item_b, time_b), max_value) / float(max_value)", "docstring": "Percentage of pixels in each object that do not overlap with the other object\n\n Args:\n item_a: STObject from the first set in ObjectMatcher\n time_a: Time integer being evaluated\n item_b: STObject from the second set in ObjectMatcher\n time_b: Time integer being evaluated\n max_value: Maximum distance value used as scaling value and upper constraint.\n\n Returns:\n Distance value between 0 and 1." }, { "code": "def focus_first_child(self):\n w, focuspos = self.get_focus()\n child = self._tree.first_child_position(focuspos)\n if child is not None:\n self.set_focus(child)", "docstring": "move focus to first child of currently focussed one" }, { "code": "def languages(self, key, value):\n languages = self.get('languages', [])\n values = force_list(value.get('a'))\n for value in values:\n for language in RE_LANGUAGE.split(value):\n try:\n name = language.strip().capitalize()\n languages.append(pycountry.languages.get(name=name).alpha_2)\n except KeyError:\n pass\n return languages", "docstring": "Populate the ``languages`` key." }, { "code": "def rightStatus(self, sheet):\n 'Compose right side of status bar.'\n if sheet.currentThreads:\n gerund = (' '+sheet.progresses[0].gerund) if sheet.progresses else ''\n status = '%9d %2d%%%s' % (len(sheet), sheet.progressPct, gerund)\n else:\n status = '%9d %s' % (len(sheet), sheet.rowtype)\n return status, 'color_status'", "docstring": "Compose right side of status bar." }, { "code": "def get_consensus_at(self, block_id):\n query = 'SELECT consensus_hash FROM snapshots WHERE block_id = ?;'\n args = (block_id,)\n con = self.db_open(self.impl, self.working_dir)\n rows = self.db_query_execute(con, query, args, verbose=False)\n res = None\n for r in rows:\n res = r['consensus_hash']\n con.close()\n return res", "docstring": "Get the consensus hash at a given block.\n Return the consensus hash if we have one for this block.\n Return None if we don't" }, { "code": "def search(self, params, standardize=False):\n resp = self._request(ENDPOINTS['SEARCH'], params)\n if not standardize:\n return resp\n for res in resp['result_data']:\n res = self.standardize(res)\n return resp", "docstring": "Get a list of person objects for the given search params.\n\n :param params: Dictionary specifying the query parameters\n :param standardize: Whether to standardize names and other features,\n currently disabled for backwards compatibility. Currently\n standardizes names, lowercases emails, and removes faculty label\n from affiliation.\n\n >>> people = d.search({'first_name': 'tobias', 'last_name': 'funke'})" }, { "code": "def bs_values_df(run_list, estimator_list, estimator_names, n_simulate,\n **kwargs):\n tqdm_kwargs = kwargs.pop('tqdm_kwargs', {'desc': 'bs values'})\n assert len(estimator_list) == len(estimator_names), (\n 'len(estimator_list) = {0} != len(estimator_names = {1}'\n .format(len(estimator_list), len(estimator_names)))\n bs_values_list = pu.parallel_apply(\n nestcheck.error_analysis.run_bootstrap_values, run_list,\n func_args=(estimator_list,), func_kwargs={'n_simulate': n_simulate},\n tqdm_kwargs=tqdm_kwargs, **kwargs)\n df = pd.DataFrame()\n for i, name in enumerate(estimator_names):\n df[name] = [arr[i, :] for arr in bs_values_list]\n for vals_shape in df.loc[0].apply(lambda x: x.shape).values:\n assert vals_shape == (n_simulate,), (\n 'Should be n_simulate=' + str(n_simulate) + ' values in ' +\n 'each cell. The cell contains array with shape ' +\n str(vals_shape))\n return df", "docstring": "Computes a data frame of bootstrap resampled values.\n\n Parameters\n ----------\n run_list: list of dicts\n List of nested sampling run dicts.\n estimator_list: list of functions\n Estimators to apply to runs.\n estimator_names: list of strs\n Name of each func in estimator_list.\n n_simulate: int\n Number of bootstrap replications to use on each run.\n kwargs:\n Kwargs to pass to parallel_apply.\n\n Returns\n -------\n bs_values_df: pandas data frame\n Columns represent estimators and rows represent runs.\n Each cell contains a 1d array of bootstrap resampled values for the run\n and estimator." }, { "code": "def createThreeObjects():\n objectA = zip(range(10), range(10))\n objectB = [(0, 0), (2, 2), (1, 1), (1, 4), (4, 2), (4, 1)]\n objectC = [(0, 0), (1, 1), (3, 1), (0, 1)]\n return [objectA, objectB, objectC]", "docstring": "Helper function that creates a set of three objects used for basic\n experiments.\n\n :return: (list(list(tuple)) List of lists of feature / location pairs." }, { "code": "def _update_quoting_state(self, ch):\n is_escaped = self.escaped\n self.escaped = (not self.escaped and\n ch == '\\\\' and\n self.quotes != self.SQUOTE)\n if self.escaped:\n return ''\n if is_escaped:\n if self.quotes == self.DQUOTE:\n if ch == '\"':\n return ch\n return \"{0}{1}\".format('\\\\', ch)\n return ch\n if self.quotes is None:\n if ch in (self.SQUOTE, self.DQUOTE):\n self.quotes = ch\n return ''\n elif self.quotes == ch:\n self.quotes = None\n return ''\n return ch", "docstring": "Update self.quotes and self.escaped\n\n :param ch: str, current character\n :return: ch if it was not used to update quoting state, else ''" }, { "code": "def handle(self, data, **kwargs):\n try:\n if self.many:\n return self.mapper.many(raw=self.raw, **self.mapper_kwargs).marshal(\n data, role=self.role\n )\n else:\n return self.mapper(\n data=data,\n obj=self.obj,\n partial=self.partial,\n **self.mapper_kwargs\n ).marshal(role=self.role)\n except MappingInvalid as e:\n self.handle_error(e)", "docstring": "Run marshalling for the specified mapper_class.\n\n Supports both .marshal and .many().marshal Kim interfaces. Handles errors raised\n during marshalling and automatically returns a HTTP error response.\n\n :param data: Data to be marshaled.\n :returns: Marshaled object according to mapper configuration\n :raises: :class:`werkzeug.exceptions.UnprocessableEntity`" }, { "code": "def path_from_row_pks(row, pks, use_rowid, quote=True):\n if use_rowid:\n bits = [row['rowid']]\n else:\n bits = [\n row[pk][\"value\"] if isinstance(row[pk], dict) else row[pk]\n for pk in pks\n ]\n if quote:\n bits = [urllib.parse.quote_plus(str(bit)) for bit in bits]\n else:\n bits = [str(bit) for bit in bits]\n return ','.join(bits)", "docstring": "Generate an optionally URL-quoted unique identifier\n for a row from its primary keys." }, { "code": "def get_int(self):\n token = self.get().unescape()\n if not token.is_identifier():\n raise dns.exception.SyntaxError('expecting an identifier')\n if not token.value.isdigit():\n raise dns.exception.SyntaxError('expecting an integer')\n return int(token.value)", "docstring": "Read the next token and interpret it as an integer.\n\n @raises dns.exception.SyntaxError:\n @rtype: int" }, { "code": "def watch(self, keys, on_watch, filters=None, start_revision=None, return_previous=None):\n d = self._start_watching(keys, on_watch, filters, start_revision, return_previous)\n def on_err(*args):\n if args[0].type not in [CancelledError, ResponseFailed]:\n self.log.warn('etcd watch terminated with \"{error}\"', error=args[0].type)\n return args[0]\n d.addErrback(on_err)\n return d", "docstring": "Watch one or more keys or key sets and invoke a callback.\n\n Watch watches for events happening or that have happened. The entire event history\n can be watched starting from the last compaction revision.\n\n :param keys: Watch these keys / key sets.\n :type keys: list of bytes or list of instance of :class:`txaioetcd.KeySet`\n\n :param on_watch: The callback to invoke upon receiving\n a watch event.\n :type on_watch: callable\n\n :param filters: Any filters to apply.\n\n :param start_revision: start_revision is an optional\n revision to watch from (inclusive). No start_revision is \"now\".\n :type start_revision: int\n\n :param return_previous: Flag to request returning previous values.\n\n :returns: A deferred that just fires when watching has started successfully,\n or which fires with an error in case the watching could not be started.\n :rtype: twisted.internet.Deferred" }, { "code": "def _checkReturnTo(self, message, return_to):\n try:\n self._verifyReturnToArgs(message.toPostArgs())\n except ProtocolError as why:\n logging.exception(\"Verifying return_to arguments: %s\" % (why, ))\n return False\n msg_return_to = message.getArg(OPENID_NS, 'return_to')\n app_parts = urlparse(urinorm.urinorm(return_to))\n msg_parts = urlparse(urinorm.urinorm(msg_return_to))\n for part in range(0, 3):\n if app_parts[part] != msg_parts[part]:\n return False\n return True", "docstring": "Check an OpenID message and its openid.return_to value\n against a return_to URL from an application. Return True on\n success, False on failure." }, { "code": "def structure_repr(self):\n ret = '{%s}' % ', '.join([str(x) for x in self.elements])\n return self._wrap_packed(ret)", "docstring": "Return the LLVM IR for the structure representation" }, { "code": "def in_group(self, group, dn=False):\n if dn:\n return group in self.groups()\n return group.check_member(self)", "docstring": "Get whether or not the bound CSH LDAP member object is part of a\n group.\n\n Arguments:\n group -- the CSHGroup object (or distinguished name) of the group to\n check membership for" }, { "code": "def set_pending_symbol(self, pending_symbol=None):\n if pending_symbol is None:\n pending_symbol = CodePointArray()\n self.value = bytearray()\n self.pending_symbol = pending_symbol\n self.line_comment = False\n return self", "docstring": "Sets the context's ``pending_symbol`` with the given unicode sequence and resets the context's ``value``.\n\n If the input is None, an empty :class:`CodePointArray` is used." }, { "code": "def write_params(path, *args, **dicts):\n path = Path(path)\n if not path.parent.is_dir():\n path.parent.mkdir(parents=True)\n if len(args) == 1:\n d = args[0]\n with path.open('w') as f:\n for key in d:\n f.write(key + ' = ' + str(d[key]) + '\\n')\n else:\n with path.open('w') as f:\n for k, d in dicts.items():\n f.write('[' + k + ']\\n')\n for key, val in d.items():\n f.write(key + ' = ' + str(val) + '\\n')", "docstring": "Write parameters to file, so that it's readable by read_params.\n\n Uses INI file format." }, { "code": "def check_for_stalled_tasks():\n from api.models.tasks import Task\n for task in Task.objects.filter(status_is_running=True):\n if not task.is_responsive():\n task.system_error()\n if task.is_timed_out():\n task.timeout_error()", "docstring": "Check for tasks that are no longer sending a heartbeat" }, { "code": "def all(self, paths, access=None):\n self.failures = [path for path in paths if not\n isvalid(path, access, filetype='all')]\n return not self.failures", "docstring": "Verify list of paths" }, { "code": "def expanduser(path):\n if hdfs_fs.default_is_local():\n return os.path.expanduser(path)\n m = re.match(r'^~([^/]*)', path)\n if m is None:\n return path\n user = m.groups()[0] or common.DEFAULT_USER\n return '/user/%s%s' % (user, path[m.end(1):])", "docstring": "Replace initial ``~`` or ``~user`` with the user's home directory.\n\n **NOTE:** if the default file system is HDFS, the ``~user`` form is\n expanded regardless of the user's existence." }, { "code": "def to_dict(obj):\n json_obj = {'type' : repr(obj)}\n if obj.is_failed:\n json_obj['errors'] = obj.errors\n elif obj.is_success:\n json_obj['modelOutput'] = obj.model_output\n return json_obj", "docstring": "Generate a JSON serialization for the run state object.\n\n Returns\n -------\n Json-like object\n Json serialization of model run state object" }, { "code": "def _has_argument(func):\n if hasattr(inspect, 'signature'):\n sig = inspect.signature(func)\n return bool(sig.parameters)\n else:\n return bool(inspect.getargspec(func).args)", "docstring": "Test whether a function expects an argument.\n\n :param func:\n The function to be tested for existence of an argument." }, { "code": "def authInsert(user, role, group, site):\n if not role: return True\n for k, v in user['roles'].iteritems():\n for g in v['group']:\n if k in role.get(g, '').split(':'):\n return True\n return False", "docstring": "Authorization function for general insert" }, { "code": "def register_metric_descriptor(self, oc_md):\n metric_type = self.get_metric_type(oc_md)\n with self._md_lock:\n if metric_type in self._md_cache:\n return self._md_cache[metric_type]\n descriptor = self.get_metric_descriptor(oc_md)\n project_name = self.client.project_path(self.options.project_id)\n sd_md = self.client.create_metric_descriptor(project_name, descriptor)\n with self._md_lock:\n self._md_cache[metric_type] = sd_md\n return sd_md", "docstring": "Register a metric descriptor with stackdriver." }, { "code": "def group(self):\n \"Group inherited from items\"\n if self._group:\n return self._group\n group = get_ndmapping_label(self, 'group') if len(self) else None\n if group is None:\n return type(self).__name__\n return group", "docstring": "Group inherited from items" }, { "code": "def triads(key):\n if _triads_cache.has_key(key):\n return _triads_cache[key]\n res = map(lambda x: triad(x, key), keys.get_notes(key))\n _triads_cache[key] = res\n return res", "docstring": "Return all the triads in key.\n\n Implemented using a cache." }, { "code": "def _create_storage_profile(self):\n if self.image_publisher:\n storage_profile = {\n 'image_reference': {\n 'publisher': self.image_publisher,\n 'offer': self.image_offer,\n 'sku': self.image_sku,\n 'version': self.image_version\n },\n }\n else:\n for image in self.compute.images.list():\n if image.name == self.image_id:\n image_id = image.id\n break\n else:\n raise AzureCloudException(\n 'Image with name {0} not found.'.format(self.image_id)\n )\n storage_profile = {\n 'image_reference': {\n 'id': image_id\n }\n }\n return storage_profile", "docstring": "Create the storage profile for the instance.\n\n Image reference can be a custom image name or a published urn." }, { "code": "def install_extension(conn, extension: str):\n query = 'CREATE EXTENSION IF NOT EXISTS \"%s\";'\n with conn.cursor() as cursor:\n cursor.execute(query, (AsIs(extension),))\n installed = check_extension(conn, extension)\n if not installed:\n raise psycopg2.ProgrammingError(\n 'Postgres extension failed installation.', extension\n )", "docstring": "Install Postgres extension." }, { "code": "def __get_jp(self, extractor_processor, sub_output=None):\n if sub_output is None and extractor_processor.output_field is None:\n raise ValueError(\n \"ExtractorProcessors input paths cannot be unioned across fields. Please specify either a sub_output or use a single scalar output_field\")\n if extractor_processor.get_output_jsonpath_with_name(sub_output) is not None:\n return extractor_processor.get_output_jsonpath_with_name(sub_output)\n else:\n return extractor_processor.get_output_jsonpath(sub_output)", "docstring": "Tries to get name from ExtractorProcessor to filter on first.\n Otherwise falls back to filtering based on its metadata" }, { "code": "def roll(self, shifts=None, roll_coords=None, **shifts_kwargs):\n ds = self._to_temp_dataset().roll(\n shifts=shifts, roll_coords=roll_coords, **shifts_kwargs)\n return self._from_temp_dataset(ds)", "docstring": "Roll this array by an offset along one or more dimensions.\n\n Unlike shift, roll may rotate all variables, including coordinates\n if specified. The direction of rotation is consistent with\n :py:func:`numpy.roll`.\n\n Parameters\n ----------\n roll_coords : bool\n Indicates whether to roll the coordinates by the offset\n The current default of roll_coords (None, equivalent to True) is\n deprecated and will change to False in a future version.\n Explicitly pass roll_coords to silence the warning.\n **shifts : keyword arguments of the form {dim: offset}\n Integer offset to rotate each of the given dimensions. Positive\n offsets roll to the right; negative offsets roll to the left.\n\n Returns\n -------\n rolled : DataArray\n DataArray with the same attributes but rolled data and coordinates.\n\n See also\n --------\n shift\n\n Examples\n --------\n\n >>> arr = xr.DataArray([5, 6, 7], dims='x')\n >>> arr.roll(x=1)\n \n array([7, 5, 6])\n Coordinates:\n * x (x) int64 2 0 1" }, { "code": "def append_surface(self, name, surface, alpha=1.):\n self.insert_surface(position=self.df_surfaces.index.shape[0],\n name=name, surface=surface, alpha=alpha)", "docstring": "Append Cairo surface as new layer on top of existing layers.\n\n Args\n ----\n\n name (str) : Name of layer.\n surface (cairo.ImageSurface) : Surface to render.\n alpha (float) : Alpha/transparency level in the range `[0, 1]`." }, { "code": "def resize(self, targ_sz, new_path='tmp', resume=True, fn=None):\n new_ds = []\n dls = [self.trn_dl,self.val_dl,self.fix_dl,self.aug_dl]\n if self.test_dl: dls += [self.test_dl, self.test_aug_dl]\n else: dls += [None,None]\n t = tqdm_notebook(dls)\n for dl in t: new_ds.append(self.resized(dl, targ_sz, new_path, resume, fn))\n t.close()\n return self.__class__(new_ds[0].path, new_ds, self.bs, self.num_workers, self.classes)", "docstring": "Resizes all the images in the train, valid, test folders to a given size.\n\n Arguments:\n targ_sz (int): the target size\n new_path (str): the path to save the resized images (default tmp)\n resume (bool): if True, check for images in the DataSet that haven't been resized yet (useful if a previous resize\n operation was aborted)\n fn (function): optional custom resizing function" }, { "code": "def deploy(self, machine):\n log.debug(\"machine id: %s.\" % machine)\n path = self.path + \"/machines\"\n value, metadata = yield self.client.get(path)\n machines = json.loads(value)\n machines.append(machine)\n yield self.client.set(path, json.dumps(machines))", "docstring": "Deploy service." }, { "code": "def query_all(kind='1', by_count=False, by_order=True):\n if by_count:\n recs = TabTag.select().where(TabTag.kind == kind).order_by(TabTag.count.desc())\n elif by_order:\n recs = TabTag.select().where(TabTag.kind == kind).order_by(TabTag.order)\n else:\n recs = TabTag.select().where(TabTag.kind == kind).order_by(TabTag.uid)\n return recs", "docstring": "Qeury all the categories, order by count or defined order." }, { "code": "def sample(self, fraction, seed=None, exact=False):\n if (fraction > 1 or fraction < 0):\n raise ValueError('Invalid sampling rate: ' + str(fraction))\n if (len(self) == 0):\n return SArray()\n if seed is None:\n seed = abs(hash(\"%0.20f\" % time.time())) % (2 ** 31)\n with cython_context():\n return SArray(_proxy=self.__proxy__.sample(fraction, seed, exact))", "docstring": "Create an SArray which contains a subsample of the current SArray.\n\n Parameters\n ----------\n fraction : float\n Fraction of the rows to fetch. Must be between 0 and 1.\n if exact is False (default), the number of rows returned is\n approximately the fraction times the number of rows.\n\n seed : int, optional\n The random seed for the random number generator.\n\n exact: bool, optional\n Defaults to False. If exact=True, an exact fraction is returned, \n but at a performance penalty.\n\n Returns\n -------\n out : SArray\n The new SArray which contains the subsampled rows.\n\n Examples\n --------\n >>> sa = turicreate.SArray(range(10))\n >>> sa.sample(.3)\n dtype: int\n Rows: 3\n [2, 6, 9]" }, { "code": "def create(self, unique_name, domain_suffix=values.unset):\n data = values.of({'UniqueName': unique_name, 'DomainSuffix': domain_suffix, })\n payload = self._version.create(\n 'POST',\n self._uri,\n data=data,\n )\n return EnvironmentInstance(self._version, payload, service_sid=self._solution['service_sid'], )", "docstring": "Create a new EnvironmentInstance\n\n :param unicode unique_name: The unique_name\n :param unicode domain_suffix: The domain_suffix\n\n :returns: Newly created EnvironmentInstance\n :rtype: twilio.rest.serverless.v1.service.environment.EnvironmentInstance" }, { "code": "def findCampaigns(ra, dec):\n logger.disabled = True\n campaigns_visible = []\n for c in fields.getFieldNumbers():\n fovobj = fields.getKeplerFov(c)\n if onSiliconCheck(ra, dec, fovobj):\n campaigns_visible.append(c)\n logger.disabled = True\n return campaigns_visible", "docstring": "Returns a list of the campaigns that cover a given position.\n\n Parameters\n ----------\n ra, dec : float, float\n Position in decimal degrees (J2000).\n\n Returns\n -------\n campaigns : list of int\n A list of the campaigns that cover the given position." }, { "code": "def get_aa_code(aa_letter):\n aa_code = None\n if aa_letter != 'X':\n for key, val in standard_amino_acids.items():\n if key == aa_letter:\n aa_code = val\n return aa_code", "docstring": "Get three-letter aa code if possible. If not, return None.\n\n If three-letter code is None, will have to find this later from the filesystem.\n\n Parameters\n ----------\n aa_letter : str\n One-letter amino acid code.\n\n Returns\n -------\n aa_code : str, or None\n Three-letter aa code." }, { "code": "def make_bubble_surface(dims=DEFAULT_DIMS, repeat=3):\n gradients = make_gradients(dims)\n return (\n np.sin((gradients[0] - 0.5) * repeat * np.pi) *\n np.sin((gradients[1] - 0.5) * repeat * np.pi))", "docstring": "Makes a surface from the product of sine functions on each axis.\n\n Args:\n dims (pair): the dimensions of the surface to create\n repeat (int): the frequency of the waves is set to ensure this many\n repetitions of the function\n \n Returns:\n surface: A surface." }, { "code": "def relpath(self):\n cwd = self.__class__(os.getcwd())\n return cwd.relpathto(self)", "docstring": "Return this path as a relative path,\n based from the current working directory." }, { "code": "def process_template(self, sql, **kwargs):\n template = self.env.from_string(sql)\n kwargs.update(self.context)\n return template.render(kwargs)", "docstring": "Processes a sql template\n\n >>> sql = \"SELECT '{{ datetime(2017, 1, 1).isoformat() }}'\"\n >>> process_template(sql)\n \"SELECT '2017-01-01T00:00:00'\"" }, { "code": "def _update_feature_log_prob(self, alpha):\n smoothed_fc = self.feature_count_ + alpha\n smoothed_cc = self.class_count_ + alpha * 2\n self.feature_log_prob_ = (np.log(smoothed_fc) -\n np.log(smoothed_cc.reshape(-1, 1)))", "docstring": "Apply smoothing to raw counts and recompute log probabilities" }, { "code": "def _options(self):\n if self._options_cache is None:\n target_url = self.client.get_url(self._URL_KEY, 'OPTIONS', 'options')\n r = self.client.request('OPTIONS', target_url)\n self._options_cache = r.json()\n return self._options_cache", "docstring": "Returns a raw options object\n\n :rtype: dict" }, { "code": "def _output(self, s):\n if s.lower().startswith(b'host: '):\n self._buffer.insert(1, s)\n else:\n self._buffer.append(s)", "docstring": "Host header should always be first" }, { "code": "def format_explanation(explanation, original_msg=None):\n if not conf.is_message_introspection_enabled() and original_msg:\n return original_msg\n explanation = ecu(explanation)\n lines = _split_explanation(explanation)\n result = _format_lines(lines)\n return u('\\n').join(result)", "docstring": "This formats an explanation\n\n Normally all embedded newlines are escaped, however there are\n three exceptions: \\n{, \\n} and \\n~. The first two are intended\n cover nested explanations, see function and attribute explanations\n for examples (.visit_Call(), visit_Attribute()). The last one is\n for when one explanation needs to span multiple lines, e.g. when\n displaying diffs." }, { "code": "def packageGraph(self, packagelevel=None):\n packages = {}\n for module in self.listModules():\n package_name = self.packageOf(module.modname, packagelevel)\n if package_name not in packages:\n dirname = os.path.dirname(module.filename)\n packages[package_name] = Module(package_name, dirname)\n package = packages[package_name]\n for name in module.imports:\n package_name = self.packageOf(name, packagelevel)\n if package_name != package.modname:\n package.imports.add(package_name)\n graph = ModuleGraph()\n graph.modules = packages\n return graph", "docstring": "Convert a module graph to a package graph." }, { "code": "def register_path(self, path, modified_time=None):\n if not foundations.common.path_exists(path):\n raise foundations.exceptions.PathExistsError(\"{0} | '{1}' path doesn't exists!\".format(\n self.__class__.__name__, path))\n if path in self:\n raise umbra.exceptions.PathRegistrationError(\"{0} | '{1}' path is already registered!\".format(\n self.__class__.__name__, path))\n self.__paths[path] = (self.get_path_modified_time(\n path) if modified_time is None else modified_time, os.path.isfile(path))\n return True", "docstring": "Registers given path.\n\n :param path: Path name.\n :type path: unicode\n :param modified_time: Custom modified time.\n :type modified_time: int or float\n :return: Method success.\n :rtype: bool" }, { "code": "def change_and_save(self, update_only_changed_fields=False, **changed_fields):\n bulk_change_and_save(self, update_only_changed_fields=update_only_changed_fields, **changed_fields)\n return self.filter()", "docstring": "Changes a given `changed_fields` on each object in the queryset, saves objects\n and returns the changed objects in the queryset." }, { "code": "def build_pages(self):\n for root, _, files in os.walk(self.pages_dir):\n base_dir = root.replace(self.pages_dir, \"\").lstrip(\"/\")\n if not base_dir.startswith(\"_\"):\n for f in files:\n src_file = os.path.join(base_dir, f)\n self._build_page(src_file)", "docstring": "Iterate over the pages_dir and build the pages" }, { "code": "def _pass_variable(self):\n pass_var = []\n for var in os.environ.keys():\n expVAR = var.split(\"_\")\n if expVAR[0] == self.prgnam.upper() and expVAR[1] != \"PATH\":\n pass_var.append(\"{0}={1}\".format(expVAR[1], os.environ[var]))\n return pass_var", "docstring": "Return enviroment variables" }, { "code": "def getAllSecrets(version=\"\", region=None, table=\"credential-store\",\n context=None, credential=None, session=None, **kwargs):\n if session is None:\n session = get_session(**kwargs)\n dynamodb = session.resource('dynamodb', region_name=region)\n kms = session.client('kms', region_name=region)\n secrets = listSecrets(region, table, **kwargs)\n if credential and WILDCARD_CHAR in credential:\n names = set(expand_wildcard(credential,\n [x[\"name\"]\n for x in secrets]))\n else:\n names = set(x[\"name\"] for x in secrets)\n pool = ThreadPool(min(len(names), THREAD_POOL_MAX_SIZE))\n results = pool.map(\n lambda credential: getSecret(credential, version, region, table, context, dynamodb, kms, **kwargs),\n names)\n pool.close()\n pool.join()\n return dict(zip(names, results))", "docstring": "fetch and decrypt all secrets" }, { "code": "def is_gentarget(self, target):\n if self.gentarget_type:\n return isinstance(target, self.gentarget_type)\n else:\n raise NotImplementedError", "docstring": "Predicate which determines whether the target in question is relevant to this codegen task.\n\n E.g., the JaxbGen task considers JaxbLibrary targets to be relevant, and nothing else.\n\n :API: public\n\n :param Target target: The target to check.\n :return: True if this class can generate code for the given target, False otherwise." }, { "code": "def _parse_throttle(self, tablename, throttle):\n amount = []\n desc = self.describe(tablename)\n throughputs = [desc.read_throughput, desc.write_throughput]\n for value, throughput in zip(throttle[1:], throughputs):\n if value == \"*\":\n amount.append(0)\n elif value[-1] == \"%\":\n amount.append(throughput * float(value[:-1]) / 100.0)\n else:\n amount.append(float(value))\n cap = Capacity(*amount)\n return RateLimit(total=cap, callback=self._on_throttle)", "docstring": "Parse a 'throttle' statement and return a RateLimit" }, { "code": "def _reset(self, force=False):\n if not self._closed and (force or self._transaction):\n try:\n self.rollback()\n except Exception:\n pass", "docstring": "Reset a tough connection.\n\n Rollback if forced or the connection was in a transaction." }, { "code": "def perimeter(self):\n if self._is_completely_masked:\n return np.nan * u.pix\n else:\n from skimage.measure import perimeter\n return perimeter(~self._total_mask, neighbourhood=4) * u.pix", "docstring": "The total perimeter of the source segment, approximated lines\n through the centers of the border pixels using a 4-connectivity.\n\n If any masked pixels make holes within the source segment, then\n the perimeter around the inner hole (e.g. an annulus) will also\n contribute to the total perimeter." }, { "code": "def make_json_formatter(graph):\n return {\n \"()\": graph.config.logging.json_formatter.formatter,\n \"fmt\": graph.config.logging.json_required_keys,\n }", "docstring": "Create the default json formatter." }, { "code": "def vault_file(env, default):\n home = os.environ['HOME'] if 'HOME' in os.environ else \\\n os.environ['USERPROFILE']\n filename = os.environ.get(env, os.path.join(home, default))\n filename = abspath(filename)\n if os.path.exists(filename):\n return filename\n return None", "docstring": "The path to a misc Vault file\n This function will check for the env override on a file\n path, compute a fully qualified OS appropriate path to\n the desired file and return it if it exists. Otherwise\n returns None" }, { "code": "def parse_routing_info(cls, records):\n if len(records) != 1:\n raise RoutingProtocolError(\"Expected exactly one record\")\n record = records[0]\n routers = []\n readers = []\n writers = []\n try:\n servers = record[\"servers\"]\n for server in servers:\n role = server[\"role\"]\n addresses = []\n for address in server[\"addresses\"]:\n addresses.append(SocketAddress.parse(address, DEFAULT_PORT))\n if role == \"ROUTE\":\n routers.extend(addresses)\n elif role == \"READ\":\n readers.extend(addresses)\n elif role == \"WRITE\":\n writers.extend(addresses)\n ttl = record[\"ttl\"]\n except (KeyError, TypeError):\n raise RoutingProtocolError(\"Cannot parse routing info\")\n else:\n return cls(routers, readers, writers, ttl)", "docstring": "Parse the records returned from a getServers call and\n return a new RoutingTable instance." }, { "code": "def average_sharded_losses(sharded_losses):\n losses = {}\n for loss_name in sorted(sharded_losses[0]):\n all_shards = [shard_losses[loss_name] for shard_losses in sharded_losses]\n if isinstance(all_shards[0], tuple):\n sharded_num, sharded_den = zip(*all_shards)\n mean_loss = (\n tf.add_n(sharded_num) / tf.maximum(\n tf.cast(1.0, sharded_den[0].dtype), tf.add_n(sharded_den)))\n else:\n mean_loss = tf.reduce_mean(all_shards)\n losses[loss_name] = mean_loss\n return losses", "docstring": "Average losses across datashards.\n\n Args:\n sharded_losses: list>. The loss\n can be a single Tensor or a 2-tuple (numerator and denominator).\n\n Returns:\n losses: dict" }, { "code": "def load_scene(self, item):\n scene = Scene.from_config(self.pyvlx, item)\n self.add(scene)", "docstring": "Load scene from json." }, { "code": "def get_errors(self):\n return [{cr.component_name: cr.get_error()}\n for cr in self.component_results if cr.has_error()]", "docstring": "If there were any business errors fetching data for this property,\n returns the error messages.\n\n Returns:\n string - the error message, or None if there was no error." }, { "code": "def delete_multireddit(self, name, *args, **kwargs):\n url = self.config['multireddit_about'].format(user=self.user.name,\n multi=name)\n if not self._use_oauth:\n self.http.headers['x-modhash'] = self.modhash\n try:\n self.request(url, data={}, method='DELETE', *args, **kwargs)\n finally:\n if not self._use_oauth:\n del self.http.headers['x-modhash']", "docstring": "Delete a Multireddit.\n\n Any additional parameters are passed directly into\n :meth:`~praw.__init__.BaseReddit.request`" }, { "code": "def update(self):\n args = {attr: getattr(self, attr) for attr in self.to_update}\n _perform_command(self, 'user_update', args)", "docstring": "Update the user's details on Todoist.\n\n This method must be called to register any local attribute changes\n with Todoist.\n\n >>> from pytodoist import todoist\n >>> user = todoist.login('john.doe@gmail.com', 'password')\n >>> user.full_name = 'John Smith'\n >>> # At this point Todoist still thinks the name is 'John Doe'.\n >>> user.update()\n >>> # Now the name has been updated on Todoist." }, { "code": "def enable_key(self):\n print(\"This command will enable a disabled key.\")\n apiKeyID = input(\"API Key ID: \")\n try:\n key = self._curl_bitmex(\"/apiKey/enable\",\n postdict={\"apiKeyID\": apiKeyID})\n print(\"Key with ID %s enabled.\" % key[\"id\"])\n except:\n print(\"Unable to enable key, please try again.\")\n self.enable_key()", "docstring": "Enable an existing API Key." }, { "code": "def upload_keys(self, device_keys=None, one_time_keys=None):\n content = {}\n if device_keys:\n content[\"device_keys\"] = device_keys\n if one_time_keys:\n content[\"one_time_keys\"] = one_time_keys\n return self._send(\"POST\", \"/keys/upload\", content=content)", "docstring": "Publishes end-to-end encryption keys for the device.\n\n Said device must be the one used when logging in.\n\n Args:\n device_keys (dict): Optional. Identity keys for the device. The required\n keys are:\n\n | user_id (str): The ID of the user the device belongs to. Must match\n the user ID used when logging in.\n | device_id (str): The ID of the device these keys belong to. Must match\n the device ID used when logging in.\n | algorithms (list): The encryption algorithms supported by this\n device.\n | keys (dict): Public identity keys. Should be formatted as\n : .\n | signatures (dict): Signatures for the device key object. Should be\n formatted as : {: }\n\n one_time_keys (dict): Optional. One-time public keys. Should be\n formatted as : , the key format being\n determined by the algorithm." }, { "code": "def form(cls, name, type_=Type.String, description=None, required=None, default=None,\n minimum=None, maximum=None, enum=None, **options):\n if minimum is not None and maximum is not None and minimum > maximum:\n raise ValueError(\"Minimum must be less than or equal to the maximum.\")\n return cls(name, In.Form, type_, None, description,\n required=required, default=default,\n minimum=minimum, maximum=maximum,\n enum=enum, **options)", "docstring": "Define form parameter." }, { "code": "def answer_approval(self, issue_id_or_key, approval_id, decision):\n url = 'rest/servicedeskapi/request/{0}/approval/{1}'.format(issue_id_or_key, approval_id)\n data = {'decision': decision}\n return self.post(url, headers=self.experimental_headers, data=data)", "docstring": "Answer a pending approval\n\n :param issue_id_or_key: str\n :param approval_id: str\n :param decision: str\n :return:" }, { "code": "def html_to_text(html, base_url='', bodywidth=CONFIG_DEFAULT):\n def _patched_handle_charref(c):\n self = h\n charref = self.charref(c)\n if self.code or self.pre:\n charref = cgi.escape(charref)\n self.o(charref, 1)\n def _patched_handle_entityref(c):\n self = h\n entityref = self.entityref(c)\n if self.code or self.pre:\n entityref = cgi.escape(entityref)\n self.o(entityref, 1)\n h = HTML2Text(baseurl=base_url, bodywidth=config.BODY_WIDTH if bodywidth is CONFIG_DEFAULT else bodywidth)\n h.handle_entityref = _patched_handle_entityref\n h.handle_charref = _patched_handle_charref\n return h.handle(html).rstrip()", "docstring": "Convert a HTML mesasge to plain text." }, { "code": "def importTTX(self):\n import os\n import re\n prefix = \"com.github.fonttools.ttx\"\n sfntVersionRE = re.compile('(^$)',\n flags=re.MULTILINE)\n if not hasattr(self.ufo, \"data\"):\n return\n if not self.ufo.data.fileNames:\n return\n for path in self.ufo.data.fileNames:\n foldername, filename = os.path.split(path)\n if (foldername == prefix and filename.endswith(\".ttx\")):\n ttx = self.ufo.data[path].decode('utf-8')\n ttx = sfntVersionRE.sub(r'\\1\\3', ttx)\n fp = BytesIO(ttx.encode('utf-8'))\n self.otf.importXML(fp)", "docstring": "Merge TTX files from data directory \"com.github.fonttools.ttx\"\n\n **This should not be called externally.** Subclasses\n may override this method to handle the bounds creation\n in a different way if desired." }, { "code": "def FoldValue(self, value):\n if value is False and self._data_type_definition.false_value is not None:\n return self._data_type_definition.false_value\n if value is True and self._data_type_definition.true_value is not None:\n return self._data_type_definition.true_value\n raise ValueError('No matching True and False values')", "docstring": "Folds the data type into a value.\n\n Args:\n value (object): value.\n\n Returns:\n object: folded value.\n\n Raises:\n ValueError: if the data type definition cannot be folded into the value." }, { "code": "def bounding_ellipses(self):\n if (self.linear_growth):\n a1 = self.sma - self.astep / 2.\n a2 = self.sma + self.astep / 2.\n else:\n a1 = self.sma * (1. - self.astep / 2.)\n a2 = self.sma * (1. + self.astep / 2.)\n return a1, a2", "docstring": "Compute the semimajor axis of the two ellipses that bound the\n annulus where integrations take place.\n\n Returns\n -------\n sma1, sma2 : float\n The smaller and larger values of semimajor axis length that\n define the annulus bounding ellipses." }, { "code": "def vectorize_utterance_ohe(self, utterance):\n for i, word in enumerate(utterance):\n if not word in self.vocab_list:\n utterance[i] = ''\n ie_utterance = self.swap_pad_and_zero(self.ie.transform(utterance))\n ohe_utterance = np.array(self.ohe.transform(ie_utterance.reshape(len(ie_utterance), 1)))\n return ohe_utterance", "docstring": "Take in a tokenized utterance and transform it into a sequence of one-hot vectors" }, { "code": "def add_data(self, rawdata):\n for data in rawdata:\n try:\n item = data[0]\n if item[0] == 2:\n continue\n if item[0] != 0:\n warnings.warn(f\"Unknown message type '{item[0]}'\", Warning)\n continue\n item = item[1]\n target = str(item[0])\n try:\n data = item[1]\n except IndexError:\n data = dict()\n try:\n method = getattr(self, self.__head + target)\n method(data)\n except AttributeError:\n self._handle_unhandled(target, data)\n except IndexError:\n LOGGER.warning(\"Wrongly constructed message received: %r\", data)\n self.conn.process_queues()", "docstring": "Add data to given room's state" }, { "code": "def get_high_water_mark(self, mark_type, obstory_name=None):\n if obstory_name is None:\n obstory_name = self.obstory_name\n obstory = self.get_obstory_from_name(obstory_name)\n key_id = self.get_hwm_key_id(mark_type)\n self.con.execute('SELECT time FROM archive_highWaterMarks WHERE markType=%s AND observatoryId=%s',\n (key_id, obstory['uid']))\n results = self.con.fetchall()\n if len(results) > 0:\n return results[0]['time']\n return None", "docstring": "Retrieves the high water mark for a given obstory, defaulting to the current installation ID\n\n :param string mark_type:\n The type of high water mark to set\n :param string obstory_name:\n The obstory ID to check for, or the default installation ID if not specified\n :return:\n A UTC datetime for the high water mark, or None if none was found." }, { "code": "def active_serving_watcher(backend, kitchen, period):\n err_str, use_kitchen = Backend.get_kitchen_from_user(kitchen)\n if use_kitchen is None:\n raise click.ClickException(err_str)\n click.secho('%s - Watching Active OrderRun Changes in Kitchen %s' % (get_datetime(), use_kitchen), fg='green')\n DKCloudCommandRunner.watch_active_servings(backend.dki, use_kitchen, period)\n while True:\n try:\n DKCloudCommandRunner.join_active_serving_watcher_thread_join()\n if not DKCloudCommandRunner.watcher_running():\n break\n except KeyboardInterrupt:\n print 'KeyboardInterrupt'\n exit_gracefully(None, None)\n exit(0)", "docstring": "Watches all cooking Recipes in a Kitchen\n Provide the kitchen name as an argument or be in a Kitchen folder." }, { "code": "def register_phonon_task(self, *args, **kwargs):\n kwargs[\"task_class\"] = PhononTask\n return self.register_task(*args, **kwargs)", "docstring": "Register a phonon task." }, { "code": "def set_blocking(fd, blocking=True):\n old_flag = fcntl.fcntl(fd, fcntl.F_GETFL)\n if blocking:\n new_flag = old_flag & ~ os.O_NONBLOCK\n else:\n new_flag = old_flag | os.O_NONBLOCK\n fcntl.fcntl(fd, fcntl.F_SETFL, new_flag)\n return not bool(old_flag & os.O_NONBLOCK)", "docstring": "Set the given file-descriptor blocking or non-blocking.\n\n Returns the original blocking status." }, { "code": "def posttrans_hook(conduit):\n if 'SALT_RUNNING' not in os.environ:\n with open(CK_PATH, 'w') as ck_fh:\n ck_fh.write('{chksum} {mtime}\\n'.format(chksum=_get_checksum(), mtime=_get_mtime()))", "docstring": "Hook after the package installation transaction.\n\n :param conduit:\n :return:" }, { "code": "def create_magic_packet(macaddress):\n if len(macaddress) == 12:\n pass\n elif len(macaddress) == 17:\n sep = macaddress[2]\n macaddress = macaddress.replace(sep, '')\n else:\n raise ValueError('Incorrect MAC address format')\n data = b'FFFFFFFFFFFF' + (macaddress * 16).encode()\n send_data = b''\n for i in range(0, len(data), 2):\n send_data += struct.pack(b'B', int(data[i: i + 2], 16))\n return send_data", "docstring": "Create a magic packet.\n\n A magic packet is a packet that can be used with the for wake on lan\n protocol to wake up a computer. The packet is constructed from the\n mac address given as a parameter.\n\n Args:\n macaddress (str): the mac address that should be parsed into a\n magic packet." }, { "code": "def parse_chains(data):\n chains = odict()\n for line in data.splitlines(True):\n m = re_chain.match(line)\n if m:\n policy = None\n if m.group(2) != '-':\n policy = m.group(2)\n chains[m.group(1)] = {\n 'policy': policy,\n 'packets': int(m.group(3)),\n 'bytes': int(m.group(4)),\n }\n return chains", "docstring": "Parse the chain definitions." }, { "code": "def stress(ref_cds, est_cds):\n ref_dists = pdist(ref_cds)\n est_dists = pdist(est_cds)\n return np.sqrt(((ref_dists - est_dists)**2).sum() / (ref_dists**2).sum())", "docstring": "Kruskal's stress" }, { "code": "def response(self, component_id, component=None, **kwargs):\n if component_id in self._responses:\n raise DuplicateComponentNameError(\n 'Another response with name \"{}\" is already registered.'.format(\n component_id\n )\n )\n component = component or {}\n ret = component.copy()\n for plugin in self._plugins:\n try:\n ret.update(plugin.response_helper(component, **kwargs) or {})\n except PluginMethodNotImplementedError:\n continue\n self._responses[component_id] = ret\n return self", "docstring": "Add a response which can be referenced.\n\n :param str component_id: ref_id to use as reference\n :param dict component: response fields\n :param dict kwargs: plugin-specific arguments" }, { "code": "def DomainFactory(domain_name, cmds):\n klass = type(str(domain_name), (BaseDomain,), {})\n for c in cmds:\n command = get_command(domain_name, c['name'])\n setattr(klass, c['name'], classmethod(command))\n return klass", "docstring": "Dynamically create Domain class and set it's methods." }, { "code": "def zpopmax(self, name, count=None):\n args = (count is not None) and [count] or []\n options = {\n 'withscores': True\n }\n return self.execute_command('ZPOPMAX', name, *args, **options)", "docstring": "Remove and return up to ``count`` members with the highest scores\n from the sorted set ``name``." }, { "code": "async def restart(request):\n def wait_and_restart():\n log.info('Restarting server')\n sleep(1)\n os.system('kill 1')\n Thread(target=wait_and_restart).start()\n return web.json_response({\"message\": \"restarting\"})", "docstring": "Returns OK, then waits approximately 1 second and restarts container" }, { "code": "def com_google_fonts_check_glyf_unused_data(ttFont):\n try:\n expected_glyphs = len(ttFont.getGlyphOrder())\n actual_glyphs = len(ttFont['glyf'].glyphs)\n diff = actual_glyphs - expected_glyphs\n if diff < 0:\n yield FAIL, Message(\"unreachable-data\",\n (\"Glyf table has unreachable data at the end of \"\n \" the table. Expected glyf table length {}\"\n \" (from loca table), got length\"\n \" {} (difference: {})\").format(\n expected_glyphs, actual_glyphs, diff))\n elif not diff:\n yield PASS, \"There is no unused data at the end of the glyf table.\"\n else:\n raise Exception(\"Bug: fontTools did not raise an expected exception.\")\n except fontTools.ttLib.TTLibError as error:\n if \"not enough 'glyf' table data\" in format(error):\n yield FAIL, Message(\"missing-data\",\n (\"Loca table references data beyond\"\n \" the end of the glyf table.\"\n \" Expected glyf table length {}\"\n \" (from loca table).\").format(expected_glyphs))\n else:\n raise Exception(\"Bug: Unexpected fontTools exception.\")", "docstring": "Is there any unused data at the end of the glyf table?" }, { "code": "def create_with_dst_resource_provisioning(\n cls, cli, src_resource_id, dst_resource_config,\n max_time_out_of_sync, name=None, remote_system=None,\n src_spa_interface=None, src_spb_interface=None,\n dst_spa_interface=None, dst_spb_interface=None,\n dst_resource_element_configs=None, auto_initiate=None,\n hourly_snap_replication_policy=None,\n daily_snap_replication_policy=None, replicate_existing_snaps=None):\n req_body = cli.make_body(\n srcResourceId=src_resource_id,\n dstResourceConfig=dst_resource_config,\n maxTimeOutOfSync=max_time_out_of_sync,\n name=name, remoteSystem=remote_system,\n srcSPAInterface=src_spa_interface,\n srcSPBInterface=src_spb_interface,\n dstSPAInterface=dst_spa_interface,\n dstSPBInterface=dst_spb_interface,\n dstResourceElementConfigs=dst_resource_element_configs,\n autoInitiate=auto_initiate,\n hourlySnapReplicationPolicy=hourly_snap_replication_policy,\n dailySnapReplicationPolicy=daily_snap_replication_policy,\n replicateExistingSnaps=replicate_existing_snaps)\n resp = cli.type_action(\n cls().resource_class,\n 'createReplicationSessionWDestResProvisioning',\n **req_body)\n resp.raise_if_err()\n session_resp = resp.first_content['id']\n return cls.get(cli, _id=session_resp['id'])", "docstring": "Create a replication session along with destination resource\n provisioning.\n\n :param cli: the rest cli.\n :param src_resource_id: id of the replication source, could be\n lun/fs/cg.\n :param dst_resource_config: `UnityResourceConfig` object. The user\n chosen config for destination resource provisioning. `pool_id` and\n `size` are required for creation.\n :param max_time_out_of_sync: maximum time to wait before syncing the\n source and destination. Value `-1` means the automatic sync is not\n performed. `0` means it is a sync replication.\n :param name: name of the replication.\n :param remote_system: `UnityRemoteSystem` object. The remote system to\n which the replication is being configured. When not specified, it\n defaults to local system.\n :param src_spa_interface: `UnityRemoteInterface` object. The\n replication interface for source SPA.\n :param src_spb_interface: `UnityRemoteInterface` object. The\n replication interface for source SPB.\n :param dst_spa_interface: `UnityRemoteInterface` object. The\n replication interface for destination SPA.\n :param dst_spb_interface: `UnityRemoteInterface` object. The\n replication interface for destination SPB.\n :param dst_resource_element_configs: List of `UnityResourceConfig`\n objects. The user chose config for each of the member element of\n the destination resource.\n :param auto_initiate: indicates whether to perform the first\n replication sync automatically.\n True - perform the first replication sync automatically.\n False - perform the first replication sync manually.\n :param hourly_snap_replication_policy: `UnitySnapReplicationPolicy`\n object. The policy for replicating hourly scheduled snaps of the\n source resource.\n :param daily_snap_replication_policy: `UnitySnapReplicationPolicy`\n object. The policy for replicating daily scheduled snaps of the\n source resource.\n :param replicate_existing_snaps: indicates whether or not to replicate\n snapshots already existing on the resource.\n :return: the newly created replication session." }, { "code": "def render_tree(root, child_func, prune=0, margin=[0], visited=None):\n rname = str(root)\n if visited is None:\n visited = {}\n children = child_func(root)\n retval = \"\"\n for pipe in margin[:-1]:\n if pipe:\n retval = retval + \"| \"\n else:\n retval = retval + \" \"\n if rname in visited:\n return retval + \"+-[\" + rname + \"]\\n\"\n retval = retval + \"+-\" + rname + \"\\n\"\n if not prune:\n visited = copy.copy(visited)\n visited[rname] = 1\n for i in range(len(children)):\n margin.append(i < len(children)-1)\n retval = retval + render_tree(children[i], child_func, prune, margin, visited)\n margin.pop()\n return retval", "docstring": "Render a tree of nodes into an ASCII tree view.\n\n :Parameters:\n - `root`: the root node of the tree\n - `child_func`: the function called to get the children of a node\n - `prune`: don't visit the same node twice\n - `margin`: the format of the left margin to use for children of root. 1 results in a pipe, and 0 results in no pipe.\n - `visited`: a dictionary of visited nodes in the current branch if not prune, or in the whole tree if prune." }, { "code": "def setups(self):\n result = []\n has_options = self.base_object.is_optionhandler\n enm = javabridge.get_enumeration_wrapper(javabridge.call(self.jobject, \"setups\", \"()Ljava/util/Enumeration;\"))\n while enm.hasMoreElements():\n if has_options:\n result.append(OptionHandler(enm.nextElement()))\n else:\n result.append(JavaObject(enm.nextElement()))\n return result", "docstring": "Generates and returns all the setups according to the parameter search space.\n\n :return: the list of configured objects (of type JavaObject)\n :rtype: list" }, { "code": "def solution_violations(solution, events, slots):\n array = converter.solution_to_array(solution, events, slots)\n return array_violations(array, events, slots)", "docstring": "Take a solution and return a list of violated constraints\n\n Parameters\n ----------\n solution: list or tuple\n a schedule in solution form\n events : list or tuple\n of resources.Event instances\n slots : list or tuple\n of resources.Slot instances\n\n Returns\n -------\n Generator\n of a list of strings indicating the nature of the violated\n constraints" }, { "code": "def temp_path(file_name=None):\n if file_name is None:\n file_name = generate_timestamped_string(\"wtf_temp_file\")\n return os.path.join(tempfile.gettempdir(), file_name)", "docstring": "Gets a temp path.\n\n Kwargs:\n file_name (str) : if file name is specified, it gets appended to the temp dir.\n\n Usage::\n\n temp_file_path = temp_path(\"myfile\")\n copyfile(\"myfile\", temp_file_path) # copies 'myfile' to '/tmp/myfile'" }, { "code": "def flush(self):\n for key in self.grouping_info.keys():\n if self._should_flush(key):\n self._write_current_buffer_for_group_key(key)", "docstring": "Ensure all remaining buffers are written." }, { "code": "def screenshot(self):\n b64data = self.http.get('/screenshot').value\n raw_data = base64.b64decode(b64data)\n from PIL import Image\n buff = io.BytesIO(raw_data)\n return Image.open(buff)", "docstring": "Take screenshot with session check\n\n Returns:\n PIL.Image" }, { "code": "def load(path, service=None, hostport=None, module_name=None):\n if not path.endswith('.thrift'):\n service, path = path, service\n module = thriftrw.load(path=path, name=module_name)\n return TChannelThriftModule(service, module, hostport)", "docstring": "Loads the Thrift file at the specified path.\n\n The file is compiled in-memory and a Python module containing the result\n is returned. It may be used with ``TChannel.thrift``. For example,\n\n .. code-block:: python\n\n from tchannel import TChannel, thrift\n\n # Load our server's interface definition.\n donuts = thrift.load(path='donuts.thrift')\n\n # We need to specify a service name or hostport because this is a\n # downstream service we'll be calling.\n coffee = thrift.load(path='coffee.thrift', service='coffee')\n\n tchannel = TChannel('donuts')\n\n @tchannel.thrift.register(donuts.DonutsService)\n @tornado.gen.coroutine\n def submitOrder(request):\n args = request.body\n\n if args.coffee:\n yield tchannel.thrift(\n coffee.CoffeeService.order(args.coffee)\n )\n\n # ...\n\n The returned module contains, one top-level type for each struct, enum,\n union, exeption, and service defined in the Thrift file. For each service,\n the corresponding class contains a classmethod for each function defined\n in that service that accepts the arguments for that function and returns a\n ``ThriftRequest`` capable of being sent via ``TChannel.thrift``.\n\n For more information on what gets generated by ``load``, see `thriftrw\n `_.\n\n Note that the ``path`` accepted by ``load`` must be either an absolute\n path or a path relative to the *the current directory*. If you need to\n refer to Thrift files relative to the Python module in which ``load`` was\n called, use the ``__file__`` magic variable.\n\n .. code-block:: python\n\n # Given,\n #\n # foo/\n # myservice.thrift\n # bar/\n # x.py\n #\n # Inside foo/bar/x.py,\n\n path = os.path.join(\n os.path.dirname(__file__), '../myservice.thrift'\n )\n\n The returned value is a valid Python module. You can install the module by\n adding it to the ``sys.modules`` dictionary. This will allow importing\n items from this module directly. You can use the ``__name__`` magic\n variable to make the generated module a submodule of the current module.\n For example,\n\n .. code-block:: python\n\n # foo/bar.py\n\n import sys\n from tchannel import thrift\n\n donuts = = thrift.load('donuts.thrift')\n sys.modules[__name__ + '.donuts'] = donuts\n\n This installs the module generated for ``donuts.thrift`` as the module\n ``foo.bar.donuts``. Callers can then import items from that module\n directly. For example,\n\n .. code-block:: python\n\n # foo/baz.py\n\n from foo.bar.donuts import DonutsService, Order\n\n def baz(tchannel):\n return tchannel.thrift(\n DonutsService.submitOrder(Order(..))\n )\n\n :param str service:\n Name of the service that the Thrift file represents. This name will be\n used to route requests through Hyperbahn.\n :param str path:\n Path to the Thrift file. If this is a relative path, it must be\n relative to the current directory.\n :param str hostport:\n Clients can use this to specify the hostport at which the service can\n be found. If omitted, TChannel will route the requests through known\n peers. This value is ignored by servers.\n :param str module_name:\n Name used for the generated Python module. Defaults to the name of the\n Thrift file." }, { "code": "def fix_facets(self):\n facets = self.facets\n for key in list(facets.keys()):\n _type = facets[key].get(\"_type\", \"unknown\")\n if _type == \"date_histogram\":\n for entry in facets[key].get(\"entries\", []):\n for k, v in list(entry.items()):\n if k in [\"count\", \"max\", \"min\", \"total_count\", \"mean\", \"total\"]:\n continue\n if not isinstance(entry[k], datetime):\n entry[k] = datetime.utcfromtimestamp(v / 1e3)", "docstring": "This function convert date_histogram facets to datetime" }, { "code": "def convert_units_to_base_units(units):\n total_factor = 1\n new_units = []\n for unit in units:\n if unit not in BASE_UNIT_CONVERSIONS:\n continue\n factor, new_unit = BASE_UNIT_CONVERSIONS[unit]\n total_factor *= factor\n new_units.append(new_unit)\n new_units.sort()\n return total_factor, tuple(new_units)", "docstring": "Convert a set of units into a set of \"base\" units.\n\n Returns a 2-tuple of `factor, new_units`." }, { "code": "def save_to(self, obj):\n if isinstance(obj, dict):\n obj = dict(obj)\n for key in self.changed_fields:\n if key in self.cleaned_data:\n val = self.cleaned_data.get(key)\n set_obj_value(obj, key, val)\n return obj", "docstring": "Save the cleaned data to an object." }, { "code": "def execute_script(self, name, keys, *args, **options):\n script = get_script(name)\n if not script:\n raise redis.RedisError('No such script \"%s\"' % name)\n address = self.address()\n if address not in all_loaded_scripts:\n all_loaded_scripts[address] = set()\n loaded = all_loaded_scripts[address]\n toload = script.required_scripts.difference(loaded)\n for name in toload:\n s = get_script(name)\n yield self.script_load(s.script)\n loaded.update(toload)\n yield script(self, keys, args, options)", "docstring": "Execute a script.\n\n makes sure all required scripts are loaded." }, { "code": "def register_channel_post_handler(self, callback, *custom_filters, commands=None, regexp=None, content_types=None,\n state=None, run_task=None, **kwargs):\n filters_set = self.filters_factory.resolve(self.channel_post_handlers,\n *custom_filters,\n commands=commands,\n regexp=regexp,\n content_types=content_types,\n state=state,\n **kwargs)\n self.channel_post_handlers.register(self._wrap_async_task(callback, run_task), filters_set)", "docstring": "Register handler for channel post\n\n :param callback:\n :param commands: list of commands\n :param regexp: REGEXP\n :param content_types: List of content types.\n :param state:\n :param custom_filters: list of custom filters\n :param run_task: run callback in task (no wait results)\n :param kwargs:\n :return: decorated function" }, { "code": "def disable_switchport(self, inter_type, inter):\n config = ET.Element('config')\n interface = ET.SubElement(config, 'interface',\n xmlns=(\"urn:brocade.com:mgmt:\"\n \"brocade-interface\"))\n int_type = ET.SubElement(interface, inter_type)\n name = ET.SubElement(int_type, 'name')\n name.text = inter\n ET.SubElement(int_type, 'switchport-basic', operation='delete')\n try:\n self._callback(config)\n return True\n except Exception as error:\n logging.error(error)\n return False", "docstring": "Change an interface's operation to L3.\n\n Args:\n inter_type: The type of interface you want to configure. Ex.\n tengigabitethernet, gigabitethernet, fortygigabitethernet.\n inter: The ID for the interface you want to configure. Ex. 1/0/1\n\n Returns:\n True if command completes successfully or False if not.\n\n Raises:\n None" }, { "code": "def write_intro (self):\n self.comment(_(\"created by %(app)s at %(time)s\") %\n {\"app\": configuration.AppName,\n \"time\": strformat.strtime(self.starttime)})\n self.comment(_(\"Get the newest version at %(url)s\") %\n {'url': configuration.Url})\n self.comment(_(\"Write comments and bugs to %(url)s\") %\n {'url': configuration.SupportUrl})\n self.comment(_(\"Support this project at %(url)s\") %\n {'url': configuration.DonateUrl})\n self.check_date()", "docstring": "Write intro comments." }, { "code": "def get_field_info(self, field):\n field_info = self.get_attributes(field)\n field_info[\"required\"] = getattr(field, \"required\", False)\n field_info[\"type\"] = self.get_label_lookup(field)\n if getattr(field, \"child\", None):\n field_info[\"child\"] = self.get_field_info(field.child)\n elif getattr(field, \"fields\", None):\n field_info[\"children\"] = self.get_serializer_info(field)\n if (not isinstance(field, (serializers.RelatedField, serializers.ManyRelatedField)) and\n hasattr(field, \"choices\")):\n field_info[\"choices\"] = [\n {\n \"value\": choice_value,\n \"display_name\": force_text(choice_name, strings_only=True)\n }\n for choice_value, choice_name in field.choices.items()\n ]\n return field_info", "docstring": "This method is basically a mirror from rest_framework==3.3.3\n\n We are currently pinned to rest_framework==3.1.1. If we upgrade,\n this can be refactored and simplified to rely more heavily on\n rest_framework's built in logic." }, { "code": "def detect_traits(item):\n return traits.detect_traits(\n name=item.name, alias=item.alias,\n filetype=(list(item.fetch(\"kind_51\")) or [None]).pop(),\n )", "docstring": "Build traits list from attributes of the passed item. Currently,\n \"kind_51\", \"name\" and \"alias\" are considered.\n\n See pyrocore.util.traits:dectect_traits for more details." }, { "code": "def partition(pred, iterable):\n trues = []\n falses = []\n for item in iterable:\n if pred(item):\n trues.append(item)\n else:\n falses.append(item)\n return trues, falses", "docstring": "split the results of an iterable based on a predicate" }, { "code": "def _lint():\n project_python_files = [filename for filename in get_project_files()\n if filename.endswith(b'.py')]\n retcode = subprocess.call(\n ['flake8', '--max-complexity=10'] + project_python_files)\n if retcode == 0:\n print_success_message('No style errors')\n return retcode", "docstring": "Run lint and return an exit code." }, { "code": "def map_sections(fun, neurites, neurite_type=NeuriteType.all, iterator_type=Tree.ipreorder):\n return map(fun, iter_sections(neurites,\n iterator_type=iterator_type,\n neurite_filter=is_type(neurite_type)))", "docstring": "Map `fun` to all the sections in a collection of neurites" }, { "code": "def bestfit_func(self, bestfit_x):\n if not self.bestfit_func:\n raise KeyError(\"Do do_bestfit first\")\n return self.args[\"func\"](self.fit_args, bestfit_x)", "docstring": "Returns y value" }, { "code": "def ekifld(handle, tabnam, ncols, nrows, cnmlen, cnames, declen, decls):\n handle = ctypes.c_int(handle)\n tabnam = stypes.stringToCharP(tabnam)\n ncols = ctypes.c_int(ncols)\n nrows = ctypes.c_int(nrows)\n cnmlen = ctypes.c_int(cnmlen)\n cnames = stypes.listToCharArray(cnames)\n declen = ctypes.c_int(declen)\n recptrs = stypes.emptyIntVector(nrows)\n decls = stypes.listToCharArray(decls)\n segno = ctypes.c_int()\n libspice.ekifld_c(handle, tabnam, ncols, nrows, cnmlen, cnames, declen,\n decls, ctypes.byref(segno), recptrs)\n return segno.value, stypes.cVectorToPython(recptrs)", "docstring": "Initialize a new E-kernel segment to allow fast writing.\n\n http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/ekifld_c.html\n\n :param handle: File handle.\n :type handle: int\n :param tabnam: Table name.\n :type tabnam: str\n :param ncols: Number of columns in the segment.\n :type ncols: int\n :param nrows: Number of rows in the segment.\n :type nrows: int\n :param cnmlen: Length of names in in column name array.\n :type cnmlen: int\n :param cnames: Names of columns.\n :type cnames: list of str.\n :param declen: Length of declaration strings in declaration array.\n :type declen: int\n :param decls: Declarations of columns.\n :type decls: list of str.\n :return: Segment number, Array of record pointers.\n :rtype: tuple" }, { "code": "def get_grid_data(xall, yall, zall, nbins=100, method='nearest'):\n from scipy.interpolate import griddata\n x, y = _np.meshgrid(\n _np.linspace(xall.min(), xall.max(), nbins),\n _np.linspace(yall.min(), yall.max(), nbins),\n indexing='ij')\n z = griddata(\n _np.hstack([xall[:,None], yall[:,None]]),\n zall, (x, y), method=method)\n return x, y, z", "docstring": "Interpolate unstructured two-dimensional data.\n\n Parameters\n ----------\n xall : ndarray(T)\n Sample x-coordinates.\n yall : ndarray(T)\n Sample y-coordinates.\n zall : ndarray(T)\n Sample z-coordinates.\n nbins : int, optional, default=100\n Number of histogram bins used in x/y-dimensions.\n method : str, optional, default='nearest'\n Assignment method; scipy.interpolate.griddata supports the\n methods 'nearest', 'linear', and 'cubic'.\n\n Returns\n -------\n x : ndarray(nbins, nbins)\n The bins' x-coordinates in meshgrid format.\n y : ndarray(nbins, nbins)\n The bins' y-coordinates in meshgrid format.\n z : ndarray(nbins, nbins)\n Interpolated z-data in meshgrid format." }, { "code": "def _onEncoding(self, encString, line, pos, absPosition):\n self.encoding = Encoding(encString, line, pos, absPosition)", "docstring": "Memorizes module encoding" }, { "code": "def wait_for_keys(self, *keys, timeout=0):\n if len(keys) == 1 and _is_iterable(keys[0]):\n keys = keys[0]\n return self.listen_until_return(Handler.key_press(keys), timeout=timeout)", "docstring": "Waits until one of the specified keys was pressed, and returns \n which key was pressed.\n\n :param keys: iterable of integers of pygame-keycodes, or simply \n multiple keys passed via multiple arguments\n :type keys: iterable\n :param timeout: number of seconds to wait till the function returns\n :type timeout: float\n\n :returns: The keycode of the pressed key, or None in case of timeout\n :rtype: int" }, { "code": "def tearpage_backend(filename, teared_pages=None):\n if teared_pages is None:\n teared_pages = [0]\n with tempfile.NamedTemporaryFile() as tmp:\n shutil.copy(filename, tmp.name)\n try:\n input_file = PdfFileReader(open(tmp.name, 'rb'))\n except PdfReadError:\n fix_pdf(filename, tmp.name)\n input_file = PdfFileReader(open(tmp.name, 'rb'))\n num_pages = input_file.getNumPages()\n output_file = PdfFileWriter()\n for i in range(num_pages):\n if i in teared_pages:\n continue\n output_file.addPage(input_file.getPage(i))\n tmp.close()\n outputStream = open(filename, \"wb\")\n output_file.write(outputStream)", "docstring": "Copy filename to a tempfile, write pages to filename except the teared one.\n\n ..note ::\n\n Adapted from sciunto's code, https://github.com/sciunto/tear-pages\n\n :param filename: PDF filepath\n :param teared_pages: Numbers of the pages to tear. Default to first page \\\n only." }, { "code": "def is_canonical(version, loosedev=False):\n if loosedev:\n return loose440re.match(version) is not None\n return pep440re.match(version) is not None", "docstring": "Return whether or not the version string is canonical according to Pep 440" }, { "code": "def __create_preview_object_base(self, dct):\n if dct.get(\"_id\"):\n del dct[\"_id\"]\n preview_object_id = yield self.previews.insert(dct)\n raise Return(preview_object_id)", "docstring": "The starting point for a preview of a future object.\n This is the object which will have future revisions iterated and applied to.\n\n :param dict dct: The starting object dictionary\n :return: The preview object id\n :rtype: str" }, { "code": "def create_spooled_temporary_file(filepath=None, fileobj=None):\n spooled_file = tempfile.SpooledTemporaryFile(\n max_size=settings.TMP_FILE_MAX_SIZE,\n dir=settings.TMP_DIR)\n if filepath:\n fileobj = open(filepath, 'r+b')\n if fileobj is not None:\n fileobj.seek(0)\n copyfileobj(fileobj, spooled_file, settings.TMP_FILE_READ_SIZE)\n return spooled_file", "docstring": "Create a spooled temporary file. if ``filepath`` or ``fileobj`` is\n defined its content will be copied into temporary file.\n\n :param filepath: Path of input file\n :type filepath: str\n\n :param fileobj: Input file object\n :type fileobj: file\n\n :returns: Spooled temporary file\n :rtype: :class:`tempfile.SpooledTemporaryFile`" }, { "code": "def padDigitalData(self, dig_data, n):\n n = int(n)\n l0 = len(dig_data)\n if l0 % n == 0:\n return dig_data\n else:\n ladd = n - (l0 % n)\n dig_data_add = np.zeros(ladd, dtype=\"uint32\")\n dig_data_add.fill(dig_data[-1])\n return np.concatenate((dig_data, dig_data_add))", "docstring": "Pad dig_data with its last element so that the new array is a\n multiple of n." }, { "code": "def upvotes(self, option):\n params = join_params(self.parameters, {\"upvotes\": option})\n return self.__class__(**params)", "docstring": "Set whether to filter by a user's upvoted list. Options available are\n user.ONLY, user.NOT, and None; default is None." }, { "code": "def where(self, column_or_label, value_or_predicate=None, other=None):\n column = self._get_column(column_or_label)\n if other is not None:\n assert callable(value_or_predicate), \"Predicate required for 3-arg where\"\n predicate = value_or_predicate\n other = self._get_column(other)\n column = [predicate(y)(x) for x, y in zip(column, other)]\n elif value_or_predicate is not None:\n if not callable(value_or_predicate):\n predicate = _predicates.are.equal_to(value_or_predicate)\n else:\n predicate = value_or_predicate\n column = [predicate(x) for x in column]\n return self.take(np.nonzero(column)[0])", "docstring": "Return a new ``Table`` containing rows where ``value_or_predicate``\n returns True for values in ``column_or_label``.\n\n Args:\n ``column_or_label``: A column of the ``Table`` either as a label\n (``str``) or an index (``int``). Can also be an array of booleans;\n only the rows where the array value is ``True`` are kept.\n\n ``value_or_predicate``: If a function, it is applied to every value\n in ``column_or_label``. Only the rows where ``value_or_predicate``\n returns True are kept. If a single value, only the rows where the\n values in ``column_or_label`` are equal to ``value_or_predicate``\n are kept.\n\n ``other``: Optional additional column label for\n ``value_or_predicate`` to make pairwise comparisons. See the\n examples below for usage. When ``other`` is supplied,\n ``value_or_predicate`` must be a callable function.\n\n Returns:\n If ``value_or_predicate`` is a function, returns a new ``Table``\n containing only the rows where ``value_or_predicate(val)`` is True\n for the ``val``s in ``column_or_label``.\n\n If ``value_or_predicate`` is a value, returns a new ``Table``\n containing only the rows where the values in ``column_or_label``\n are equal to ``value_or_predicate``.\n\n If ``column_or_label`` is an array of booleans, returns a new\n ``Table`` containing only the rows where ``column_or_label`` is\n ``True``.\n\n >>> marbles = Table().with_columns(\n ... \"Color\", make_array(\"Red\", \"Green\", \"Blue\",\n ... \"Red\", \"Green\", \"Green\"),\n ... \"Shape\", make_array(\"Round\", \"Rectangular\", \"Rectangular\",\n ... \"Round\", \"Rectangular\", \"Round\"),\n ... \"Amount\", make_array(4, 6, 12, 7, 9, 2),\n ... \"Price\", make_array(1.30, 1.20, 2.00, 1.75, 0, 3.00))\n\n >>> marbles\n Color | Shape | Amount | Price\n Red | Round | 4 | 1.3\n Green | Rectangular | 6 | 1.2\n Blue | Rectangular | 12 | 2\n Red | Round | 7 | 1.75\n Green | Rectangular | 9 | 0\n Green | Round | 2 | 3\n\n Use a value to select matching rows\n\n >>> marbles.where(\"Price\", 1.3)\n Color | Shape | Amount | Price\n Red | Round | 4 | 1.3\n\n In general, a higher order predicate function such as the functions in\n ``datascience.predicates.are`` can be used.\n\n >>> from datascience.predicates import are\n >>> # equivalent to previous example\n >>> marbles.where(\"Price\", are.equal_to(1.3))\n Color | Shape | Amount | Price\n Red | Round | 4 | 1.3\n\n >>> marbles.where(\"Price\", are.above(1.5))\n Color | Shape | Amount | Price\n Blue | Rectangular | 12 | 2\n Red | Round | 7 | 1.75\n Green | Round | 2 | 3\n\n Use the optional argument ``other`` to apply predicates to compare\n columns.\n\n >>> marbles.where(\"Price\", are.above, \"Amount\")\n Color | Shape | Amount | Price\n Green | Round | 2 | 3\n\n >>> marbles.where(\"Price\", are.equal_to, \"Amount\") # empty table\n Color | Shape | Amount | Price" }, { "code": "def every(predicate, *iterables):\n r\n try:\n if len(iterables) == 1: ifilterfalse(predicate, iterables[0]).next()\n else: ifilterfalse(bool, starmap(predicate, izip(*iterables))).next()\n except StopIteration: return True\n else: return False", "docstring": "r\"\"\"Like `some`, but only returns `True` if all the elements of `iterables`\n satisfy `predicate`.\n\n Examples:\n >>> every(bool, [])\n True\n >>> every(bool, [0])\n False\n >>> every(bool, [1,1])\n True\n >>> every(operator.eq, [1,2,3],[1,2])\n True\n >>> every(operator.eq, [1,2,3],[0,2])\n False" }, { "code": "def for_category(self, category, live_only=False):\n filters = {'tag': category.tag}\n if live_only:\n filters.update({'entry__live': True})\n return self.filter(**filters)", "docstring": "Returns queryset of EntryTag instances for specified category.\n\n :param category: the Category instance.\n :param live_only: flag to include only \"live\" entries.\n :rtype: django.db.models.query.QuerySet." }, { "code": "def _imagpart(self, f):\n def f_im(x, **kwargs):\n result = np.asarray(f(x, **kwargs),\n dtype=self.scalar_out_dtype)\n return result.imag\n if is_real_dtype(self.out_dtype):\n return self.zero()\n else:\n return self.real_space.element(f_im)", "docstring": "Function returning the imaginary part of the result from ``f``." }, { "code": "def get_top_artists(self, limit=None, cacheable=True):\n params = {}\n if limit:\n params[\"limit\"] = limit\n doc = _Request(self, \"chart.getTopArtists\", params).execute(cacheable)\n return _extract_top_artists(doc, self)", "docstring": "Returns the most played artists as a sequence of TopItem objects." }, { "code": "def make_directory_if_not_exists(path):\n try:\n os.makedirs(path)\n except OSError, error:\n if error.errno <> errno.EEXIST:\n raise error", "docstring": "Create the specified path, making all intermediate-level directories\n needed to contain the leaf directory. Ignore any error that would\n occur if the leaf directory already exists.\n\n @note: all the intermediate-level directories are created with the\n default mode is 0777 (octal).\n\n @param path: the path to create.\n\n @raise OSError: an error that would occur if the path cannot be\n created." }, { "code": "def bulk_record_workunits(self, engine_workunits):\n for workunit in engine_workunits:\n duration = workunit['end_timestamp'] - workunit['start_timestamp']\n span = zipkin_span(\n service_name=\"pants\",\n span_name=workunit['name'],\n duration=duration,\n span_storage=self.span_storage,\n )\n span.zipkin_attrs = ZipkinAttrs(\n trace_id=self.trace_id,\n span_id=workunit['span_id'],\n parent_span_id=workunit.get(\"parent_id\", self.parent_id),\n flags='0',\n is_sampled=True,\n )\n span.start()\n span.start_timestamp = workunit['start_timestamp']\n span.stop()", "docstring": "A collection of workunits from v2 engine part" }, { "code": "def build_single(mode):\n if mode == 'force':\n amode = ['-a']\n else:\n amode = []\n if executable.endswith('uwsgi'):\n _executable = executable[:-5] + 'python'\n else:\n _executable = executable\n p = subprocess.Popen([_executable, '-m', 'nikola', 'build'] + amode,\n stderr=subprocess.PIPE)\n p.wait()\n rl = p.stderr.readlines()\n try:\n out = ''.join(rl)\n except TypeError:\n out = ''.join(l.decode('utf-8') for l in rl)\n return (p.returncode == 0), out", "docstring": "Build, in the single-user mode." }, { "code": "def get_assessments_offered_by_search(self, assessment_offered_query, assessment_offered_search):\n if not self._can('search'):\n raise PermissionDenied()\n return self._provider_session.get_assessments_offered_by_search(assessment_offered_query, assessment_offered_search)", "docstring": "Pass through to provider AssessmentOfferedSearchSession.get_assessments_offered_by_search" }, { "code": "def ToJSonResponse(self, columns_order=None, order_by=(), req_id=0,\n response_handler=\"google.visualization.Query.setResponse\"):\n response_obj = {\n \"version\": \"0.6\",\n \"reqId\": str(req_id),\n \"table\": self._ToJSonObj(columns_order, order_by),\n \"status\": \"ok\"\n }\n encoded_response_str = DataTableJSONEncoder().encode(response_obj)\n if not isinstance(encoded_response_str, str):\n encoded_response_str = encoded_response_str.encode(\"utf-8\")\n return \"%s(%s);\" % (response_handler, encoded_response_str)", "docstring": "Writes a table as a JSON response that can be returned as-is to a client.\n\n This method writes a JSON response to return to a client in response to a\n Google Visualization API query. This string can be processed by the calling\n page, and is used to deliver a data table to a visualization hosted on\n a different page.\n\n Args:\n columns_order: Optional. Passed straight to self.ToJSon().\n order_by: Optional. Passed straight to self.ToJSon().\n req_id: Optional. The response id, as retrieved by the request.\n response_handler: Optional. The response handler, as retrieved by the\n request.\n\n Returns:\n A JSON response string to be received by JS the visualization Query\n object. This response would be translated into a DataTable on the\n client side.\n Example result (newlines added for readability):\n google.visualization.Query.setResponse({\n 'version':'0.6', 'reqId':'0', 'status':'OK',\n 'table': {cols: [...], rows: [...]}});\n\n Note: The URL returning this string can be used as a data source by Google\n Visualization Gadgets or from JS code." }, { "code": "def to_one_hot(dataY):\n nc = 1 + np.max(dataY)\n onehot = [np.zeros(nc, dtype=np.int8) for _ in dataY]\n for i, j in enumerate(dataY):\n onehot[i][j] = 1\n return onehot", "docstring": "Convert the vector of labels dataY into one-hot encoding.\n\n :param dataY: vector of labels\n :return: one-hot encoded labels" }, { "code": "def execfile(fname, variables):\n with open(fname) as f:\n code = compile(f.read(), fname, 'exec')\n exec(code, variables)", "docstring": "This is builtin in python2, but we have to roll our own on py3." }, { "code": "def SetEventTag(self, event_tag):\n event_identifier = event_tag.GetEventIdentifier()\n lookup_key = event_identifier.CopyToString()\n self._index[lookup_key] = event_tag.GetIdentifier()", "docstring": "Sets an event tag in the index.\n\n Args:\n event_tag (EventTag): event tag." }, { "code": "def inherited_labels(cls):\n return [scls.__label__ for scls in cls.mro()\n if hasattr(scls, '__label__') and not hasattr(\n scls, '__abstract_node__')]", "docstring": "Return list of labels from nodes class hierarchy.\n\n :return: list" }, { "code": "def translate(self):\n value = super().translate()\n if value is None or (isinstance(value, str) and value.strip() == ''):\n return None\n return int(value)", "docstring": "Gets the value in the current language, or\n in the configured fallbck language." }, { "code": "def get_absl_log_prefix(record):\n created_tuple = time.localtime(record.created)\n created_microsecond = int(record.created % 1.0 * 1e6)\n critical_prefix = ''\n level = record.levelno\n if _is_non_absl_fatal_record(record):\n level = logging.ERROR\n critical_prefix = _CRITICAL_PREFIX\n severity = converter.get_initial_for_level(level)\n return '%c%02d%02d %02d:%02d:%02d.%06d %5d %s:%d] %s' % (\n severity,\n created_tuple.tm_mon,\n created_tuple.tm_mday,\n created_tuple.tm_hour,\n created_tuple.tm_min,\n created_tuple.tm_sec,\n created_microsecond,\n _get_thread_id(),\n record.filename,\n record.lineno,\n critical_prefix)", "docstring": "Returns the absl log prefix for the log record.\n\n Args:\n record: logging.LogRecord, the record to get prefix for." }, { "code": "def userinfo_json(request, user_id):\n data = {'first_name': '',\n 'last_name': '',\n 'email': '',\n 'slug': '',\n 'bio': '',\n 'phone': '',\n 'is_active': False}\n try:\n member = StaffMember.objects.get(pk=user_id)\n for key in data.keys():\n if hasattr(member, key):\n data[key] = getattr(member, key, '')\n except StaffMember.DoesNotExist:\n pass\n return HttpResponse(json.dumps(data),\n mimetype='application/json')", "docstring": "Return the user's information in a json object" }, { "code": "def option(self, *args, **kwargs):\n args, kwargs = _config_parameter(args, kwargs)\n return self._click.option(*args, **kwargs)", "docstring": "Registers a click.option which falls back to a configmanager Item\n if user hasn't provided a value in the command line.\n\n Item must be the last of ``args``.\n\n Examples::\n\n config = Config({'greeting': 'Hello'})\n\n @click.command()\n @config.click.option('--greeting', config.greeting)\n def say_hello(greeting):\n click.echo(greeting)" }, { "code": "def white_noise(dur=None, low=-1., high=1.):\n if dur is None or (isinf(dur) and dur > 0):\n while True:\n yield random.uniform(low, high)\n for x in xrange(rint(dur)):\n yield random.uniform(low, high)", "docstring": "White noise stream generator.\n\n Parameters\n ----------\n dur :\n Duration, in number of samples; endless if not given (or None).\n low, high :\n Lower and higher limits. Defaults to the [-1; 1] range.\n\n Returns\n -------\n Stream yielding random numbers between -1 and 1." }, { "code": "def rmse(targets, predictions):\n r\n _supervised_evaluation_error_checking(targets, predictions)\n return _turicreate.extensions._supervised_streaming_evaluator(targets,\n predictions, \"rmse\", {})", "docstring": "r\"\"\"\n Compute the root mean squared error between two SArrays.\n\n Parameters\n ----------\n targets : SArray[float or int]\n An Sarray of ground truth target values.\n\n predictions : SArray[float or int]\n The prediction that corresponds to each target value.\n This vector must have the same length as ``targets``.\n\n Returns\n -------\n out : float\n The RMSE between the two SArrays.\n\n See Also\n --------\n max_error\n\n Notes\n -----\n The root mean squared error between two vectors, x and y, is defined as:\n\n .. math::\n\n RMSE = \\sqrt{\\frac{1}{N} \\sum_{i=1}^N (x_i - y_i)^2}\n\n References\n ----------\n - `Wikipedia - root-mean-square deviation\n `_\n\n Examples\n --------\n >>> targets = turicreate.SArray([3.14, 0.1, 50, -2.5])\n >>> predictions = turicreate.SArray([3.1, 0.5, 50.3, -5])\n\n >>> turicreate.evaluation.rmse(targets, predictions)\n 1.2749117616525465" }, { "code": "def verify_edge_segments(edge_infos):\n if edge_infos is None:\n return\n for edge_info in edge_infos:\n num_segments = len(edge_info)\n for index in six.moves.xrange(-1, num_segments - 1):\n index1, start1, end1 = edge_info[index]\n if not 0.0 <= start1 < end1 <= 1.0:\n raise ValueError(BAD_SEGMENT_PARAMS, edge_info[index])\n index2, _, _ = edge_info[index + 1]\n if index1 == index2:\n raise ValueError(\n SEGMENTS_SAME_EDGE, edge_info[index], edge_info[index + 1]\n )", "docstring": "Verify that the edge segments in an intersection are valid.\n\n .. note::\n\n This is a helper used only by :func:`generic_intersect`.\n\n Args:\n edge_infos (Optional[list]): List of \"edge info\" lists. Each list\n represents a curved polygon and contains 3-tuples of edge index,\n start and end (see the output of :func:`ends_to_curve`).\n\n Raises:\n ValueError: If two consecutive edge segments lie on the same edge\n index.\n ValueError: If the start and end parameter are \"invalid\" (they should\n be between 0 and 1 and start should be strictly less than end)." }, { "code": "def run(self, func=None):\n args = self.parser.parse_args()\n if self.__add_vq is not None and self.__config_logging:\n self.__config_logging(args)\n if self.__show_version_func and args.version and callable(self.__show_version_func):\n self.__show_version_func(self, args)\n elif args.func is not None:\n args.func(self, args)\n elif func is not None:\n func(self, args)\n else:\n self.parser.print_help()", "docstring": "Run the app" }, { "code": "def dataReceived(self, data):\n self.bytes_in += (len(data))\n self.buffer_in = self.buffer_in + data\n while self.CheckDataReceived():\n pass", "docstring": "Called from Twisted whenever data is received." }, { "code": "def has_mixture_channel(val: Any) -> bool:\n mixture_getter = getattr(val, '_has_mixture_', None)\n result = NotImplemented if mixture_getter is None else mixture_getter()\n if result is not NotImplemented:\n return result\n result = has_unitary(val)\n if result is not NotImplemented and result:\n return result\n return mixture_channel(val, None) is not None", "docstring": "Returns whether the value has a mixture channel representation.\n\n In contrast to `has_mixture` this method falls back to checking whether\n the value has a unitary representation via `has_channel`.\n\n Returns:\n If `val` has a `_has_mixture_` method and its result is not\n NotImplemented, that result is returned. Otherwise, if `val` has a\n `_has_unitary_` method and its results is not NotImplemented, that\n result is returned. Otherwise, if the value has a `_mixture_` method\n that is not a non-default value, True is returned. Returns False if none\n of these functions." }, { "code": "def get_compound_pd(self):\n entry1 = PDEntry(self.entry1.composition, 0)\n entry2 = PDEntry(self.entry2.composition, 0)\n cpd = CompoundPhaseDiagram(\n self.rxn_entries + [entry1, entry2],\n [Composition(entry1.composition.reduced_formula),\n Composition(entry2.composition.reduced_formula)],\n normalize_terminal_compositions=False) \n return cpd", "docstring": "Get the CompoundPhaseDiagram object, which can then be used for\n plotting.\n\n Returns:\n (CompoundPhaseDiagram)" }, { "code": "def subpnt(method, target, et, fixref, abcorr, obsrvr):\n method = stypes.stringToCharP(method)\n target = stypes.stringToCharP(target)\n et = ctypes.c_double(et)\n fixref = stypes.stringToCharP(fixref)\n abcorr = stypes.stringToCharP(abcorr)\n obsrvr = stypes.stringToCharP(obsrvr)\n spoint = stypes.emptyDoubleVector(3)\n trgepc = ctypes.c_double(0)\n srfvec = stypes.emptyDoubleVector(3)\n libspice.subpnt_c(method, target, et, fixref, abcorr, obsrvr, spoint,\n ctypes.byref(trgepc), srfvec)\n return stypes.cVectorToPython(spoint), trgepc.value, stypes.cVectorToPython(\n srfvec)", "docstring": "Compute the rectangular coordinates of the sub-observer point on\n a target body at a specified epoch, optionally corrected for\n light time and stellar aberration.\n\n This routine supersedes :func:`subpt`.\n\n http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/subpnt_c.html\n\n :param method: Computation method.\n :type method: str\n :param target: Name of target body.\n :type target: str\n :param et: Epoch in ephemeris seconds past J2000 TDB.\n :type et: float\n :param fixref: Body-fixed, body-centered target body frame.\n :type fixref: str\n :param abcorr: Aberration correction.\n :type abcorr: str\n :param obsrvr: Name of observing body.\n :type obsrvr: str\n :return:\n Sub-observer point on the target body,\n Sub-observer point epoch,\n Vector from observer to sub-observer point.\n :rtype: tuple" }, { "code": "def OnPrintPreview(self, event):\n print_area = self._get_print_area()\n print_data = self.main_window.print_data\n self.main_window.actions.print_preview(print_area, print_data)", "docstring": "Print preview handler" }, { "code": "def probe_async(self, callback):\n topics = MQTTTopicValidator(self.prefix)\n self.client.publish(topics.probe, {'type': 'command', 'operation': 'probe', 'client': self.name})\n callback(self.id, True, None)", "docstring": "Probe for visible devices connected to this DeviceAdapter.\n\n Args:\n callback (callable): A callback for when the probe operation has completed.\n callback should have signature callback(adapter_id, success, failure_reason) where:\n success: bool\n failure_reason: None if success is True, otherwise a reason for why we could not probe" }, { "code": "def proxy(host='localhost', port=4304, flags=0, persistent=False,\n verbose=False, ):\n try:\n gai = socket.getaddrinfo(host, port, 0, socket.SOCK_STREAM,\n socket.IPPROTO_TCP)\n except socket.gaierror as err:\n raise ConnError(*err.args)\n assert gai\n for (family, _type, _proto, _, sockaddr) in gai:\n assert _type is socket.SOCK_STREAM and _proto is socket.IPPROTO_TCP\n owp = _Proxy(family, sockaddr, flags, verbose)\n try:\n owp.ping()\n except ConnError as err:\n lasterr = err.args\n continue\n else:\n break\n else:\n raise ConnError(*lasterr)\n owp._init_errcodes()\n if persistent:\n owp = clone(owp, persistent=True)\n assert not isinstance(owp, _PersistentProxy) or owp.conn is None\n return owp", "docstring": "factory function that returns a proxy object for an owserver at\n host, port." }, { "code": "def parse(cls, uri):\n\t\turi_components = urlsplit(uri)\n\t\tadapter_fn = lambda x: x if x is not None and (isinstance(x, str) is False or len(x)) > 0 else None\n\t\treturn cls(\n\t\t\tscheme=adapter_fn(uri_components.scheme),\n\t\t\tusername=adapter_fn(uri_components.username),\n\t\t\tpassword=adapter_fn(uri_components.password),\n\t\t\thostname=adapter_fn(uri_components.hostname),\n\t\t\tport=adapter_fn(uri_components.port),\n\t\t\tpath=adapter_fn(uri_components.path),\n\t\t\tquery=adapter_fn(uri_components.query),\n\t\t\tfragment=adapter_fn(uri_components.fragment),\n\t\t)", "docstring": "Parse URI-string and return WURI object\n\n\t\t:param uri: string to parse\n\t\t:return: WURI" }, { "code": "def _allow_custom_expire(self, load):\n expire_override = self.opts.get('token_expire_user_override', False)\n if expire_override is True:\n return True\n if isinstance(expire_override, collections.Mapping):\n expire_whitelist = expire_override.get(load['eauth'], [])\n if isinstance(expire_whitelist, collections.Iterable):\n if load.get('username') in expire_whitelist:\n return True\n return False", "docstring": "Return bool if requesting user is allowed to set custom expire" }, { "code": "def plural(self, text, count=None):\n pre, word, post = self.partition_word(text)\n if not word:\n return text\n plural = self.postprocess(\n word,\n self._pl_special_adjective(word, count)\n or self._pl_special_verb(word, count)\n or self._plnoun(word, count),\n )\n return \"{}{}{}\".format(pre, plural, post)", "docstring": "Return the plural of text.\n\n If count supplied, then return text if count is one of:\n 1, a, an, one, each, every, this, that\n otherwise return the plural.\n\n Whitespace at the start and end is preserved." }, { "code": "def get(self, *args, **kwargs):\n if not mqueue.qsize():\n return None\n message_data, content_type, content_encoding = mqueue.get()\n return self.Message(backend=self, body=message_data,\n content_type=content_type,\n content_encoding=content_encoding)", "docstring": "Get the next waiting message from the queue.\n\n :returns: A :class:`Message` instance, or ``None`` if there is\n no messages waiting." }, { "code": "def find(name):\n if op.exists(name):\n return name\n path = op.dirname(__file__) or '.'\n paths = [path] + config['include_path']\n for path in paths:\n filename = op.abspath(op.join(path, name))\n if op.exists(filename):\n return filename\n for d in os.listdir(path):\n fullpath = op.abspath(op.join(path, d))\n if op.isdir(fullpath):\n filename = op.abspath(op.join(fullpath, name))\n if op.exists(filename):\n return filename\n return None", "docstring": "Locate a filename into the shader library." }, { "code": "def ref(self, orm_classpath, cls_pk=None):\n orm_module, orm_class = get_objects(orm_classpath)\n q = orm_class.query\n if cls_pk:\n found = False\n for fn, f in orm_class.schema.fields.items():\n cls_ref_s = f.schema\n if cls_ref_s and self.schema == cls_ref_s:\n q.is_field(fn, cls_pk)\n found = True\n break\n if not found:\n raise ValueError(\"Did not find a foreign key field for [{}] in [{}]\".format(\n self.orm_class.table_name,\n orm_class.table_name,\n ))\n return q", "docstring": "takes a classpath to allow query-ing from another Orm class\n\n the reason why it takes string paths is to avoid infinite recursion import \n problems because an orm class from module A might have a ref from module B\n and sometimes it is handy to have module B be able to get the objects from\n module A that correspond to the object in module B, but you can't import\n module A into module B because module B already imports module A.\n\n orm_classpath -- string -- a full python class path (eg, foo.bar.Che)\n cls_pk -- mixed -- automatically set the where field of orm_classpath \n that references self.orm_class to the value in cls_pk if present\n return -- Query()" }, { "code": "def get_planet(planet_id):\n result = _get(planet_id, settings.PLANETS)\n return Planet(result.content)", "docstring": "Return a single planet" }, { "code": "def close(self):\n try:\n self.dut.close()\n except Exception:\n logging.warning('Closing DUT was not successful')\n else:\n logging.debug('Closed DUT')", "docstring": "Releasing hardware resources." }, { "code": "def set(self, name, value, overwrite=False):\n if hasattr(self, name):\n if overwrite:\n setattr(self, name, value)\n else:\n self._log.warning(\"Configuration parameter %s exists and overwrite not allowed\" % name)\n raise Exception(\"Configuration parameter %s exists and overwrite not allowed\" % name)\n else:\n setattr(self, name, value)\n return getattr(self, name)", "docstring": "Sets a new value for a given configuration parameter.\n\n If it already exists, an Exception is thrown.\n To overwrite an existing value, set overwrite to True.\n\n :param name: Unique name of the parameter\n :param value: Value of the configuration parameter\n :param overwrite: If true, an existing parameter of *name* gets overwritten without warning or exception.\n :type overwrite: boolean" }, { "code": "def output(self, value, normal=False, color=None, error=False,\n arrow=False, indent=None):\n if error and value and (normal or self.verbose):\n return self._print(value, color='red', indent=indent)\n if self.verbose or normal:\n return self._print(value, color, arrow, indent)\n return", "docstring": "Handles verbosity of this calls.\n if priority is set to 1, the value is printed\n\n if class instance verbose is True, the value is printed\n\n :param value:\n a string representing the message to be printed\n :type value:\n String\n :param normal:\n if set to true the message is always printed, otherwise it is only shown if verbosity is set\n :type normal:\n boolean\n :param color:\n The color of the message, choices: 'red', 'green', 'blue'\n :type normal:\n String\n :param error:\n if set to true the message appears in red\n :type error:\n Boolean\n :param arrow:\n if set to true an arrow appears before the message\n :type arrow:\n Boolean\n :param indent:\n indents the message based on the number provided\n :type indent:\n Boolean\n\n :returns:\n void" }, { "code": "def _set_status_data(self, userdata):\n self._on_mask = userdata['d3']\n self._off_mask = userdata['d4']\n self._x10_house_code = userdata['d5']\n self._x10_unit = userdata['d6']\n self._ramp_rate = userdata['d7']\n self._on_level = userdata['d8']\n self._led_brightness = userdata['d9']\n self._non_toggle_mask = userdata['d10']\n self._led_bit_mask = userdata['d11']\n self._x10_all_bit_mask = userdata['d12']\n self._on_off_bit_mask = userdata['d13']\n self._trigger_group_bit_mask = userdata['d14']", "docstring": "Set status properties from userdata response.\n\n Response values:\n d3: On Mask\n d4: Off Mask\n d5: X10 House Code\n d6: X10 Unit\n d7: Ramp Rate\n d8: On-Level\n d9: LED Brightness\n d10: Non-Toggle Mask\n d11: LED Bit Mask\n d12: X10 ALL Bit Mask\n d13: On/Off Bit Mask" }, { "code": "def calculate_manual_reading(basic_data: BasicMeterData) -> Reading:\n t_start = basic_data.previous_register_read_datetime\n t_end = basic_data.current_register_read_datetime\n read_start = basic_data.previous_register_read\n read_end = basic_data.current_register_read\n value = basic_data.quantity\n uom = basic_data.uom\n quality_method = basic_data.current_quality_method\n return Reading(t_start, t_end, value, uom, quality_method, \"\", \"\",\n read_start, read_end)", "docstring": "Calculate the interval between two manual readings" }, { "code": "def list_rocs_files(url=ROCS_URL):\n soup = BeautifulSoup(get(url))\n if not url.endswith('/'):\n url += '/'\n files = []\n for elem in soup.findAll('a'):\n if elem['href'].startswith('?'):\n continue\n if elem.string.lower() == 'parent directory':\n continue\n files.append(url + elem['href'])\n return files", "docstring": "Gets the contents of the given url." }, { "code": "def _git_diff(self):\n if self._diff_dict is None:\n result_dict = dict()\n for diff_str in self._get_included_diff_results():\n diff_dict = self._parse_diff_str(diff_str)\n for src_path in diff_dict.keys():\n if self._is_path_excluded(src_path):\n continue\n root, extension = os.path.splitext(src_path)\n extension = extension[1:].lower()\n if not self._supported_extensions or extension in self._supported_extensions:\n added_lines, deleted_lines = diff_dict[src_path]\n result_dict[src_path] = [\n line for line in result_dict.get(src_path, [])\n if not line in deleted_lines\n ] + added_lines\n for (src_path, lines) in result_dict.items():\n result_dict[src_path] = self._unique_ordered_lines(lines)\n self._diff_dict = result_dict\n return self._diff_dict", "docstring": "Run `git diff` and returns a dict in which the keys\n are changed file paths and the values are lists of\n line numbers.\n\n Guarantees that each line number within a file\n is unique (no repeats) and in ascending order.\n\n Returns a cached result if called multiple times.\n\n Raises a GitDiffError if `git diff` has an error." }, { "code": "def environ_setenv(self, tag, data):\n environ = data.get('environ', None)\n if environ is None:\n return False\n false_unsets = data.get('false_unsets', False)\n clear_all = data.get('clear_all', False)\n import salt.modules.environ as mod_environ\n return mod_environ.setenv(environ, false_unsets, clear_all)", "docstring": "Set the salt-minion main process environment according to\n the data contained in the minion event data" }, { "code": "def _create_event(self, event_state, event_type, event_value,\n proc_list, proc_desc, peak_time):\n if event_state == \"WARNING\" or event_state == \"CRITICAL\":\n self.set_process_sort(event_type)\n item = [\n time.mktime(datetime.now().timetuple()),\n -1,\n event_state,\n event_type,\n event_value,\n event_value,\n event_value,\n event_value,\n 1,\n [],\n proc_desc,\n glances_processes.sort_key]\n self.events_list.insert(0, item)\n if self.len() > self.events_max:\n self.events_list.pop()\n return True\n else:\n return False", "docstring": "Add a new item in the log list.\n\n Item is added only if the criticity (event_state) is WARNING or CRITICAL." }, { "code": "def patchURL(self, url, headers, body):\n return self._load_resource(\"PATCH\", url, headers, body)", "docstring": "Request a URL using the HTTP method PATCH." }, { "code": "def predict_is(self, h):\n result = pd.DataFrame([self.run(h=h)[2]]).T \n result.index = self.index[-h:]\n return result", "docstring": "Outputs predictions for the Aggregate algorithm on the in-sample data\n\n Parameters\n ----------\n h : int\n How many steps to run the aggregating algorithm on \n\n Returns\n ----------\n - pd.DataFrame of ensemble predictions" }, { "code": "def start_tasks(self):\n while self.tasks_at_once > len(self.pending_results) and self._has_more_tasks():\n task, parent_result = self.tasks.popleft()\n self.execute_task(task, parent_result)", "docstring": "Start however many tasks we can based on our limits and what we have left to finish." }, { "code": "def re_evaluate(local_dict=None):\n try:\n compiled_ex = _numexpr_last['ex']\n except KeyError:\n raise RuntimeError(\"not a previous evaluate() execution found\")\n argnames = _numexpr_last['argnames']\n args = getArguments(argnames, local_dict)\n kwargs = _numexpr_last['kwargs']\n with evaluate_lock:\n return compiled_ex(*args, **kwargs)", "docstring": "Re-evaluate the previous executed array expression without any check.\n\n This is meant for accelerating loops that are re-evaluating the same\n expression repeatedly without changing anything else than the operands.\n If unsure, use evaluate() which is safer.\n\n Parameters\n ----------\n\n local_dict : dictionary, optional\n A dictionary that replaces the local operands in current frame." }, { "code": "def thread_pool(*workers, results=None, end_of_queue=EndOfQueue):\n if results is None:\n results = Queue(end_of_queue=end_of_queue)\n count = thread_counter(results.close)\n @pull\n def thread_pool_results(source):\n for worker in workers:\n t = threading.Thread(\n target=count(patch),\n args=(pull(source) >> worker, results.sink),\n daemon=True)\n t.start()\n yield from results.source()\n return thread_pool_results", "docstring": "Returns a |pull| object, call it ``r``, starting a thread for each given\n worker. Each thread pulls from the source that ``r`` is connected to, and\n the returned results are pushed to a |Queue|. ``r`` yields from the other\n end of the same |Queue|.\n\n The target function for each thread is |patch|, which can be stopped by\n exhausting the source.\n\n If all threads have ended, the result queue receives end-of-queue.\n\n :param results: If results should go somewhere else than a newly\n constructed |Queue|, a different |Connection| object can be given.\n :type results: |Connection|\n\n :param end_of_queue: end-of-queue signal object passed on to the creation\n of the |Queue| object.\n\n :rtype: |pull|" }, { "code": "def get_value_as_list(self, dictionary, key):\n if key not in dictionary:\n return None\n value = dictionary[key]\n if not isinstance(value, list):\n return [value]\n else:\n return value", "docstring": "Helper function to check and convert a value to list.\n\n Helper function to check and convert a value to json list.\n This helps the ribcl data to be generalized across the servers.\n\n :param dictionary: a dictionary to check in if key is present.\n :param key: key to be checked if thats present in the given dictionary.\n\n :returns the data converted to a list." }, { "code": "def _get_future_tasks(self):\n self.alerts = {}\n now = std_now()\n for task in objectmodels['task'].find({'alert_time': {'$gt': now}}):\n self.alerts[task.alert_time] = task\n self.log('Found', len(self.alerts), 'future tasks')", "docstring": "Assemble a list of future alerts" }, { "code": "def getAvg(self,varname,**kwds):\n if hasattr(self,varname):\n return np.mean(getattr(self,varname),**kwds)\n else:\n return np.nan", "docstring": "Calculates the average of an attribute of this instance. Returns NaN if no such attribute.\n\n Parameters\n ----------\n varname : string\n The name of the attribute whose average is to be calculated. This attribute must be an\n np.array or other class compatible with np.mean.\n\n Returns\n -------\n avg : float or np.array\n The average of this attribute. Might be an array if the axis keyword is passed." }, { "code": "def parse_yaml(self, y):\n self._targets = []\n if 'targets' in y:\n for t in y['targets']:\n if 'waitTime' in t['condition']:\n new_target = WaitTime()\n elif 'preceding' in t['condition']:\n new_target = Preceding()\n else:\n new_target = Condition()\n new_target.parse_yaml(t)\n self._targets.append(new_target)\n return self", "docstring": "Parse a YAML speficication of a message sending object into this\n object." }, { "code": "def create_prefix_dir(self, path, fmt):\n create_prefix_dir(self._get_os_path(path.strip('/')), fmt)", "docstring": "Create the prefix dir, if missing" }, { "code": "def transform_cur_commands_interactive(_, **kwargs):\n event_payload = kwargs.get('event_payload', {})\n cur_commands = event_payload.get('text', '').split(' ')\n _transform_cur_commands(cur_commands)\n event_payload.update({\n 'text': ' '.join(cur_commands)\n })", "docstring": "Transform any aliases in current commands in interactive into their respective commands." }, { "code": "def alias_package(package, alias, extra_modules={}):\n path = package.__path__\n alias_prefix = alias + '.'\n prefix = package.__name__ + '.'\n for _, name, _ in pkgutil.walk_packages(path, prefix):\n if name.startswith('tango.databaseds.db_access.'):\n continue\n try:\n if name not in sys.modules:\n __import__(name)\n except ImportError:\n continue\n alias_name = name.replace(prefix, alias_prefix)\n sys.modules[alias_name] = sys.modules[name]\n for key, value in extra_modules.items():\n name = prefix + value\n if name not in sys.modules:\n __import__(name)\n if not hasattr(package, key):\n setattr(package, key, sys.modules[name])\n sys.modules[alias_prefix + key] = sys.modules[name]\n sys.modules[alias] = sys.modules[package.__name__]", "docstring": "Alias a python package properly.\n\n It ensures that modules are not duplicated by trying\n to import and alias all the submodules recursively." }, { "code": "def _check(self, args):\n if sum(bool(args[arg]) for arg in self._mapping) > 1:\n raise DocoptExit(_('These options are mutually exclusive: {0}',\n ', '.join(self._mapping)))", "docstring": "Exit in case of multiple exclusive arguments." }, { "code": "def get_snapshots(self,**kwargs):\n commits = self.repository.get_commits(**kwargs)\n snapshots = []\n for commit in commits:\n for key in ('committer_date','author_date'):\n commit[key] = datetime.datetime.fromtimestamp(commit[key+'_ts'])\n snapshot = GitSnapshot(commit)\n hasher = Hasher()\n hasher.add(snapshot.sha)\n snapshot.hash = hasher.digest.hexdigest()\n snapshot.project = self.project\n snapshot.pk = uuid.uuid4().hex\n snapshots.append(snapshot)\n return snapshots", "docstring": "Returns a list of snapshots in a given repository." }, { "code": "def in_query(expression):\n def _in(index, expression=expression):\n ev = expression() if callable(expression) else expression\n try:\n iter(ev)\n except TypeError:\n raise AttributeError('$in argument must be an iterable!')\n hashed_ev = [index.get_hash_for(v) for v in ev]\n store_keys = set()\n for value in hashed_ev:\n store_keys |= set(index.get_keys_for(value))\n return list(store_keys)\n return _in", "docstring": "Match any of the values that exist in an array specified in query." }, { "code": "def call(method, *args, **kwargs):\n kwargs = clean_kwargs(**kwargs)\n return getattr(pyeapi_device['connection'], method)(*args, **kwargs)", "docstring": "Calls an arbitrary pyeapi method." }, { "code": "def resizeEvent(self, event):\r\n curr_item = self.currentItem()\r\n self.closePersistentEditor(curr_item)\r\n super(XMultiTagEdit, self).resizeEvent(event)", "docstring": "Overloads the resize event to control if we are still editing.\r\n \r\n If we are resizing, then we are no longer editing." }, { "code": "def server_session(model=None, session_id=None, url=\"default\", relative_urls=False, resources=\"default\"):\n if session_id is None:\n raise ValueError(\"Must supply a session_id\")\n url = _clean_url(url)\n app_path = _get_app_path(url)\n elementid = make_id()\n modelid = \"\" if model is None else model.id\n src_path = _src_path(url, elementid)\n src_path += _process_app_path(app_path)\n src_path += _process_relative_urls(relative_urls, url)\n src_path += _process_session_id(session_id)\n src_path += _process_resources(resources)\n tag = AUTOLOAD_TAG.render(\n src_path = src_path,\n app_path = app_path,\n elementid = elementid,\n modelid = modelid,\n )\n return encode_utf8(tag)", "docstring": "Return a script tag that embeds content from a specific existing session on\n a Bokeh server.\n\n This function is typically only useful for serving from a a specific session\n that was previously created using the ``bokeh.client`` API.\n\n Bokeh apps embedded using these methods will NOT set the browser window title.\n\n .. note::\n Typically you will not want to save or re-use the output of this\n function for different or multiple page loads.\n\n Args:\n model (Model or None, optional) :\n The object to render from the session, or None. (default: None)\n\n If None, the entire document will be rendered.\n\n session_id (str) :\n A server session ID\n\n url (str, optional) :\n A URL to a Bokeh application on a Bokeh server (default: \"default\")\n\n If ``\"default\"`` the default URL ``{DEFAULT_SERVER_HTTP_URL}`` will be used.\n\n relative_urls (bool, optional) :\n Whether to use relative URLs for resources.\n\n If ``True`` the links generated for resources such a BokehJS\n JavaScript and CSS will be relative links.\n\n This should normally be set to ``False``, but must be set to\n ``True`` in situations where only relative URLs will work. E.g.\n when running the Bokeh behind reverse-proxies under certain\n configurations\n\n resources (str) : A string specifying what resources need to be loaded\n along with the document.\n\n If ``default`` then the default JS/CSS bokeh files will be loaded.\n\n If None then none of the resource files will be loaded. This is\n useful if you prefer to serve those resource files via other means\n (e.g. from a caching server). Be careful, however, that the resource\n files you'll load separately are of the same version as that of the\n server's, otherwise the rendering may not work correctly.\n\n Returns:\n A ``'\n js_content = fmt.format(file_content)\n html = html[:match.start()] + js_content + html[match.end():]\n return html", "docstring": "Freeze all JS assets to the rendered html itself." }, { "code": "def build_strings(strings, prefix):\n strings = [\n (\n make_c_str(prefix + str(number), value),\n reloc_ptr(\n prefix + str(number), 'reloc_delta', 'char *'\n )\n ) for value, number in sort_values(strings)\n ]\n return [i[0] for i in strings], [i[1] for i in strings]", "docstring": "Construct string definitions according to\n the previously maintained table." }, { "code": "def mul(left, right):\n from .mv_mul import MvMul\n length = max(left, right)\n if length == 1:\n return Mul(left, right)\n return MvMul(left, right)", "docstring": "Distribution multiplication.\n\n Args:\n left (Dist, numpy.ndarray) : left hand side.\n right (Dist, numpy.ndarray) : right hand side." }, { "code": "def check_types(func):\n call = PythonCall(func)\n @wraps(func)\n def decorator(*args, **kwargs):\n parameters = call.bind(args, kwargs)\n for arg_name, expected_type in func.__annotations__.items():\n if not isinstance(parameters[arg_name], expected_type):\n raise TypeError(\"{} must be a {}\".format(\n arg_name, expected_type))\n return call.apply(args, kwargs)\n return decorator", "docstring": "Check if annotated function arguments are of the correct type" }, { "code": "def _SkipGroup(buffer, pos, end):\n while 1:\n (tag_bytes, pos) = ReadTag(buffer, pos)\n new_pos = SkipField(buffer, pos, end, tag_bytes)\n if new_pos == -1:\n return pos\n pos = new_pos", "docstring": "Skip sub-group. Returns the new position." }, { "code": "def purge_dict(idict):\n odict = {}\n for key, val in idict.items():\n if is_null(val):\n continue\n odict[key] = val\n return odict", "docstring": "Remove null items from a dictionary" }, { "code": "def _refresh(self):\n new_token = self.authenticate(self._username, self._password)\n self._token = new_token\n logger.info('New API token received: \"{}\".'.format(new_token))\n return self._token", "docstring": "Refresh the API token using the currently bound credentials.\n\n This is simply a convenience method to be invoked automatically if authentication fails\n during normal client use." }, { "code": "def run():\n _parser_options()\n set_verbose(args[\"verbose\"])\n if _check_global_settings():\n _load_db()\n else:\n exit(-1)\n _setup_server()\n if args[\"rollback\"]:\n _server_rollback()\n okay(\"The server rollback appears to have been successful.\")\n exit(0)\n _server_enable() \n _list_repos()\n _handle_install()\n _do_cron()", "docstring": "Main script entry to handle the arguments given to the script." }, { "code": "def search_one(self, keyword, arg=None, children=None):\n if children is None:\n children = self.substmts\n for ch in children:\n if ch.keyword == keyword and (arg is None or ch.arg == arg):\n return ch\n return None", "docstring": "Return receiver's substmt with `keyword` and optionally `arg`." }, { "code": "def set_examples(self, examples):\n self.store('examples', examples)\n if len(examples) > 0:\n self.store('are_sequence_examples',\n isinstance(examples[0], tf.train.SequenceExample))\n return self", "docstring": "Sets the examples to be displayed in WIT.\n\n Args:\n examples: List of example protos.\n\n Returns:\n self, in order to enabled method chaining." }, { "code": "def _get_explicit_environ_credentials():\n explicit_file = os.environ.get(environment_vars.CREDENTIALS)\n if explicit_file is not None:\n credentials, project_id = _load_credentials_from_file(\n os.environ[environment_vars.CREDENTIALS])\n return credentials, project_id\n else:\n return None, None", "docstring": "Gets credentials from the GOOGLE_APPLICATION_CREDENTIALS environment\n variable." }, { "code": "def load_sensor_composites(self, sensor_name):\n config_filename = sensor_name + \".yaml\"\n LOG.debug(\"Looking for composites config file %s\", config_filename)\n composite_configs = config_search_paths(\n os.path.join(\"composites\", config_filename),\n self.ppp_config_dir, check_exists=True)\n if not composite_configs:\n LOG.debug(\"No composite config found called {}\".format(\n config_filename))\n return\n self._load_config(composite_configs)", "docstring": "Load all compositor configs for the provided sensor." }, { "code": "def get_properties(obj):\n properties = {}\n for property_name in dir(obj):\n property = getattr(obj, property_name)\n if PropertyReflector._is_property(property, property_name):\n properties[property_name] = property\n return properties", "docstring": "Get values of all properties in specified object and returns them as a map.\n\n :param obj: an object to get properties from.\n\n :return: a map, containing the names of the object's properties and their values." }, { "code": "def set_mime_type(self, mime_type):\n try:\n self.set_lexer_from_mime_type(mime_type)\n except ClassNotFound:\n _logger().exception('failed to get lexer from mimetype')\n self._lexer = TextLexer()\n return False\n except ImportError:\n _logger().warning('failed to get lexer from mimetype (%s)' %\n mime_type)\n self._lexer = TextLexer()\n return False\n else:\n return True", "docstring": "Update the highlighter lexer based on a mime type.\n\n :param mime_type: mime type of the new lexer to setup." }, { "code": "def tag_timexes(self):\n if not self.is_tagged(ANALYSIS):\n self.tag_analysis()\n if not self.is_tagged(TIMEXES):\n if self.__timex_tagger is None:\n self.__timex_tagger = load_default_timex_tagger()\n self.__timex_tagger.tag_document(self, **self.__kwargs)\n return self", "docstring": "Create ``timexes`` layer.\n Depends on morphological analysis data in ``words`` layer\n and tags it automatically, if it is not present." }, { "code": "def set_value(self, value, block_events=False):\n if block_events: self.block_events()\n self._widget.setValue(value)\n if block_events: self.unblock_events()", "docstring": "Sets the current value of the number box.\n\n Setting block_events=True will temporarily block the widget from\n sending any signals when setting the value." }, { "code": "def delete_request(\n self,\n alias,\n uri,\n data=None,\n json=None,\n params=None,\n headers=None,\n allow_redirects=None,\n timeout=None):\n session = self._cache.switch(alias)\n data = self._format_data_according_to_header(session, data, headers)\n redir = True if allow_redirects is None else allow_redirects\n response = self._delete_request(\n session, uri, data, json, params, headers, redir, timeout)\n if isinstance(data, bytes):\n data = data.decode('utf-8')\n logger.info('Delete Request using : alias=%s, uri=%s, data=%s, \\\n headers=%s, allow_redirects=%s ' % (alias, uri, data, headers, redir))\n return response", "docstring": "Send a DELETE request on the session object found using the\n given `alias`\n\n ``alias`` that will be used to identify the Session object in the cache\n\n ``uri`` to send the DELETE request to\n\n ``json`` a value that will be json encoded\n and sent as request data if data is not specified\n\n ``headers`` a dictionary of headers to use with the request\n\n ``allow_redirects`` Boolean. Set to True if POST/PUT/DELETE redirect following is allowed.\n\n ``timeout`` connection timeout" }, { "code": "def task_transaction(channel):\n with channel.lock:\n if channel.poll(0):\n task = channel.recv()\n channel.send(Acknowledgement(os.getpid(), task.id))\n else:\n raise RuntimeError(\"Race condition between workers\")\n return task", "docstring": "Ensures a task is fetched and acknowledged atomically." }, { "code": "def convert(cls, value, from_unit, to_unit):\n value_ms = value * cls.UNITS_IN_MILLISECONDS[from_unit]\n return value_ms / cls.UNITS_IN_MILLISECONDS[to_unit]", "docstring": "Convert a value from one time unit to another.\n\n :return: the numeric value converted to the desired unit\n :rtype: float" }, { "code": "def isinstance(instance, ifaces):\n ifaces = _ensure_ifaces_tuple(ifaces)\n for iface in ifaces:\n attributes = (\n attr\n for attr in iface.__abstractmethods__\n if hasattr(getattr(iface, attr), '__iattribute__')\n )\n for attribute in attributes:\n if not hasattr(instance, attribute):\n return False\n if not issubclass(type(instance), ifaces):\n return False\n return True", "docstring": "Check if a given instance is an implementation of the interface." }, { "code": "def get_con_id(self):\n con_id = \"\"\n if \"contribution\" in self.tables:\n if \"id\" in self.tables[\"contribution\"].df.columns:\n con_id = str(self.tables[\"contribution\"].df[\"id\"].values[0])\n return con_id", "docstring": "Return contribution id if available" }, { "code": "def convert_ids_to_tokens(self, ids):\n tokens = []\n for i in ids:\n tokens.append(self.ids_to_tokens[i])\n return tokens", "docstring": "Converts a sequence of ids in wordpiece tokens using the vocab." }, { "code": "def clear_license(self):\n if (self.get_license_metadata().is_read_only() or\n self.get_license_metadata().is_required()):\n raise errors.NoAccess()\n self._my_map['license'] = dict(self._license_default)", "docstring": "Removes the license.\n\n raise: NoAccess - ``Metadata.isRequired()`` is ``true`` or\n ``Metadata.isReadOnly()`` is ``true``\n *compliance: mandatory -- This method must be implemented.*" }, { "code": "def unlistify(n, depth=1, typ=list, get=None):\n i = 0\n if depth is None:\n depth = 1\n index_desired = get or 0\n while i < depth and isinstance(n, typ):\n if len(n):\n if len(n) > index_desired:\n n = n[index_desired]\n i += 1\n else:\n return n\n return n", "docstring": "Return the desired element in a list ignoring the rest.\n\n >>> unlistify([1,2,3])\n 1\n >>> unlistify([1,[4, 5, 6],3], get=1)\n [4, 5, 6]\n >>> unlistify([1,[4, 5, 6],3], depth=2, get=1)\n 5\n >>> unlistify([1,(4, 5, 6),3], depth=2, get=1)\n (4, 5, 6)\n >>> unlistify([1,2,(4, 5, 6)], depth=2, get=2)\n (4, 5, 6)\n >>> unlistify([1,2,(4, 5, 6)], depth=2, typ=(list, tuple), get=2)\n 6" }, { "code": "def InstallNanny(self):\n new_config = config.CONFIG.MakeNewConfig()\n new_config.SetWriteBack(config.CONFIG[\"Config.writeback\"])\n for option in self.nanny_options:\n new_config.Set(option, config.CONFIG.Get(option))\n new_config.Write()\n args = [\n config.CONFIG[\"Nanny.binary\"], \"--service_key\",\n config.CONFIG[\"Client.config_key\"], \"install\"\n ]\n logging.debug(\"Calling %s\", (args,))\n output = subprocess.check_output(\n args, shell=True, stdin=subprocess.PIPE, stderr=subprocess.PIPE)\n logging.debug(\"%s\", output)", "docstring": "Install the nanny program." }, { "code": "def to_string_with_default(value, default_value):\n result = StringConverter.to_nullable_string(value)\n return result if result != None else default_value", "docstring": "Converts value into string or returns default when value is None.\n\n :param value: the value to convert.\n\n :param default_value: the default value.\n\n :return: string value or default when value is null." }, { "code": "def get(self, var, default=None):\n try:\n return self.__get(var)\n except (KeyError, IndexError):\n return default", "docstring": "Return a value from configuration.\n\n Safe version which always returns a default value if the value is not\n found." }, { "code": "def get_mean_values(self, C, sites, rup, dists, a1100):\n if isinstance(a1100, np.ndarray):\n temp_vs30 = sites.vs30\n temp_z2pt5 = sites.z2pt5\n else:\n temp_vs30 = 1100.0 * np.ones(len(sites.vs30))\n temp_z2pt5 = self._select_basin_model(1100.0) *\\\n np.ones_like(temp_vs30)\n return (self._get_magnitude_term(C, rup.mag) +\n self._get_geometric_attenuation_term(C, rup.mag, dists.rrup) +\n self._get_style_of_faulting_term(C, rup) +\n self._get_hanging_wall_term(C, rup, dists) +\n self._get_shallow_site_response_term(C, temp_vs30, a1100) +\n self._get_basin_response_term(C, temp_z2pt5) +\n self._get_hypocentral_depth_term(C, rup) +\n self._get_fault_dip_term(C, rup) +\n self._get_anelastic_attenuation_term(C, dists.rrup))", "docstring": "Returns the mean values for a specific IMT" }, { "code": "def add_column(self, column_name, column_values):\n if isinstance(column_values, list) and isinstance(column_values[0], list):\n raise ValueError('\"column_values\" must be a flat list, but we detected '\n 'that its first entry is a list')\n if isinstance(column_values, np.ndarray) and column_values.ndim != 1:\n raise ValueError('\"column_values\" should be of rank 1, '\n 'but is of rank %d' % column_values.ndim)\n if len(column_values) != self.num_points:\n raise ValueError('\"column_values\" should be of length %d, but is of '\n 'length %d' % (self.num_points, len(column_values)))\n if column_name in self.name_to_values:\n raise ValueError('The column name \"%s\" is already used' % column_name)\n self.column_names.append(column_name)\n self.name_to_values[column_name] = column_values", "docstring": "Adds a named column of metadata values.\n\n Args:\n column_name: Name of the column.\n column_values: 1D array/list/iterable holding the column values. Must be\n of length `num_points`. The i-th value corresponds to the i-th point.\n\n Raises:\n ValueError: If `column_values` is not 1D array, or of length `num_points`,\n or the `name` is already used." }, { "code": "def get_sentences_list(self, sentences=1):\n if sentences < 1:\n raise ValueError('Param \"sentences\" must be greater than 0.')\n sentences_list = []\n while sentences:\n num_rand_words = random.randint(self.MIN_WORDS, self.MAX_WORDS)\n random_sentence = self.make_sentence(\n random.sample(self.words, num_rand_words))\n sentences_list.append(random_sentence)\n sentences -= 1\n return sentences_list", "docstring": "Return sentences in list.\n\n :param int sentences: how many sentences\n :returns: list of strings with sentence\n :rtype: list" }, { "code": "def lock_option(self, key, subkey):\n key, subkey = _lower_keys(key, subkey)\n _entry_must_exist(self.gc, key, subkey)\n self.gc.loc[\n (self.gc[\"k1\"] == key) &\n (self.gc[\"k2\"] == subkey), \"locked\"] = True", "docstring": "Make an option unmutable.\n\n :param str key: First identifier of the option.\n :param str subkey: Second identifier of the option.\n\n :raise:\n :NotRegisteredError: If ``key`` or ``subkey`` do not define any\n option." }, { "code": "def resolve_nested_dict(nested_dict):\n res = {}\n for k, v in nested_dict.items():\n if isinstance(v, dict):\n for k_, v_ in resolve_nested_dict(v).items():\n res[(k, ) + k_] = v_\n else:\n res[(k, )] = v\n return res", "docstring": "Flattens a nested dict by joining keys into tuple of paths.\n\n Can then be passed into `format_vars`." }, { "code": "def _estimate_p_values(self):\n if not self._is_fitted:\n raise AttributeError('GAM has not been fitted. Call fit first.')\n p_values = []\n for term_i in range(len(self.terms)):\n p_values.append(self._compute_p_value(term_i))\n return p_values", "docstring": "estimate the p-values for all features" }, { "code": "def scene_name(sequence_number, scene_id, name):\n return MessageWriter().string(\"scene.name\").uint64(sequence_number).uint32(scene_id).string(name).get()", "docstring": "Create a scene.name message" }, { "code": "def get_pwm_list(pwm_id_list, pseudocountProb=0.0001):\n l = load_motif_db(HOCOMOCO_PWM)\n l = {k.split()[0]: v for k, v in l.items()}\n pwm_list = [PWM(_normalize_pwm(l[m]) + pseudocountProb, name=m) for m in pwm_id_list]\n return pwm_list", "docstring": "Get a list of HOCOMOCO PWM's.\n\n # Arguments\n pwm_id_list: List of id's from the `PWM_id` column in `get_metadata()` table\n pseudocountProb: Added pseudocount probabilities to the PWM\n\n # Returns\n List of `concise.utils.pwm.PWM` instances." }, { "code": "def _customer_lifetime_value(\n transaction_prediction_model, frequency, recency, T, monetary_value, time=12, discount_rate=0.01, freq=\"D\"\n):\n df = pd.DataFrame(index=frequency.index)\n df[\"clv\"] = 0\n steps = np.arange(1, time + 1)\n factor = {\"W\": 4.345, \"M\": 1.0, \"D\": 30, \"H\": 30 * 24}[freq]\n for i in steps * factor:\n expected_number_of_transactions = transaction_prediction_model.predict(\n i, frequency, recency, T\n ) - transaction_prediction_model.predict(i - factor, frequency, recency, T)\n df[\"clv\"] += (monetary_value * expected_number_of_transactions) / (1 + discount_rate) ** (i / factor)\n return df[\"clv\"]", "docstring": "Compute the average lifetime value for a group of one or more customers.\n\n This method computes the average lifetime value for a group of one or more customers.\n\n Parameters\n ----------\n transaction_prediction_model:\n the model to predict future transactions\n frequency: array_like\n the frequency vector of customers' purchases (denoted x in literature).\n recency: array_like\n the recency vector of customers' purchases (denoted t_x in literature).\n T: array_like\n the vector of customers' age (time since first purchase)\n monetary_value: array_like\n the monetary value vector of customer's purchases (denoted m in literature).\n time: int, optional\n the lifetime expected for the user in months. Default: 12\n discount_rate: float, optional\n the monthly adjusted discount rate. Default: 1\n\n Returns\n -------\n :obj: Series\n series with customer ids as index and the estimated customer lifetime values as values" }, { "code": "def _resource_prefix(self, resource=None):\n px = 'ELASTICSEARCH'\n if resource and config.DOMAIN[resource].get('elastic_prefix'):\n px = config.DOMAIN[resource].get('elastic_prefix')\n return px", "docstring": "Get elastic prefix for given resource.\n\n Resource can specify ``elastic_prefix`` which behaves same like ``mongo_prefix``." }, { "code": "def get_backspace_count(self, buffer):\n if TriggerMode.ABBREVIATION in self.modes and self.backspace:\n if self._should_trigger_abbreviation(buffer):\n abbr = self._get_trigger_abbreviation(buffer)\n stringBefore, typedAbbr, stringAfter = self._partition_input(buffer, abbr)\n return len(abbr) + len(stringAfter)\n if self.parent is not None:\n return self.parent.get_backspace_count(buffer)\n return 0", "docstring": "Given the input buffer, calculate how many backspaces are needed to erase the text\n that triggered this folder." }, { "code": "def _create_driver(self, **kwargs):\n if self.driver is None:\n self.driver = self.create_driver(**kwargs)\n self.init_driver_func(self.driver)", "docstring": "Create webdriver, assign it to ``self.driver``, and run webdriver\n initiation process, which is usually used for manual login." }, { "code": "def parse(self, module):\n self.parse_block(module.refstring, module, module, 0)\n min_start = len(module.refstring)\n for x in module.executables:\n if module.executables[x].start < min_start:\n min_start = module.executables[x].start\n module.contains = module.refstring[min_start::]", "docstring": "Extracts all the subroutine and function definitions from the specified module." }, { "code": "def _dirdiffandupdate(self, dir1, dir2):\n self._dowork(dir1, dir2, None, self._update)", "docstring": "Private function which does directory diff & update" }, { "code": "def collect_blame_info(cls, matches):\n old_area = None\n for filename, ranges in matches:\n area, name = os.path.split(filename)\n if not area:\n area = '.'\n if area != old_area:\n print(\"\\n\\n%s/\\n\" % area)\n old_area = area\n print(\"%s \" % name, end=\"\")\n filter = cls.build_line_range_filter(ranges)\n command = ['git', 'blame', '--line-porcelain'] + filter + [name]\n os.chdir(area)\n p = subprocess.Popen(command, stdout=subprocess.PIPE,\n stderr=subprocess.PIPE)\n out, err = p.communicate()\n if err:\n print(\" <<<<<<<<<< Unable to collect 'git blame' info:\", err)\n else:\n yield out", "docstring": "Runs git blame on files, for the specified sets of line ranges.\n\n If no line range tuples are provided, it will do all lines." }, { "code": "def AddFileEntry(\n self, path, file_entry_type=definitions.FILE_ENTRY_TYPE_FILE,\n file_data=None, link_data=None):\n if path in self._paths:\n raise KeyError('File entry already set for path: {0:s}.'.format(path))\n if file_data and file_entry_type != definitions.FILE_ENTRY_TYPE_FILE:\n raise ValueError('File data set for non-file file entry type.')\n if link_data and file_entry_type != definitions.FILE_ENTRY_TYPE_LINK:\n raise ValueError('Link data set for non-link file entry type.')\n if file_data is not None:\n path_data = file_data\n elif link_data is not None:\n path_data = link_data\n else:\n path_data = None\n self._paths[path] = (file_entry_type, path_data)", "docstring": "Adds a fake file entry.\n\n Args:\n path (str): path of the file entry.\n file_entry_type (Optional[str]): type of the file entry object.\n file_data (Optional[bytes]): data of the fake file-like object.\n link_data (Optional[bytes]): link data of the fake file entry object.\n\n Raises:\n KeyError: if the path already exists.\n ValueError: if the file data is set but the file entry type is not a file\n or if the link data is set but the file entry type is not a link." }, { "code": "def on_key_press(self, event):\n key = event.key\n if event.modifiers:\n return\n if self.enable_keyboard_pan and key in self._arrows:\n self._pan_keyboard(key)\n if key in self._pm:\n self._zoom_keyboard(key)\n if key == 'R':\n self.reset()", "docstring": "Pan and zoom with the keyboard." }, { "code": "def get_clonespec_for_valid_snapshot(config_spec, object_ref, reloc_spec, template, vm_):\n moving = True\n if QUICK_LINKED_CLONE == vm_['snapshot']['disk_move_type']:\n reloc_spec.diskMoveType = QUICK_LINKED_CLONE\n elif CURRENT_STATE_LINKED_CLONE == vm_['snapshot']['disk_move_type']:\n reloc_spec.diskMoveType = CURRENT_STATE_LINKED_CLONE\n elif COPY_ALL_DISKS_FULL_CLONE == vm_['snapshot']['disk_move_type']:\n reloc_spec.diskMoveType = COPY_ALL_DISKS_FULL_CLONE\n elif FLATTEN_DISK_FULL_CLONE == vm_['snapshot']['disk_move_type']:\n reloc_spec.diskMoveType = FLATTEN_DISK_FULL_CLONE\n else:\n moving = False\n if moving:\n return build_clonespec(config_spec, object_ref, reloc_spec, template)\n return None", "docstring": "return clonespec only if values are valid" }, { "code": "def facts():\n ret = {}\n try:\n ret['facts'] = __proxy__['junos.get_serialized_facts']()\n ret['out'] = True\n except Exception as exception:\n ret['message'] = 'Could not display facts due to \"{0}\"'.format(\n exception)\n ret['out'] = False\n return ret", "docstring": "Displays the facts gathered during the connection.\n These facts are also stored in Salt grains.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt 'device_name' junos.facts" }, { "code": "def view_job_info(token, dstore):\n data = [['task', 'sent', 'received']]\n for task in dstore['task_info']:\n dset = dstore['task_info/' + task]\n if 'argnames' in dset.attrs:\n argnames = dset.attrs['argnames'].split()\n totsent = dset.attrs['sent']\n sent = ['%s=%s' % (a, humansize(s))\n for s, a in sorted(zip(totsent, argnames), reverse=True)]\n recv = dset['received'].sum()\n data.append((task, ' '.join(sent), humansize(recv)))\n return rst_table(data)", "docstring": "Determine the amount of data transferred from the controller node\n to the workers and back in a classical calculation." }, { "code": "def get_parent_catalogs(self, catalog_id):\n if self._catalog_session is not None:\n return self._catalog_session.get_parent_catalogs(catalog_id=catalog_id)\n return CatalogLookupSession(\n self._proxy,\n self._runtime).get_catalogs_by_ids(\n list(self.get_parent_catalog_ids(catalog_id)))", "docstring": "Gets the parent catalogs of the given ``id``.\n\n arg: catalog_id (osid.id.Id): the ``Id`` of the ``Catalog``\n to query\n return: (osid.cataloging.CatalogList) - the parent catalogs of\n the ``id``\n raise: NotFound - a ``Catalog`` identified by ``Id is`` not\n found\n raise: NullArgument - ``catalog_id`` is ``null``\n raise: OperationFailed - unable to complete request\n raise: PermissionDenied - authorization failure\n *compliance: mandatory -- This method must be implemented.*" }, { "code": "def _build_cookie_jar(cls, session: AppSession):\n if not session.args.cookies:\n return\n if session.args.load_cookies or session.args.save_cookies:\n session.factory.set('CookieJar', BetterMozillaCookieJar)\n cookie_jar = session.factory.new('CookieJar')\n if session.args.load_cookies:\n cookie_jar.load(session.args.load_cookies, ignore_discard=True)\n else:\n cookie_jar = session.factory.new('CookieJar')\n policy = session.factory.new('CookiePolicy', cookie_jar=cookie_jar)\n cookie_jar.set_policy(policy)\n _logger.debug(__('Loaded cookies: {0}', list(cookie_jar)))\n cookie_jar_wrapper = session.factory.new(\n 'CookieJarWrapper',\n cookie_jar,\n save_filename=session.args.save_cookies,\n keep_session_cookies=session.args.keep_session_cookies,\n )\n return cookie_jar_wrapper", "docstring": "Build the cookie jar" }, { "code": "def ms_to_datetime(ms):\n dt = datetime.datetime.utcfromtimestamp(ms / 1000)\n return dt.replace(microsecond=(ms % 1000) * 1000).replace(tzinfo=pytz.utc)", "docstring": "Converts a millisecond accuracy timestamp to a datetime" }, { "code": "def pad_char(text: str, width: int, char: str = '\\n') -> str:\r\n dis = width - len(text)\r\n if dis < 0:\r\n raise ValueError\r\n if dis > 0:\r\n text += char * dis\r\n return text", "docstring": "Pads a text until length width." }, { "code": "def _call(self, x):\n pointwise_norm = self.pointwise_norm(x)\n return pointwise_norm.inner(pointwise_norm.space.one())", "docstring": "Return the group L1-norm of ``x``." }, { "code": "def polygon_from_points(points):\n polygon = []\n for pair in points.split(\" \"):\n x_y = pair.split(\",\")\n polygon.append([float(x_y[0]), float(x_y[1])])\n return polygon", "docstring": "Constructs a numpy-compatible polygon from a page representation." }, { "code": "def bind_filter(self, direction, filter_name):\n if direction not in self._dynamips_direction:\n raise DynamipsError(\"Unknown direction {} to bind filter {}:\".format(direction, filter_name))\n dynamips_direction = self._dynamips_direction[direction]\n yield from self._hypervisor.send(\"nio bind_filter {name} {direction} {filter}\".format(name=self._name,\n direction=dynamips_direction,\n filter=filter_name))\n if direction == \"in\":\n self._input_filter = filter_name\n elif direction == \"out\":\n self._output_filter = filter_name\n elif direction == \"both\":\n self._input_filter = filter_name\n self._output_filter = filter_name", "docstring": "Adds a packet filter to this NIO.\n Filter \"freq_drop\" drops packets.\n Filter \"capture\" captures packets.\n\n :param direction: \"in\", \"out\" or \"both\"\n :param filter_name: name of the filter to apply" }, { "code": "def create_spot_datafeed_subscription(self, bucket, prefix):\n params = {'Bucket' : bucket}\n if prefix:\n params['Prefix'] = prefix\n return self.get_object('CreateSpotDatafeedSubscription',\n params, SpotDatafeedSubscription, verb='POST')", "docstring": "Create a spot instance datafeed subscription for this account.\n\n :type bucket: str or unicode\n :param bucket: The name of the bucket where spot instance data\n will be written. The account issuing this request\n must have FULL_CONTROL access to the bucket\n specified in the request.\n\n :type prefix: str or unicode\n :param prefix: An optional prefix that will be pre-pended to all\n data files written to the bucket.\n\n :rtype: :class:`boto.ec2.spotdatafeedsubscription.SpotDatafeedSubscription`\n :return: The datafeed subscription object or None" }, { "code": "def process_fields(self, fields):\n\t\tresult = []\n\t\tstrip = ''.join(self.PREFIX_MAP)\n\t\tfor field in fields:\n\t\t\tdirection = self.PREFIX_MAP['']\n\t\t\tif field[0] in self.PREFIX_MAP:\n\t\t\t\tdirection = self.PREFIX_MAP[field[0]]\n\t\t\t\tfield = field.lstrip(strip)\n\t\t\tresult.append((field, direction))\n\t\treturn result", "docstring": "Process a list of simple string field definitions and assign their order based on prefix." }, { "code": "def load_dotenv(dotenv_path, verbose=False):\n if not os.path.exists(dotenv_path):\n if verbose:\n warnings.warn(f\"Not loading {dotenv_path}, it doesn't exist.\")\n return None\n for k, v in dotenv_values(dotenv_path).items():\n os.environ.setdefault(k, v)\n return True", "docstring": "Read a .env file and load into os.environ.\n\n :param dotenv_path:\n :type dotenv_path: str\n :param verbose: verbosity flag, raise warning if path does not exist\n :return: success flag" }, { "code": "def iv(b, **kwargs):\n import matplotlib.pyplot as plt\n import imview.imviewer as imview \n b = checkma(b)\n fig = plt.figure()\n imview.bma_fig(fig, b, **kwargs)\n plt.show()\n return fig", "docstring": "Quick access to imview for interactive sessions" }, { "code": "def withconfig(self, keysuffix):\n def decorator(cls):\n return self.loadconfig(keysuffix, cls)\n return decorator", "docstring": "Load configurations with this decorator" }, { "code": "def run(self):\n self.files_exist()\n self.info_file()\n sources = self.sources\n if len(sources) > 1 and self.sbo_sources != sources:\n sources = self.sbo_sources\n BuildPackage(self.script, sources, self.path, auto=True).build()\n raise SystemExit()", "docstring": "Build package and fix ordelist per checksum" }, { "code": "def return_features_numpy(self, names='all'):\n if self._prepopulated is False:\n raise errors.EmptyDatabase(self.dbpath)\n else:\n return return_features_numpy_base(self.dbpath, self._set_object, self.points_amt, names)", "docstring": "Returns a 2d numpy array of extracted features\n\n Parameters\n ----------\n names : list of strings, a list of feature names which are to be retrieved from the database, if equal to 'all',\n all features will be returned, default value: 'all'\n\n Returns\n -------\n A numpy array of features, each row corresponds to a single datapoint. If a single feature is a 1d numpy array,\n then it will be unrolled into the resulting array. Higher-dimensional numpy arrays are not supported." }, { "code": "def query(self, variables, evidence=None, joint=True):\n return self._query(variables=variables, operation='marginalize', evidence=evidence, joint=joint)", "docstring": "Query method using belief propagation.\n\n Parameters\n ----------\n variables: list\n list of variables for which you want to compute the probability\n\n evidence: dict\n a dict key, value pair as {var: state_of_var_observed}\n None if no evidence\n\n joint: boolean\n If True, returns a Joint Distribution over `variables`.\n If False, returns a dict of distributions over each of the `variables`.\n\n Examples\n --------\n >>> from pgmpy.factors.discrete import TabularCPD\n >>> from pgmpy.models import BayesianModel\n >>> from pgmpy.inference import BeliefPropagation\n >>> bayesian_model = BayesianModel([('A', 'J'), ('R', 'J'), ('J', 'Q'),\n ... ('J', 'L'), ('G', 'L')])\n >>> cpd_a = TabularCPD('A', 2, [[0.2], [0.8]])\n >>> cpd_r = TabularCPD('R', 2, [[0.4], [0.6]])\n >>> cpd_j = TabularCPD('J', 2,\n ... [[0.9, 0.6, 0.7, 0.1],\n ... [0.1, 0.4, 0.3, 0.9]],\n ... ['R', 'A'], [2, 2])\n >>> cpd_q = TabularCPD('Q', 2,\n ... [[0.9, 0.2],\n ... [0.1, 0.8]],\n ... ['J'], [2])\n >>> cpd_l = TabularCPD('L', 2,\n ... [[0.9, 0.45, 0.8, 0.1],\n ... [0.1, 0.55, 0.2, 0.9]],\n ... ['G', 'J'], [2, 2])\n >>> cpd_g = TabularCPD('G', 2, [[0.6], [0.4]])\n >>> bayesian_model.add_cpds(cpd_a, cpd_r, cpd_j, cpd_q, cpd_l, cpd_g)\n >>> belief_propagation = BeliefPropagation(bayesian_model)\n >>> belief_propagation.query(variables=['J', 'Q'],\n ... evidence={'A': 0, 'R': 0, 'G': 0, 'L': 1})" }, { "code": "def getReferenceByName(self, name):\n if name not in self._referenceNameMap:\n raise exceptions.ReferenceNameNotFoundException(name)\n return self._referenceNameMap[name]", "docstring": "Returns the reference with the specified name." }, { "code": "def add_token_to_namespace(self, token: str, namespace: str = 'tokens') -> int:\n if not isinstance(token, str):\n raise ValueError(\"Vocabulary tokens must be strings, or saving and loading will break.\"\n \" Got %s (with type %s)\" % (repr(token), type(token)))\n if token not in self._token_to_index[namespace]:\n index = len(self._token_to_index[namespace])\n self._token_to_index[namespace][token] = index\n self._index_to_token[namespace][index] = token\n return index\n else:\n return self._token_to_index[namespace][token]", "docstring": "Adds ``token`` to the index, if it is not already present. Either way, we return the index of\n the token." }, { "code": "def get_vexrc(options, environ):\n if options.config and not os.path.exists(options.config):\n raise exceptions.InvalidVexrc(\"nonexistent config: {0!r}\".format(options.config))\n filename = options.config or os.path.expanduser('~/.vexrc')\n vexrc = config.Vexrc.from_file(filename, environ)\n return vexrc", "docstring": "Get a representation of the contents of the config file.\n\n :returns:\n a Vexrc instance." }, { "code": "def create_client_with_manual_poll(api_key, config_cache_class=None,\n base_url=None):\n if api_key is None:\n raise ConfigCatClientException('API Key is required.')\n return ConfigCatClient(api_key, 0, 0, None, 0, config_cache_class, base_url)", "docstring": "Create an instance of ConfigCatClient and setup Manual Poll mode with custom options\n\n :param api_key: ConfigCat ApiKey to access your configuration.\n :param config_cache_class: If you want to use custom caching instead of the client's default InMemoryConfigCache,\n You can provide an implementation of ConfigCache.\n :param base_url: You can set a base_url if you want to use a proxy server between your application and ConfigCat" }, { "code": "def has_textonly_pdf():\n args_tess = ['tesseract', '--print-parameters', 'pdf']\n params = ''\n try:\n params = check_output(args_tess, universal_newlines=True, stderr=STDOUT)\n except CalledProcessError as e:\n print(\"Could not --print-parameters from tesseract\", file=sys.stderr)\n raise MissingDependencyError from e\n if 'textonly_pdf' in params:\n return True\n return False", "docstring": "Does Tesseract have textonly_pdf capability?\n\n Available in v4.00.00alpha since January 2017. Best to\n parse the parameter list" }, { "code": "def Delete(self):\n args = user_management_pb2.ApiDeleteGrrUserArgs(username=self.username)\n self._context.SendRequest(\"DeleteGrrUser\", args)", "docstring": "Deletes the user." }, { "code": "def cast_values_csvs(d, idx, x):\n try:\n d[idx].append(float(x))\n except ValueError:\n d[idx].append(x)\n except KeyError as e:\n logger_misc.warn(\"cast_values_csv: KeyError: col: {}, {}\".format(x, e))\n return d", "docstring": "Attempt to cast string to float. If error, keep as a string.\n\n :param dict d: Data\n :param int idx: Index number\n :param str x: Data\n :return any:" }, { "code": "def create(self, friendly_name, event_callback_url=values.unset,\n events_filter=values.unset, multi_task_enabled=values.unset,\n template=values.unset, prioritize_queue_order=values.unset):\n data = values.of({\n 'FriendlyName': friendly_name,\n 'EventCallbackUrl': event_callback_url,\n 'EventsFilter': events_filter,\n 'MultiTaskEnabled': multi_task_enabled,\n 'Template': template,\n 'PrioritizeQueueOrder': prioritize_queue_order,\n })\n payload = self._version.create(\n 'POST',\n self._uri,\n data=data,\n )\n return WorkspaceInstance(self._version, payload, )", "docstring": "Create a new WorkspaceInstance\n\n :param unicode friendly_name: Human readable description of this workspace\n :param unicode event_callback_url: If provided, the Workspace will publish events to this URL.\n :param unicode events_filter: Use this parameter to receive webhooks on EventCallbackUrl for specific events on a workspace.\n :param bool multi_task_enabled: Multi tasking allows workers to handle multiple tasks simultaneously.\n :param unicode template: One of the available template names.\n :param WorkspaceInstance.QueueOrder prioritize_queue_order: Use this parameter to configure whether to prioritize LIFO or FIFO when workers are receiving Tasks from combination of LIFO and FIFO TaskQueues.\n\n :returns: Newly created WorkspaceInstance\n :rtype: twilio.rest.taskrouter.v1.workspace.WorkspaceInstance" }, { "code": "def _get_proc_username(proc):\n try:\n return salt.utils.data.decode(proc.username() if PSUTIL2 else proc.username)\n except (psutil.NoSuchProcess, psutil.AccessDenied, KeyError):\n return None", "docstring": "Returns the username of a Process instance.\n\n It's backward compatible with < 2.0 versions of psutil." }, { "code": "def _switch_partition() -> RootPartitions:\n res = subprocess.check_output(['ot-switch-partitions'])\n for line in res.split(b'\\n'):\n matches = re.match(\n b'Current boot partition: ([23]), setting to ([23])',\n line)\n if matches:\n return {b'2': RootPartitions.TWO,\n b'3': RootPartitions.THREE}[matches.group(2)]\n else:\n raise RuntimeError(f'Bad output from ot-switch-partitions: {res}')", "docstring": "Switch the active boot partition using the switch script" }, { "code": "def ver_cmp(ver1, ver2):\n return cmp(\n pkg_resources.parse_version(ver1), pkg_resources.parse_version(ver2)\n )", "docstring": "Compare lago versions\n\n Args:\n ver1(str): version string\n ver2(str): version string\n\n Returns:\n Return negative if ver1ver2." }, { "code": "def get_min_instability(self, min_voltage=None, max_voltage=None):\n data = []\n for pair in self._select_in_voltage_range(min_voltage, max_voltage):\n if pair.decomp_e_charge is not None:\n data.append(pair.decomp_e_charge)\n if pair.decomp_e_discharge is not None:\n data.append(pair.decomp_e_discharge)\n return min(data) if len(data) > 0 else None", "docstring": "The minimum instability along a path for a specific voltage range.\n\n Args:\n min_voltage: The minimum allowable voltage.\n max_voltage: The maximum allowable voltage.\n\n Returns:\n Minimum decomposition energy of all compounds along the insertion\n path (a subset of the path can be chosen by the optional arguments)" }, { "code": "def hash(self):\n return hash(\n self._shape + (\n self.tilewidth, self.tilelength, self.tiledepth,\n self.bitspersample, self.fillorder, self.predictor,\n self.extrasamples, self.photometric, self.compression,\n self.planarconfig))", "docstring": "Return checksum to identify pages in same series." }, { "code": "def _deserialize(cls, key, value, fields):\n converter = cls._get_converter_for_field(key, None, fields)\n return converter.deserialize(value)", "docstring": "Marshal incoming data into Python objects." }, { "code": "def calc_qpout_v1(self):\n der = self.parameters.derived.fastaccess\n flu = self.sequences.fluxes.fastaccess\n for idx in range(der.nmb):\n flu.qpout[idx] = flu.qma[idx]+flu.qar[idx]", "docstring": "Calculate the ARMA results for the different response functions.\n\n Required derived parameter:\n |Nmb|\n\n Required flux sequences:\n |QMA|\n |QAR|\n\n Calculated flux sequence:\n |QPOut|\n\n Examples:\n\n Initialize an arma model with three different response functions:\n\n >>> from hydpy.models.arma import *\n >>> parameterstep()\n >>> derived.nmb(3)\n >>> fluxes.qma.shape = 3\n >>> fluxes.qar.shape = 3\n >>> fluxes.qpout.shape = 3\n\n Define the output values of the MA and of the AR processes\n associated with the three response functions and apply\n method |calc_qpout_v1|:\n\n >>> fluxes.qar = 4.0, 5.0, 6.0\n >>> fluxes.qma = 1.0, 2.0, 3.0\n >>> model.calc_qpout_v1()\n >>> fluxes.qpout\n qpout(5.0, 7.0, 9.0)" }, { "code": "def parse_kwargs(kwargs):\n d = defaultdict(list)\n for k, v in ((k.lstrip('-'), v) for k,v in (a.split('=') for a in kwargs)):\n d[k].append(v)\n ret = {}\n for k, v in d.items():\n if len(v) == 1 and type(v) is list:\n ret[k] = v[0]\n else:\n ret[k] = v\n return ret", "docstring": "Convert a list of kwargs into a dictionary. Duplicates of the same keyword\n get added to an list within the dictionary.\n\n >>> parse_kwargs(['--var1=1', '--var2=2', '--var1=3']\n {'var1': [1, 3], 'var2': 2}" }, { "code": "def get_script_property(value, is_bytes=False):\n obj = unidata.ascii_scripts if is_bytes else unidata.unicode_scripts\n if value.startswith('^'):\n negated = value[1:]\n value = '^' + unidata.unicode_alias['script'].get(negated, negated)\n else:\n value = unidata.unicode_alias['script'].get(value, value)\n return obj[value]", "docstring": "Get `SC` property." }, { "code": "def connect(self, region, **kw_params):\n self.ec2 = boto.ec2.connect_to_region(region, **kw_params)\n if not self.ec2:\n raise EC2ManagerException('Unable to connect to region \"%s\"' % region)\n self.remote_images.clear()\n if self.images and any(('image_name' in img and 'image_id' not in img) for img in self.images.values()):\n for img in self.images.values():\n if 'image_name' in img and 'image_id' not in img:\n img['image_id'] = self.resolve_image_name(img.pop('image_name'))", "docstring": "Connect to a EC2.\n\n :param region: The name of the region to connect to.\n :type region: str\n :param kw_params:\n :type kw_params: dict" }, { "code": "def get_record_types(self):\n from ..type.objects import TypeList\n type_list = []\n for type_idstr in self._supported_record_type_ids:\n type_list.append(Type(**self._record_type_data_sets[Id(type_idstr).get_identifier()]))\n return TypeList(type_list)", "docstring": "Gets the record types available in this object.\n\n A record ``Type`` explicitly indicates the specification of an\n interface to the record. A record may or may not inherit other\n record interfaces through interface inheritance in which case\n support of a record type may not be explicit in the returned\n list. Interoperability with the typed interface to this object\n should be performed through ``hasRecordType()``.\n\n return: (osid.type.TypeList) - the record types available\n *compliance: mandatory -- This method must be implemented.*" }, { "code": "def default(self):\n output = ensure_unicode(self.git.log(\n '-1',\n '-p',\n '--no-color',\n '--format=%s',\n ).stdout)\n lines = output.splitlines()\n return u'\\n'.join(\n itertools.chain(\n lines[:1],\n itertools.islice(\n itertools.dropwhile(\n lambda x: not x.startswith('+++'),\n lines[1:],\n ),\n 1,\n None,\n ),\n )\n )", "docstring": "Return last changes in truncated unified diff format" }, { "code": "def defaults():\n return dict((str(k), str(v)) for k, v in cma_default_options.items())", "docstring": "return a dictionary with default option values and description" }, { "code": "def add(self, entity):\n characteristic = self.extract_traits(entity)\n if not characteristic.traits:\n return\n if characteristic.is_matching:\n self.add_match(entity, *characteristic.traits)\n else:\n self.add_mismatch(entity, *characteristic.traits)", "docstring": "Add entity to index.\n\n :param object entity: single object to add to box's index" }, { "code": "def zip_dict(a: Dict[str, A], b: Dict[str, B]) \\\n -> Dict[str, Tuple[Optional[A], Optional[B]]]:\n return {key: (a.get(key), b.get(key)) for key in a.keys() | b.keys()}", "docstring": "Combine the values within two dictionaries by key.\n\n :param a: The first dictionary.\n :param b: The second dictionary.\n :return: A dictionary containing all keys that appear in the union of a and\n b. Values are pairs where the first part is a's value for the key,\n and right second part b's value." }, { "code": "def get_commits(self, since_sha=None):\n assert self.tempdir\n cmd = ['git', 'log', '--first-parent', '--reverse', COMMIT_FORMAT]\n if since_sha:\n commits = [self.get_commit(since_sha)]\n cmd.append('{}..HEAD'.format(since_sha))\n else:\n commits = []\n cmd.append('HEAD')\n output = cmd_output(*cmd, cwd=self.tempdir)\n for sha, date in chunk_iter(output.splitlines(), 2):\n commits.append(Commit(sha, int(date)))\n return commits", "docstring": "Returns a list of Commit objects.\n\n Args:\n since_sha - (optional) A sha to search from" }, { "code": "def set_ard_time(self, us):\n t = int((us / 250) - 1)\n if (t < 0):\n t = 0\n if (t > 0xF):\n t = 0xF\n _send_vendor_setup(self.handle, SET_RADIO_ARD, t, 0, ())", "docstring": "Set the ACK retry delay for radio communication" }, { "code": "def _default(self, obj):\n return obj.__dict__ if isinstance(obj, JsonObj) else json.JSONDecoder().decode(obj)", "docstring": "return a serialized version of obj or raise a TypeError\n\n :param obj:\n :return: Serialized version of obj" }, { "code": "def request_login(blink, url, username, password, is_retry=False):\n headers = {\n 'Host': DEFAULT_URL,\n 'Content-Type': 'application/json'\n }\n data = dumps({\n 'email': username,\n 'password': password,\n 'client_specifier': 'iPhone 9.2 | 2.2 | 222'\n })\n return http_req(blink, url=url, headers=headers, data=data,\n json_resp=False, reqtype='post', is_retry=is_retry)", "docstring": "Login request.\n\n :param blink: Blink instance.\n :param url: Login url.\n :param username: Blink username.\n :param password: Blink password.\n :param is_retry: Is this part of a re-authorization attempt?" }, { "code": "def get_as_float_with_default(self, index, default_value):\n value = self[index]\n return FloatConverter.to_float_with_default(value, default_value)", "docstring": "Converts array element into a float or returns default value if conversion is not possible.\n\n :param index: an index of element to get.\n\n :param default_value: the default value\n\n :return: float value ot the element or default value if conversion is not supported." }, { "code": "def _auto_commit(self):\n if not self.auto_commit or self.auto_commit_every_n is None:\n return\n if self.count_since_commit >= self.auto_commit_every_n:\n self.commit()", "docstring": "Check if we have to commit based on number of messages and commit" }, { "code": "def updateData(self,exten,data):\n _extnum=self._interpretExten(exten)\n fimg = fileutil.openImage(self._filename, mode='update', memmap=False)\n fimg[_extnum].data = data\n fimg[_extnum].header = self._image[_extnum].header\n fimg.close()", "docstring": "Write out updated data and header to\n the original input file for this object." }, { "code": "def languages_column(self, obj):\n languages = self.get_available_languages(obj)\n return '{0}'.format(\n \" \".join(languages)\n )", "docstring": "Adds languages columns." }, { "code": "def ip(self):\n if not self._ip:\n if 'ip' in self.config:\n ip = self.config['ip']\n else:\n ip = self.protocol.transport.get_extra_info('sockname')[0]\n ip = ip_address(ip)\n if ip.version == 4:\n self._ip = ip\n else:\n response = urlopen('http://ipv4.icanhazip.com/')\n ip = response.read().strip().decode()\n ip = ip_address(ip)\n self._ip = ip\n return self._ip", "docstring": "return bot's ip as an ``ip_address`` object" }, { "code": "def dicomdir_info(dirpath, *args, **kwargs):\n dr = DicomReader(dirpath=dirpath, *args, **kwargs)\n info = dr.dicomdirectory.get_stats_of_series_in_dir()\n return info", "docstring": "Get information about series in dir" }, { "code": "def checkout(self, *args, **kwargs):\n self._call_helper(\"Checking out\", self.real.checkout, *args, **kwargs)", "docstring": "This function checks out source code." }, { "code": "def get_session_key(self, username, password_hash):\n params = {\"username\": username, \"authToken\": md5(username + password_hash)}\n request = _Request(self.network, \"auth.getMobileSession\", params)\n request.sign_it()\n doc = request.execute()\n return _extract(doc, \"key\")", "docstring": "Retrieve a session key with a username and a md5 hash of the user's\n password." }, { "code": "def set_level(level):\n Logger.level = level\n for logger in Logger.loggers.values():\n logger.setLevel(level)", "docstring": "Set level of logging for all loggers.\n\n Args:\n level (int): level of logging." }, { "code": "def pack_value(self, val):\n if isinstance(val, bytes):\n val = list(iterbytes(val))\n slen = len(val)\n if self.pad:\n pad = b'\\0\\0' * (slen % 2)\n else:\n pad = b''\n return struct.pack('>' + 'H' * slen, *val) + pad, slen, None", "docstring": "Convert 8-byte string into 16-byte list" }, { "code": "def _delete_partition(self, tenant_id, tenant_name):\n self.dcnm_obj.delete_partition(tenant_name, fw_const.SERV_PART_NAME)", "docstring": "Function to delete a service partition." }, { "code": "def _token_extensions(self):\n token_provider = self.config['sasl_oauth_token_provider']\n if callable(getattr(token_provider, \"extensions\", None)) and len(token_provider.extensions()) > 0:\n msg = \"\\x01\".join([\"{}={}\".format(k, v) for k, v in token_provider.extensions().items()])\n return \"\\x01\" + msg\n else:\n return \"\"", "docstring": "Return a string representation of the OPTIONAL key-value pairs that can be sent with an OAUTHBEARER\n initial request." }, { "code": "def _build_indexes(self):\n if isinstance(self._data, list):\n for d in self._data:\n if not isinstance(d, dict):\n err = u'Cannot build index for non Dict type.'\n self._tcex.log.error(err)\n raise RuntimeError(err)\n data_obj = DataObj(d)\n self._master_index.setdefault(id(data_obj), data_obj)\n for key, value in d.items():\n if not isinstance(value, (float, int, str)):\n self._tcex.log.debug(u'Can only build index String Types.')\n continue\n self._indexes.setdefault(key, {}).setdefault(value, []).append(data_obj)\n else:\n err = u'Only *List* data type is currently supported'\n self._tcex.log.error(err)\n raise RuntimeError(err)", "docstring": "Build indexes from data for fast filtering of data.\n\n Building indexes of data when possible. This is only supported when dealing with a\n List of Dictionaries with String values." }, { "code": "def show_grid(self, **kwargs):\n kwargs.setdefault('grid', 'back')\n kwargs.setdefault('location', 'outer')\n kwargs.setdefault('ticks', 'both')\n return self.show_bounds(**kwargs)", "docstring": "A wrapped implementation of ``show_bounds`` to change default\n behaviour to use gridlines and showing the axes labels on the outer\n edges. This is intended to be silimar to ``matplotlib``'s ``grid``\n function." }, { "code": "def get_model(with_pipeline=False):\n model = NeuralNetClassifier(MLPClassifier)\n if with_pipeline:\n model = Pipeline([\n ('scale', FeatureUnion([\n ('minmax', MinMaxScaler()),\n ('normalize', Normalizer()),\n ])),\n ('select', SelectKBest(k=N_FEATURES)),\n ('net', model),\n ])\n return model", "docstring": "Get a multi-layer perceptron model.\n\n Optionally, put it in a pipeline that scales the data." }, { "code": "def print(self):\n print(\n '{dim}Identifier:{none} {cyan}{identifier}{none}\\n'\n '{dim}Name:{none} {name}\\n'\n '{dim}Description:{none}\\n{description}'.format(\n dim=Style.DIM,\n cyan=Fore.CYAN,\n none=Style.RESET_ALL,\n identifier=self.identifier,\n name=self.name,\n description=pretty_description(self.description, indent=2)\n )\n )\n if hasattr(self, 'argument_list') and self.argument_list:\n print('{dim}Arguments:{none}'.format(\n dim=Style.DIM, none=Style.RESET_ALL))\n for argument in self.argument_list:\n argument.print(indent=2)", "docstring": "Print self." }, { "code": "def desaturate(self, level):\n h, s, l = self.__hsl\n return Color((h, max(s - level, 0), l), 'hsl', self.__a, self.__wref)", "docstring": "Create a new instance based on this one but less saturated.\n\n Parameters:\n :level:\n The amount by which the color should be desaturated to produce\n the new one [0...1].\n\n Returns:\n A grapefruit.Color instance.\n\n >>> Color.from_hsl(30, 0.5, 0.5).desaturate(0.25)\n Color(0.625, 0.5, 0.375, 1.0)\n >>> Color.from_hsl(30, 0.5, 0.5).desaturate(0.25).hsl\n (30.0, 0.25, 0.5)" }, { "code": "def from_json(cls, json_data):\n data = json.loads(json_data)\n result = cls(data)\n if hasattr(result, \"_from_json\"):\n result._from_json()\n return result", "docstring": "Tries to convert a JSON representation to an object of the same\n type as self\n\n A class can provide a _fromJSON implementation in order to do specific\n type checking or other custom implementation details. This method\n will throw a ValueError for invalid JSON, a TypeError for\n improperly constructed, but valid JSON, and any custom errors\n that can be be propagated from class constructors.\n\n :param json_data: The JSON string to convert\n :type json_data: str | unicode\n\n :raises: TypeError, ValueError, LanguageMapInitError" }, { "code": "def _udp_transact(self, payload, handler, *args,\n broadcast=False, timeout=TIMEOUT):\n if self.host in _BUFFER:\n del _BUFFER[self.host]\n host = self.host\n if broadcast:\n host = '255.255.255.255'\n retval = None\n for _ in range(RETRIES):\n _SOCKET.sendto(bytearray(payload), (host, PORT))\n start = time.time()\n while time.time() < start + timeout:\n data = _BUFFER.get(self.host, None)\n if data:\n retval = handler(data, *args)\n if retval:\n return retval", "docstring": "Complete a UDP transaction.\n\n UDP is stateless and not guaranteed, so we have to\n take some mitigation steps:\n - Send payload multiple times.\n - Wait for awhile to receive response.\n\n :param payload: Payload to send.\n :param handler: Response handler.\n :param args: Arguments to pass to response handler.\n :param broadcast: Send a broadcast instead.\n :param timeout: Timeout in seconds." }, { "code": "def match_sr(self, svc_ref, cid=None):\n with self.__lock:\n our_sr = self.get_reference()\n if our_sr is None:\n return False\n sr_compare = our_sr == svc_ref\n if cid is None:\n return sr_compare\n our_cid = self.get_export_container_id()\n if our_cid is None:\n return False\n return sr_compare and our_cid == cid", "docstring": "Checks if this export registration matches the given service reference\n\n :param svc_ref: A service reference\n :param cid: A container ID\n :return: True if the service matches this export registration" }, { "code": "def _delete_masked_points(*arrs):\n if any(hasattr(a, 'mask') for a in arrs):\n keep = ~functools.reduce(np.logical_or, (np.ma.getmaskarray(a) for a in arrs))\n return tuple(ma.asarray(a[keep]) for a in arrs)\n else:\n return arrs", "docstring": "Delete masked points from arrays.\n\n Takes arrays and removes masked points to help with calculations and plotting.\n\n Parameters\n ----------\n arrs : one or more array-like\n source arrays\n\n Returns\n -------\n arrs : one or more array-like\n arrays with masked elements removed" }, { "code": "def filter_ignoring_case(self, pattern):\n return self.filter(re.compile(pattern, re.I))", "docstring": "Like ``filter`` but case-insensitive.\n\n Expects a regular expression string without the surrounding ``/``\n characters.\n\n >>> see().filter('^my', ignore_case=True)\n MyClass()" }, { "code": "def update(name, maximum_version=None, required_version=None):\n flags = [('Name', name)]\n if maximum_version is not None:\n flags.append(('MaximumVersion', maximum_version))\n if required_version is not None:\n flags.append(('RequiredVersion', required_version))\n params = ''\n for flag, value in flags:\n params += '-{0} {1} '.format(flag, value)\n cmd = 'Update-Module {0} -Force'.format(params)\n _pshell(cmd)\n return name in list_modules()", "docstring": "Update a PowerShell module to a specific version, or the newest\n\n :param name: Name of a Powershell module\n :type name: ``str``\n\n :param maximum_version: The maximum version to install, e.g. 1.23.2\n :type maximum_version: ``str``\n\n :param required_version: Install a specific version\n :type required_version: ``str``\n\n CLI Example:\n\n .. code-block:: bash\n\n salt 'win01' psget.update PowerPlan" }, { "code": "def add_to_obj(obj, dictionary, objs=None, exceptions=None, verbose=0):\n if exceptions is None:\n exceptions = []\n for item in dictionary:\n if item in exceptions:\n continue\n if dictionary[item] is not None:\n if verbose:\n print(\"process: \", item, dictionary[item])\n key, value = get_key_value(dictionary[item], objs, key=item)\n if verbose:\n print(\"assign: \", key, value)\n try:\n setattr(obj, key, value)\n except AttributeError:\n raise AttributeError(\"Can't set {0}={1} on object: {2}\".format(key, value, obj))", "docstring": "Cycles through a dictionary and adds the key-value pairs to an object.\n\n :param obj:\n :param dictionary:\n :param exceptions:\n :param verbose:\n :return:" }, { "code": "def imagetransformerpp_base_14l_8h_big_uncond_dr03_dan_p():\n hparams = imagetransformerpp_base_12l_8h_big_uncond_dr03_dan_l()\n hparams.num_decoder_layers = 14\n hparams.batch_size = 8\n hparams.layer_prepostprocess_dropout = 0.2\n return hparams", "docstring": "Gets to 2.92 in just under 4 days on 8 p100s." }, { "code": "def make_field(self, **kwargs):\n kwargs['required'] = False\n kwargs['allow_null'] = True\n return self.field_class(**kwargs)", "docstring": "create serializer field" }, { "code": "def version():\n cmd = 'lvm version'\n out = __salt__['cmd.run'](cmd).splitlines()\n ret = out[0].split(': ')\n return ret[1].strip()", "docstring": "Return LVM version from lvm version\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' lvm.version" }, { "code": "def get_formatted_string(self, input_string):\n if isinstance(input_string, str):\n try:\n return self.get_processed_string(input_string)\n except KeyNotInContextError as err:\n raise KeyNotInContextError(\n f'Unable to format \\'{input_string}\\' because {err}'\n ) from err\n elif isinstance(input_string, SpecialTagDirective):\n return input_string.get_value(self)\n else:\n raise TypeError(f\"can only format on strings. {input_string} is a \"\n f\"{type(input_string)} instead.\")", "docstring": "Return formatted value for input_string.\n\n get_formatted gets a context[key] value.\n get_formatted_string is for any arbitrary string that is not in the\n context.\n\n Only valid if input_string is a type string.\n Return a string interpolated from the context dictionary.\n\n If input_string='Piping {key1} the {key2} wild'\n And context={'key1': 'down', 'key2': 'valleys', 'key3': 'value3'}\n\n Then this will return string: \"Piping down the valleys wild\"\n\n Args:\n input_string: string to parse for substitutions.\n\n Returns:\n Formatted string.\n\n Raises:\n KeyNotInContextError: context[key] has {somekey} where somekey does\n not exist in context dictionary.\n TypeError: Attempt operation on a non-string type." }, { "code": "def setupTable_vmtx(self):\n if \"vmtx\" not in self.tables:\n return\n self.otf[\"vmtx\"] = vmtx = newTable(\"vmtx\")\n vmtx.metrics = {}\n for glyphName, glyph in self.allGlyphs.items():\n height = otRound(glyph.height)\n if height < 0:\n raise ValueError(\n \"The height should not be negative: '%s'\" % (glyphName))\n verticalOrigin = _getVerticalOrigin(self.otf, glyph)\n bounds = self.glyphBoundingBoxes[glyphName]\n top = bounds.yMax if bounds else 0\n vmtx[glyphName] = (height, verticalOrigin - top)", "docstring": "Make the vmtx table.\n\n **This should not be called externally.** Subclasses\n may override or supplement this method to handle the\n table creation in a different way if desired." }, { "code": "def get_message(self):\n result = ''\n if self._data_struct is not None:\n result = self._data_struct[KEY_MESSAGE]\n return result", "docstring": "Return the message embedded in the JSON error response body,\n or an empty string if the JSON couldn't be parsed." }, { "code": "def list(self):\n databases = []\n for dbname in os.listdir(self.path):\n databases.append(dbname)\n return list(reversed(sorted(databases)))", "docstring": "List all the databases on the given path.\n\n :return:" }, { "code": "def WriteFromFD(self, src_fd, arcname=None, compress_type=None, st=None):\n yield self.WriteFileHeader(\n arcname=arcname, compress_type=compress_type, st=st)\n while 1:\n buf = src_fd.read(1024 * 1024)\n if not buf:\n break\n yield self.WriteFileChunk(buf)\n yield self.WriteFileFooter()", "docstring": "Write a zip member from a file like object.\n\n Args:\n src_fd: A file like object, must support seek(), tell(), read().\n arcname: The name in the archive this should take.\n compress_type: Compression type (zipfile.ZIP_DEFLATED, or ZIP_STORED)\n st: An optional stat object to be used for setting headers.\n\n Raises:\n ArchiveAlreadyClosedError: If the zip if already closed.\n\n Yields:\n Chunks of binary data." }, { "code": "def get_allowed_methods(self, callback):\n if hasattr(callback, 'actions'):\n return [method.upper() for method in callback.actions.keys() if method != 'head']\n return [\n method for method in\n callback.cls().allowed_methods if method not in ('OPTIONS', 'HEAD')\n ]", "docstring": "Return a list of the valid HTTP methods for this endpoint." }, { "code": "def pub(self, topic, message):\n return self.send(' '.join((constants.PUB, topic)), message)", "docstring": "Publish to a topic" }, { "code": "def times(x, y):\n def decorator(fn):\n def wrapped(*args, **kwargs):\n n = random.randint(x, y)\n for z in range(1, n):\n fn(*args, **kwargs)\n return wrapped\n return decorator", "docstring": "Do something a random amount of times\n between x & y" }, { "code": "def recursive_apply(inval, func):\n if isinstance(inval, dict):\n return {k: recursive_apply(v, func) for k, v in inval.items()}\n elif isinstance(inval, list):\n return [recursive_apply(v, func) for v in inval]\n else:\n return func(inval)", "docstring": "Recursively apply a function to all levels of nested iterables\n\n :param inval: the object to run the function on\n :param func: the function that will be run on the inval" }, { "code": "def get_account(self, account, use_sis_id=False, **kwargs):\n if use_sis_id:\n account_id = account\n uri_str = 'accounts/sis_account_id:{}'\n else:\n account_id = obj_or_id(account, \"account\", (Account,))\n uri_str = 'accounts/{}'\n response = self.__requester.request(\n 'GET',\n uri_str.format(account_id),\n _kwargs=combine_kwargs(**kwargs)\n )\n return Account(self.__requester, response.json())", "docstring": "Retrieve information on an individual account.\n\n :calls: `GET /api/v1/accounts/:id \\\n `_\n\n :param account: The object or ID of the account to retrieve.\n :type account: int, str or :class:`canvasapi.account.Account`\n :param use_sis_id: Whether or not account_id is an sis ID.\n Defaults to `False`.\n :type use_sis_id: bool\n\n :rtype: :class:`canvasapi.account.Account`" }, { "code": "def validate(self):\n validate_url = \"https://api.pushover.net/1/users/validate.json\"\n payload = {\n 'token': self.api_token,\n 'user': self.user,\n }\n return requests.post(validate_url, data=payload)", "docstring": "Validate the user and token, returns the Requests response." }, { "code": "async def close(self, code: int = 1000, reason: str = \"\") -> None:\n try:\n await asyncio.wait_for(\n self.write_close_frame(serialize_close(code, reason)),\n self.close_timeout,\n loop=self.loop,\n )\n except asyncio.TimeoutError:\n self.fail_connection()\n try:\n await asyncio.wait_for(\n self.transfer_data_task, self.close_timeout, loop=self.loop\n )\n except (asyncio.TimeoutError, asyncio.CancelledError):\n pass\n await asyncio.shield(self.close_connection_task)", "docstring": "This coroutine performs the closing handshake.\n\n It waits for the other end to complete the handshake and for the TCP\n connection to terminate. As a consequence, there's no need to await\n :meth:`wait_closed`; :meth:`close` already does it.\n\n :meth:`close` is idempotent: it doesn't do anything once the\n connection is closed.\n\n It's safe to wrap this coroutine in :func:`~asyncio.create_task` since\n errors during connection termination aren't particularly useful.\n\n ``code`` must be an :class:`int` and ``reason`` a :class:`str`." }, { "code": "def lrange(self, name, start, stop):\n with self.pipe as pipe:\n f = Future()\n res = pipe.lrange(self.redis_key(name), start, stop)\n def cb():\n f.set([self.valueparse.decode(v) for v in res.result])\n pipe.on_execute(cb)\n return f", "docstring": "Returns a range of items.\n\n :param name: str the name of the redis key\n :param start: integer representing the start index of the range\n :param stop: integer representing the size of the list.\n :return: Future()" }, { "code": "def labels(data, label_column, color=None, font_name=FONT_NAME, \n font_size=14, anchor_x='left', anchor_y='top'):\n from geoplotlib.layers import LabelsLayer\n _global_config.layers.append(LabelsLayer(data, label_column, color, font_name, \n font_size, anchor_x, anchor_y))", "docstring": "Draw a text label for each sample\n\n :param data: data access object\n :param label_column: column in the data access object where the labels text is stored\n :param color: color\n :param font_name: font name\n :param font_size: font size\n :param anchor_x: anchor x\n :param anchor_y: anchor y" }, { "code": "def _start_primary(self):\n self.em.start()\n self.em.set_secondary_state(_STATE_RUNNING)\n self._set_shared_instances()", "docstring": "Start as the primary" }, { "code": "def populate_items(self, request):\n self._items = self.get_items(request)\n return self.items", "docstring": "populate and returns filtered items" }, { "code": "def parent_tags(self):\n tags = set()\n for addr in self._addresses:\n if addr.attr == 'text':\n tags.add(addr.element.tag)\n tags.update(el.tag for el in addr.element.iterancestors())\n tags.discard(HTMLFragment._root_tag)\n return frozenset(tags)", "docstring": "Provides tags of all parent HTML elements." }, { "code": "def prepare(self, data):\n result = {}\n if not self.fields:\n return data\n for fieldname, lookup in self.fields.items():\n if isinstance(lookup, SubPreparer):\n result[fieldname] = lookup.prepare(data)\n else:\n result[fieldname] = self.lookup_data(lookup, data)\n return result", "docstring": "Handles transforming the provided data into the fielded data that should\n be exposed to the end user.\n\n Uses the ``lookup_data`` method to traverse dotted paths.\n\n Returns a dictionary of data as the response." }, { "code": "def _spacingx(node, max_dims, xoffset, xspace):\n x_spacing = _n_terminations(node) * xspace\n if x_spacing > max_dims[0]:\n max_dims[0] = x_spacing\n return xoffset - x_spacing / 2.", "docstring": "Determine the spacing of the current node depending on the number\n of the leaves of the tree" }, { "code": "def get_networks_by_name(self, name: str) -> List[Network]:\n return self.session.query(Network).filter(Network.name.like(name)).all()", "docstring": "Get all networks with the given name. Useful for getting all versions of a given network." }, { "code": "def plot_vyx(self, colorbar=True, cb_orientation='vertical',\n cb_label=None, ax=None, show=True, fname=None, **kwargs):\n if cb_label is None:\n cb_label = self._vyx_label\n if ax is None:\n fig, axes = self.vyx.plot(colorbar=colorbar,\n cb_orientation=cb_orientation,\n cb_label=cb_label, show=False, **kwargs)\n if show:\n fig.show()\n if fname is not None:\n fig.savefig(fname)\n return fig, axes\n else:\n self.vyx.plot(colorbar=colorbar, cb_orientation=cb_orientation,\n cb_label=cb_label, ax=ax, **kwargs)", "docstring": "Plot the Vyx component of the tensor.\n\n Usage\n -----\n x.plot_vyx([tick_interval, xlabel, ylabel, ax, colorbar,\n cb_orientation, cb_label, show, fname])\n\n Parameters\n ----------\n tick_interval : list or tuple, optional, default = [30, 30]\n Intervals to use when plotting the x and y ticks. If set to None,\n ticks will not be plotted.\n xlabel : str, optional, default = 'longitude'\n Label for the longitude axis.\n ylabel : str, optional, default = 'latitude'\n Label for the latitude axis.\n ax : matplotlib axes object, optional, default = None\n A single matplotlib axes object where the plot will appear.\n colorbar : bool, optional, default = True\n If True, plot a colorbar.\n cb_orientation : str, optional, default = 'vertical'\n Orientation of the colorbar: either 'vertical' or 'horizontal'.\n cb_label : str, optional, default = '$V_{yx}$'\n Text label for the colorbar.\n show : bool, optional, default = True\n If True, plot the image to the screen.\n fname : str, optional, default = None\n If present, and if axes is not specified, save the image to the\n specified file.\n kwargs : optional\n Keyword arguements that will be sent to the SHGrid.plot()\n and plt.imshow() methods." }, { "code": "def _get_variable(vid, variables):\n if isinstance(vid, six.string_types):\n vid = get_base_id(vid)\n else:\n vid = _get_string_vid(vid)\n for v in variables:\n if vid == get_base_id(v[\"id\"]):\n return copy.deepcopy(v)\n raise ValueError(\"Did not find variable %s in \\n%s\" % (vid, pprint.pformat(variables)))", "docstring": "Retrieve an input variable from our existing pool of options." }, { "code": "def can_handle(self, text: str) -> bool:\n try:\n changelogs = self.split_changelogs(text)\n if not changelogs:\n return False\n for changelog in changelogs:\n _header, _changes = self.split_changelog(changelog)\n if not any((_header, _changes)):\n return False\n header = self.parse_header(_header)\n changes = self.parse_changes(_changes)\n if not any((header, changes)):\n return False\n except Exception:\n return False\n else:\n return True", "docstring": "Check whether this parser can parse the text" }, { "code": "def parse(self, s):\n return datetime.datetime.strptime(s, self.date_format).date()", "docstring": "Parses a date string formatted like ``YYYY-MM-DD``." }, { "code": "def configure_for_kerberos(self, datanode_transceiver_port=None,\n datanode_web_port=None):\n args = dict()\n if datanode_transceiver_port:\n args['datanodeTransceiverPort'] = datanode_transceiver_port\n if datanode_web_port:\n args['datanodeWebPort'] = datanode_web_port\n return self._cmd('configureForKerberos', data=args, api_version=11)", "docstring": "Command to configure the cluster to use Kerberos for authentication.\n\n This command will configure all relevant services on a cluster for\n Kerberos usage. This command will trigger a GenerateCredentials command\n to create Kerberos keytabs for all roles in the cluster.\n\n @param datanode_transceiver_port: The HDFS DataNode transceiver port to use.\n This will be applied to all DataNode role configuration groups. If\n not specified, this will default to 1004.\n @param datanode_web_port: The HDFS DataNode web port to use. This will be\n applied to all DataNode role configuration groups. If not specified,\n this will default to 1006.\n @return: Reference to the submitted command.\n @since: API v11" }, { "code": "def _update_entry(entry, status, directives):\n for directive, state in six.iteritems(directives):\n if directive == 'delete_others':\n status['delete_others'] = state\n continue\n for attr, vals in six.iteritems(state):\n status['mentioned_attributes'].add(attr)\n vals = _toset(vals)\n if directive == 'default':\n if vals and (attr not in entry or not entry[attr]):\n entry[attr] = vals\n elif directive == 'add':\n vals.update(entry.get(attr, ()))\n if vals:\n entry[attr] = vals\n elif directive == 'delete':\n existing_vals = entry.pop(attr, OrderedSet())\n if vals:\n existing_vals -= vals\n if existing_vals:\n entry[attr] = existing_vals\n elif directive == 'replace':\n entry.pop(attr, None)\n if vals:\n entry[attr] = vals\n else:\n raise ValueError('unknown directive: ' + directive)", "docstring": "Update an entry's attributes using the provided directives\n\n :param entry:\n A dict mapping each attribute name to a set of its values\n :param status:\n A dict holding cross-invocation status (whether delete_others\n is True or not, and the set of mentioned attributes)\n :param directives:\n A dict mapping directive types to directive-specific state" }, { "code": "def _get_value(self):\n x, y = self._point.x, self._point.y\n self._px, self._py = self._item_point.canvas.get_matrix_i2i(self._item_point,\n self._item_target).transform_point(x, y)\n return self._px, self._py", "docstring": "Return two delegating variables. Each variable should contain\n a value attribute with the real value." }, { "code": "def configure_arrays(self):\n self.science = self.hdulist['sci', 1].data\n self.err = self.hdulist['err', 1].data\n self.dq = self.hdulist['dq', 1].data\n if (self.ampstring == 'ABCD'):\n self.science = np.concatenate(\n (self.science, self.hdulist['sci', 2].data[::-1, :]), axis=1)\n self.err = np.concatenate(\n (self.err, self.hdulist['err', 2].data[::-1, :]), axis=1)\n self.dq = np.concatenate(\n (self.dq, self.hdulist['dq', 2].data[::-1, :]), axis=1)\n self.ingest_dark()\n self.ingest_flash()\n self.ingest_flatfield()", "docstring": "Get the SCI and ERR data." }, { "code": "def cache_key(*args, **kwargs):\n key = \"\"\n for arg in args:\n if callable(arg):\n key += \":%s\" % repr(arg)\n else:\n key += \":%s\" % str(arg)\n return key", "docstring": "Base method for computing the cache key with respect to the given\n arguments." }, { "code": "def badge(pipeline_id):\n if not pipeline_id.startswith('./'):\n pipeline_id = './' + pipeline_id\n pipeline_status = status.get(pipeline_id)\n status_color = 'lightgray'\n if pipeline_status.pipeline_details:\n status_text = pipeline_status.state().lower()\n last_execution = pipeline_status.get_last_execution()\n success = last_execution.success if last_execution else None\n if success is True:\n stats = last_execution.stats if last_execution else None\n record_count = stats.get('count_of_rows')\n if record_count is not None:\n status_text += ' (%d records)' % record_count\n status_color = 'brightgreen'\n elif success is False:\n status_color = 'red'\n else:\n status_text = \"not found\"\n return _make_badge_response('pipeline', status_text, status_color)", "docstring": "An individual pipeline status" }, { "code": "async def sendto(self, data, component):\n active_pair = self._nominated.get(component)\n if active_pair:\n await active_pair.protocol.send_data(data, active_pair.remote_addr)\n else:\n raise ConnectionError('Cannot send data, not connected')", "docstring": "Send a datagram on the specified component.\n\n If the connection is not established, a `ConnectionError` is raised." }, { "code": "def _registerNode(self, nodeAddress, agentId, nodePort=5051):\n executor = self.executors.get(nodeAddress)\n if executor is None or executor.agentId != agentId:\n executor = self.ExecutorInfo(nodeAddress=nodeAddress,\n agentId=agentId,\n nodeInfo=None,\n lastSeen=time.time())\n self.executors[nodeAddress] = executor\n else:\n executor.lastSeen = time.time()\n self.agentsByID[agentId] = nodeAddress\n return executor", "docstring": "Called when we get communication from an agent. Remembers the\n information about the agent by address, and the agent address by agent\n ID." }, { "code": "def pair_hmm_align_unaligned_seqs(seqs, moltype=DNA_cogent, params={}):\n seqs = LoadSeqs(data=seqs, moltype=moltype, aligned=False)\n try:\n s1, s2 = seqs.values()\n except ValueError:\n raise ValueError(\n \"Pairwise aligning of seqs requires exactly two seqs.\")\n try:\n gap_open = params['gap_open']\n except KeyError:\n gap_open = 5\n try:\n gap_extend = params['gap_extend']\n except KeyError:\n gap_extend = 2\n try:\n score_matrix = params['score_matrix']\n except KeyError:\n score_matrix = make_dna_scoring_dict(\n match=1, transition=-1, transversion=-1)\n return local_pairwise(s1, s2, score_matrix, gap_open, gap_extend)", "docstring": "Checks parameters for pairwise alignment, returns alignment.\n\n Code from Greg Caporaso." }, { "code": "async def create(gc: GroupControl, name, slaves):\n click.echo(\"Creating group %s with slaves: %s\" % (name, slaves))\n click.echo(await gc.create(name, slaves))", "docstring": "Create new group" }, { "code": "def _build_toc_node(docname, anchor=\"anchor\", text=\"test text\", bullet=False):\n reference = nodes.reference(\n \"\",\n \"\",\n internal=True,\n refuri=docname,\n anchorname=\"\n *[nodes.Text(text, text)]\n )\n para = addnodes.compact_paragraph(\"\", \"\", reference)\n ret_list = nodes.list_item(\"\", para)\n return nodes.bullet_list(\"\", ret_list) if bullet else ret_list", "docstring": "Create the node structure that Sphinx expects for TOC Tree entries.\n\n The ``bullet`` argument wraps it in a ``nodes.bullet_list``,\n which is how you nest TOC Tree entries." }, { "code": "def _hdparm(args, failhard=True):\n cmd = 'hdparm {0}'.format(args)\n result = __salt__['cmd.run_all'](cmd)\n if result['retcode'] != 0:\n msg = '{0}: {1}'.format(cmd, result['stderr'])\n if failhard:\n raise CommandExecutionError(msg)\n else:\n log.warning(msg)\n return result['stdout']", "docstring": "Execute hdparm\n Fail hard when required\n return output when possible" }, { "code": "def _start_loop(self):\n loop = GObject.MainLoop()\n bus = SystemBus()\n manager = bus.get(\".NetworkManager\")\n manager.onPropertiesChanged = self._vpn_signal_handler\n loop.run()", "docstring": "Starts main event handler loop, run in handler thread t." }, { "code": "def _upload_simple(self, upload_info, _=None):\n upload_result = self._api.upload_simple(\n upload_info.fd,\n upload_info.name,\n folder_key=upload_info.folder_key,\n filedrop_key=upload_info.filedrop_key,\n path=upload_info.path,\n file_size=upload_info.size,\n file_hash=upload_info.hash_info.file,\n action_on_duplicate=upload_info.action_on_duplicate)\n logger.debug(\"upload_result: %s\", upload_result)\n upload_key = upload_result['doupload']['key']\n return self._poll_upload(upload_key, 'upload/simple')", "docstring": "Simple upload and return quickkey\n\n Can be used for small files smaller than UPLOAD_SIMPLE_LIMIT_BYTES\n\n upload_info -- UploadInfo object\n check_result -- ignored" }, { "code": "def batch_get_assets_history(\n self,\n parent,\n content_type,\n read_time_window,\n asset_names=None,\n retry=google.api_core.gapic_v1.method.DEFAULT,\n timeout=google.api_core.gapic_v1.method.DEFAULT,\n metadata=None,\n ):\n if \"batch_get_assets_history\" not in self._inner_api_calls:\n self._inner_api_calls[\n \"batch_get_assets_history\"\n ] = google.api_core.gapic_v1.method.wrap_method(\n self.transport.batch_get_assets_history,\n default_retry=self._method_configs[\"BatchGetAssetsHistory\"].retry,\n default_timeout=self._method_configs[\"BatchGetAssetsHistory\"].timeout,\n client_info=self._client_info,\n )\n request = asset_service_pb2.BatchGetAssetsHistoryRequest(\n parent=parent,\n content_type=content_type,\n read_time_window=read_time_window,\n asset_names=asset_names,\n )\n return self._inner_api_calls[\"batch_get_assets_history\"](\n request, retry=retry, timeout=timeout, metadata=metadata\n )", "docstring": "Batch gets the update history of assets that overlap a time window. For\n RESOURCE content, this API outputs history with asset in both non-delete\n or deleted status. For IAM\\_POLICY content, this API outputs history\n when the asset and its attached IAM POLICY both exist. This can create\n gaps in the output history. If a specified asset does not exist, this\n API returns an INVALID\\_ARGUMENT error.\n\n Example:\n >>> from google.cloud import asset_v1\n >>> from google.cloud.asset_v1 import enums\n >>>\n >>> client = asset_v1.AssetServiceClient()\n >>>\n >>> # TODO: Initialize `parent`:\n >>> parent = ''\n >>>\n >>> # TODO: Initialize `content_type`:\n >>> content_type = enums.ContentType.CONTENT_TYPE_UNSPECIFIED\n >>>\n >>> # TODO: Initialize `read_time_window`:\n >>> read_time_window = {}\n >>>\n >>> response = client.batch_get_assets_history(parent, content_type, read_time_window)\n\n Args:\n parent (str): Required. The relative name of the root asset. It can only be an\n organization number (such as \"organizations/123\"), a project ID (such as\n \"projects/my-project-id\")\", or a project number (such as \"projects/12345\").\n content_type (~google.cloud.asset_v1.types.ContentType): Required. The content type.\n read_time_window (Union[dict, ~google.cloud.asset_v1.types.TimeWindow]): Optional. The time window for the asset history. Both start\\_time and\n end\\_time are optional and if set, it must be after 2018-10-02 UTC. If\n end\\_time is not set, it is default to current timestamp. If start\\_time\n is not set, the snapshot of the assets at end\\_time will be returned.\n The returned results contain all temporal assets whose time window\n overlap with read\\_time\\_window.\n\n If a dict is provided, it must be of the same form as the protobuf\n message :class:`~google.cloud.asset_v1.types.TimeWindow`\n asset_names (list[str]): A list of the full names of the assets. For example:\n ``//compute.googleapis.com/projects/my_project_123/zones/zone1/instances/instance1``.\n See `Resource\n Names `__\n and `Resource Name\n Format `__\n for more info.\n\n The request becomes a no-op if the asset name list is empty, and the max\n size of the asset name list is 100 in one request.\n retry (Optional[google.api_core.retry.Retry]): A retry object used\n to retry requests. If ``None`` is specified, requests will not\n be retried.\n timeout (Optional[float]): The amount of time, in seconds, to wait\n for the request to complete. Note that if ``retry`` is\n specified, the timeout applies to each individual attempt.\n metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata\n that is provided to the method.\n\n Returns:\n A :class:`~google.cloud.asset_v1.types.BatchGetAssetsHistoryResponse` instance.\n\n Raises:\n google.api_core.exceptions.GoogleAPICallError: If the request\n failed for any reason.\n google.api_core.exceptions.RetryError: If the request failed due\n to a retryable error and retry attempts failed.\n ValueError: If the parameters are invalid." }, { "code": "def _convert_template_option(template):\n option = {}\n extraction_method = template.get('extraction_method')\n if extraction_method == 'guess':\n option['guess'] = True\n elif extraction_method == 'lattice':\n option['lattice'] = True\n elif extraction_method == 'stream':\n option['stream'] = True\n option['pages'] = template.get('page')\n option['area'] = [round(template['y1'], 3), round(template['x1'], 3), round(template['y2'], 3), round(template['x2'], 3)]\n return option", "docstring": "Convert Tabula app template to tabula-py option\n\n Args:\n template (dict): Tabula app template\n\n Returns:\n `obj`:dict: tabula-py option" }, { "code": "def autobuild_onlycopy():\n try:\n family = utilities.get_family('module_settings.json')\n autobuild_release(family)\n Alias('release', os.path.join('build', 'output'))\n Default(['release'])\n except unit_test.IOTileException as e:\n print(e.format())\n Exit(1)", "docstring": "Autobuild a project that does not require building firmware, pcb or documentation" }, { "code": "def get_staff(self, gradebook_id, simple=False):\n staff_data = self.get(\n 'staff/{gradebookId}'.format(\n gradebookId=gradebook_id or self.gradebook_id\n ),\n params=None,\n )\n if simple:\n simple_list = []\n unraveled_list = self.unravel_staff(staff_data)\n for member in unraveled_list.__iter__():\n simple_list.append({\n 'accountEmail': member['accountEmail'],\n 'displayName': member['displayName'],\n 'role': member['role'],\n })\n return simple_list\n return staff_data['data']", "docstring": "Get staff list for gradebook.\n\n Get staff list for the gradebook specified. Optionally, return\n a less detailed list by specifying ``simple = True``.\n\n If simple=True, return a list of dictionaries, one dictionary\n for each member. The dictionary contains a member's ``email``,\n ``displayName``, and ``role``. Members with multiple roles will\n appear in the list once for each role.\n\n Args:\n gradebook_id (str): unique identifier for gradebook, i.e. ``2314``\n simple (bool): Return a staff list with less detail. Default\n is ``False``.\n\n Returns:\n\n An example return value is:\n\n .. code-block:: python\n\n {\n u'data': {\n u'COURSE_ADMIN': [\n {\n u'accountEmail': u'benfranklin@mit.edu',\n u'displayName': u'Benjamin Franklin',\n u'editable': False,\n u'email': u'benfranklin@mit.edu',\n u'givenName': u'Benjamin',\n u'middleName': None,\n u'mitId': u'921344431',\n u'nickName': u'Benjamin',\n u'personId': 10710616,\n u'sortableName': u'Franklin, Benjamin',\n u'surname': u'Franklin',\n u'year': None\n },\n ],\n u'COURSE_PROF': [\n {\n u'accountEmail': u'dduck@mit.edu',\n u'displayName': u'Donald Duck',\n u'editable': False,\n u'email': u'dduck@mit.edu',\n u'givenName': u'Donald',\n u'middleName': None,\n u'mitId': u'916144889',\n u'nickName': u'Donald',\n u'personId': 8117160,\n u'sortableName': u'Duck, Donald',\n u'surname': u'Duck',\n u'year': None\n },\n ],\n u'COURSE_TA': [\n {\n u'accountEmail': u'hduck@mit.edu',\n u'displayName': u'Huey Duck',\n u'editable': False,\n u'email': u'hduck@mit.edu',\n u'givenName': u'Huey',\n u'middleName': None,\n u'mitId': u'920445024',\n u'nickName': u'Huey',\n u'personId': 1299059,\n u'sortableName': u'Duck, Huey',\n u'surname': u'Duck',\n u'year': None\n },\n ]\n },\n }" }, { "code": "def get_authors(self, entry):\n try:\n return format_html_join(\n ', ', '{}',\n [(author.get_absolute_url(),\n getattr(author, author.USERNAME_FIELD))\n for author in entry.authors.all()])\n except NoReverseMatch:\n return ', '.join(\n [conditional_escape(getattr(author, author.USERNAME_FIELD))\n for author in entry.authors.all()])", "docstring": "Return the authors in HTML." }, { "code": "def as_text(self, max_rows=0, sep=\" | \"):\n if not max_rows or max_rows > self.num_rows:\n max_rows = self.num_rows\n omitted = max(0, self.num_rows - max_rows)\n labels = self._columns.keys()\n fmts = self._get_column_formatters(max_rows, False)\n rows = [[fmt(label, label=True) for fmt, label in zip(fmts, labels)]]\n for row in itertools.islice(self.rows, max_rows):\n rows.append([f(v, label=False) for v, f in zip(row, fmts)])\n lines = [sep.join(row) for row in rows]\n if omitted:\n lines.append('... ({} rows omitted)'.format(omitted))\n return '\\n'.join([line.rstrip() for line in lines])", "docstring": "Format table as text." }, { "code": "def _estimate_centers_widths(\n self,\n unique_R,\n inds,\n X,\n W,\n init_centers,\n init_widths,\n template_centers,\n template_widths,\n template_centers_mean_cov,\n template_widths_mean_var_reci):\n init_estimate = np.hstack(\n (init_centers.ravel(), init_widths.ravel()))\n data_sigma = 1.0 / math.sqrt(2.0) * np.std(X)\n final_estimate = least_squares(\n self._residual_multivariate,\n init_estimate,\n args=(\n unique_R,\n inds,\n X,\n W,\n template_centers,\n template_widths,\n template_centers_mean_cov,\n template_widths_mean_var_reci,\n data_sigma),\n method=self.nlss_method,\n loss=self.nlss_loss,\n bounds=self.bounds,\n verbose=0,\n x_scale=self.x_scale,\n tr_solver=self.tr_solver)\n return final_estimate.x, final_estimate.cost", "docstring": "Estimate centers and widths\n\n Parameters\n ----------\n\n unique_R : a list of array,\n Each element contains unique value in one dimension of\n coordinate matrix R.\n\n inds : a list of array,\n Each element contains the indices to reconstruct one\n dimension of original cooridnate matrix from the unique\n array.\n\n X : 2D array, with shape [n_voxel, n_tr]\n fMRI data from one subject.\n\n W : 2D array, with shape [K, n_tr]\n The weight matrix.\n\n init_centers : 2D array, with shape [K, n_dim]\n The initial values of centers.\n\n init_widths : 1D array\n The initial values of widths.\n\n template_centers: 1D array\n The template prior on centers\n\n template_widths: 1D array\n The template prior on widths\n\n template_centers_mean_cov: 2D array, with shape [K, cov_size]\n The template prior on centers' mean\n\n template_widths_mean_var_reci: 1D array\n The reciprocal of template prior on variance of widths' mean\n\n\n Returns\n -------\n\n final_estimate.x: 1D array\n The newly estimated centers and widths.\n\n final_estimate.cost: float\n The cost value." }, { "code": "def _GetCachedEntryDataTypeMap(\n self, format_type, value_data, cached_entry_offset):\n if format_type not in self._SUPPORTED_FORMAT_TYPES:\n raise errors.ParseError('Unsupported format type: {0:d}'.format(\n format_type))\n data_type_map_name = ''\n if format_type == self._FORMAT_TYPE_XP:\n data_type_map_name = 'appcompatcache_cached_entry_xp_32bit'\n elif format_type in (self._FORMAT_TYPE_8, self._FORMAT_TYPE_10):\n data_type_map_name = 'appcompatcache_cached_entry_header_8'\n else:\n cached_entry = self._ParseCommon2003CachedEntry(\n value_data, cached_entry_offset)\n if (cached_entry.path_offset_32bit == 0 and\n cached_entry.path_offset_64bit != 0):\n number_of_bits = '64'\n else:\n number_of_bits = '32'\n if format_type == self._FORMAT_TYPE_2003:\n data_type_map_name = (\n 'appcompatcache_cached_entry_2003_{0:s}bit'.format(number_of_bits))\n elif format_type == self._FORMAT_TYPE_VISTA:\n data_type_map_name = (\n 'appcompatcache_cached_entry_vista_{0:s}bit'.format(number_of_bits))\n elif format_type == self._FORMAT_TYPE_7:\n data_type_map_name = (\n 'appcompatcache_cached_entry_7_{0:s}bit'.format(number_of_bits))\n return self._GetDataTypeMap(data_type_map_name)", "docstring": "Determines the cached entry data type map.\n\n Args:\n format_type (int): format type.\n value_data (bytes): value data.\n cached_entry_offset (int): offset of the first cached entry data\n relative to the start of the value data.\n\n Returns:\n dtfabric.DataTypeMap: data type map which contains a data type definition,\n such as a structure, that can be mapped onto binary data or None\n if the data type map is not defined.\n\n Raises:\n ParseError: if the cached entry data type map cannot be determined." }, { "code": "def _unhandled_event_default(event):\n if isinstance(event, KeyboardEvent):\n c = event.key_code\n if c in (ord(\"X\"), ord(\"x\"), ord(\"Q\"), ord(\"q\")):\n raise StopApplication(\"User terminated app\")\n if c in (ord(\" \"), ord(\"\\n\"), ord(\"\\r\")):\n raise NextScene()", "docstring": "Default unhandled event handler for handling simple scene navigation." }, { "code": "def Find(cls, setting_matcher, port_path=None, serial=None, timeout_ms=None):\n if port_path:\n device_matcher = cls.PortPathMatcher(port_path)\n usb_info = port_path\n elif serial:\n device_matcher = cls.SerialMatcher(serial)\n usb_info = serial\n else:\n device_matcher = None\n usb_info = 'first'\n return cls.FindFirst(setting_matcher, device_matcher,\n usb_info=usb_info, timeout_ms=timeout_ms)", "docstring": "Gets the first device that matches according to the keyword args." }, { "code": "def enable_vmm_statistics(self, enable):\n if not isinstance(enable, bool):\n raise TypeError(\"enable can only be an instance of type bool\")\n self._call(\"enableVMMStatistics\",\n in_p=[enable])", "docstring": "Enables or disables collection of VMM RAM statistics.\n\n in enable of type bool\n True enables statistics collection.\n\n raises :class:`VBoxErrorInvalidVmState`\n Machine session is not open.\n \n raises :class:`VBoxErrorInvalidObjectState`\n Session type is not direct." }, { "code": "def get_modules(folder):\n if is_frozen():\n zipname = os.path.dirname(os.path.dirname(__file__))\n parentmodule = os.path.basename(os.path.dirname(__file__))\n with zipfile.ZipFile(zipname, 'r') as f:\n prefix = \"%s/%s/\" % (parentmodule, folder)\n modnames = [os.path.splitext(n[len(prefix):])[0]\n for n in f.namelist()\n if n.startswith(prefix) and \"__init__\" not in n]\n else:\n dirname = os.path.join(os.path.dirname(__file__), folder)\n modnames = get_importable_modules(dirname)\n for modname in modnames:\n try:\n name =\"..%s.%s\" % (folder, modname)\n yield importlib.import_module(name, __name__)\n except ImportError as msg:\n out.error(\"could not load module %s: %s\" % (modname, msg))", "docstring": "Find all valid modules in the given folder which must be in\n in the same directory as this loader.py module. A valid module\n has a .py extension, and is importable.\n @return: all loaded valid modules\n @rtype: iterator of module" }, { "code": "def handle(data_type, data, data_id=None, caller=None):\n if not data_id:\n data_id = data_type\n if data_id not in _handlers:\n _handlers[data_id] = dict(\n [(h.handle, h) for h in handlers.instantiate_for_data_type(data_type, data_id=data_id)])\n for handler in list(_handlers[data_id].values()):\n try:\n data = handler(data, caller=caller)\n except Exception as inst:\n vodka.log.error(\"Data handler '%s' failed with error\" % handler)\n vodka.log.error(traceback.format_exc())\n return data", "docstring": "execute all data handlers on the specified data according to data type\n\n Args:\n data_type (str): data type handle\n data (dict or list): data\n\n Kwargs:\n data_id (str): can be used to differentiate between different data\n sets of the same data type. If not specified will default to\n the data type\n caller (object): if specified, holds the object or function that\n is trying to handle data\n\n Returns:\n dict or list - data after handlers have been executed on it" }, { "code": "def pages(self):\n pages = []\n for har_dict in self.har_data:\n har_parser = HarParser(har_data=har_dict)\n if self.page_id:\n for page in har_parser.pages:\n if page.page_id == self.page_id:\n pages.append(page)\n else:\n pages = pages + har_parser.pages\n return pages", "docstring": "The aggregate pages of all the parser objects." }, { "code": "def option_group_exists(name, tags=None, region=None, key=None, keyid=None,\n profile=None):\n conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)\n try:\n rds = conn.describe_option_groups(OptionGroupName=name)\n return {'exists': bool(rds)}\n except ClientError as e:\n return {'error': __utils__['boto3.get_error'](e)}", "docstring": "Check to see if an RDS option group exists.\n\n CLI example::\n\n salt myminion boto_rds.option_group_exists myoptiongr region=us-east-1" }, { "code": "def to_b58check(self, testnet=False):\n b = self.testnet_bytes if testnet else bytes(self)\n return base58.b58encode_check(b)", "docstring": "Generates a Base58Check encoding of this key.\n\n Args:\n testnet (bool): True if the key is to be used with\n testnet, False otherwise.\n Returns:\n str: A Base58Check encoded string representing the key." }, { "code": "def is_modified(self):\n if self.__modified_data__ is not None:\n return True\n for value in self.__original_data__:\n try:\n if value.is_modified():\n return True\n except AttributeError:\n pass\n return False", "docstring": "Returns whether list is modified or not" }, { "code": "def to_api(in_dict, int_keys=None, date_keys=None, bool_keys=None):\n if int_keys:\n for in_key in int_keys:\n if (in_key in in_dict) and (in_dict.get(in_key, None) is not None):\n in_dict[in_key] = int(in_dict[in_key])\n if date_keys:\n for in_key in date_keys:\n if (in_key in in_dict) and (in_dict.get(in_key, None) is not None):\n _from = in_dict[in_key]\n if isinstance(_from, basestring):\n dtime = parse_datetime(_from)\n elif isinstance(_from, datetime):\n dtime = _from\n in_dict[in_key] = dtime.isoformat()\n elif (in_key in in_dict) and in_dict.get(in_key, None) is None:\n del in_dict[in_key]\n for k, v in in_dict.items():\n if v is None:\n del in_dict[k]\n return in_dict", "docstring": "Extends a given object for API Production." }, { "code": "def feature_list():\n lib_features_c_array = ctypes.POINTER(Feature)()\n lib_features_size = ctypes.c_size_t()\n check_call(_LIB.MXLibInfoFeatures(ctypes.byref(lib_features_c_array), ctypes.byref(lib_features_size)))\n features = [lib_features_c_array[i] for i in range(lib_features_size.value)]\n return features", "docstring": "Check the library for compile-time features. The list of features are maintained in libinfo.h and libinfo.cc\n\n Returns\n -------\n list\n List of :class:`.Feature` objects" }, { "code": "def wait_for_port(self, port, timeout=10, **probe_kwargs):\n Probe(timeout=timeout, fnc=functools.partial(self.is_port_open, port), **probe_kwargs).run()", "docstring": "block until specified port starts accepting connections, raises an exc ProbeTimeout\n if timeout is reached\n\n :param port: int, port number\n :param timeout: int or float (seconds), time to wait for establishing the connection\n :param probe_kwargs: arguments passed to Probe constructor\n :return: None" }, { "code": "def ls():\n heading, body = cli_syncthing_adapter.ls()\n if heading:\n click.echo(heading)\n if body:\n click.echo(body.strip())", "docstring": "List all synchronized directories." }, { "code": "def load_fasta_file(filename):\n with open(filename, \"r\") as handle:\n records = list(SeqIO.parse(handle, \"fasta\"))\n return records", "docstring": "Load a FASTA file and return the sequences as a list of SeqRecords\n\n Args:\n filename (str): Path to the FASTA file to load\n\n Returns:\n list: list of all sequences in the FASTA file as Biopython SeqRecord objects" }, { "code": "def xor(s, pad):\n from itertools import cycle\n s = bytearray(force_bytes(s, encoding='latin-1'))\n pad = bytearray(force_bytes(pad, encoding='latin-1'))\n return binary_type(bytearray(x ^ y for x, y in zip(s, cycle(pad))))", "docstring": "XOR a given string ``s`` with the one-time-pad ``pad``" }, { "code": "def config_profile_list(self):\n these_profiles = self._config_profile_list() or []\n profile_list = [q for p in these_profiles for q in\n [p.get('profileName')]]\n return profile_list", "docstring": "Return config profile list from DCNM." }, { "code": "def init_selection(self):\n si = self.shotverbrws.selected_indexes(0)\n if si:\n self.shot_ver_sel_changed(si[0])\n else:\n self.shot_ver_sel_changed(QtCore.QModelIndex())\n ai = self.assetverbrws.selected_indexes(0)\n if ai:\n self.asset_ver_sel_changed(ai[0])\n else:\n self.asset_ver_sel_changed(QtCore.QModelIndex())", "docstring": "Call selection changed in the beginning, so signals get emitted once\n\n Emit shot_taskfile_sel_changed signal and asset_taskfile_sel_changed.\n\n :returns: None\n :raises: None" }, { "code": "def get_agent(self, agent_id):\n collection = JSONClientValidated('authentication',\n collection='Agent',\n runtime=self._runtime)\n result = collection.find_one(\n dict({'_id': ObjectId(self._get_id(agent_id, 'authentication').get_identifier())},\n **self._view_filter()))\n return objects.Agent(osid_object_map=result, runtime=self._runtime, proxy=self._proxy)", "docstring": "Gets the ``Agent`` specified by its ``Id``.\n\n In plenary mode, the exact ``Id`` is found or a ``NotFound``\n results. Otherwise, the returned ``Agent`` may have a different\n ``Id`` than requested, such as the case where a duplicate ``Id``\n was assigned to an ``Agent`` and retained for compatibility.\n\n arg: agent_id (osid.id.Id): the ``Id`` of an ``Agent``\n return: (osid.authentication.Agent) - the returned ``Agent``\n raise: NotFound - no ``Agent`` found with the given ``Id``\n raise: NullArgument - ``agent_id`` is ``null``\n raise: OperationFailed - unable to complete request\n raise: PermissionDenied - authorization failure\n *compliance: mandatory -- This method must be implemented.*" }, { "code": "def glob1(self, dir_relpath, glob):\n if self.isignored(dir_relpath, directory=True):\n return []\n matched_files = self._glob1_raw(dir_relpath, glob)\n prefix = self._relpath_no_dot(dir_relpath)\n return self._filter_ignored(matched_files, selector=lambda p: os.path.join(prefix, p))", "docstring": "Returns a list of paths in path that match glob and are not ignored." }, { "code": "def calculate_shannon_entropy(self, data):\n if not data:\n return 0\n entropy = 0\n for x in self.charset:\n p_x = float(data.count(x)) / len(data)\n if p_x > 0:\n entropy += - p_x * math.log(p_x, 2)\n return entropy", "docstring": "Returns the entropy of a given string.\n\n Borrowed from: http://blog.dkbza.org/2007/05/scanning-data-for-entropy-anomalies.html.\n\n :param data: string. The word to analyze.\n :returns: float, between 0.0 and 8.0" }, { "code": "def local_path(self, url, filename=None, decompress=False, download=False):\n if download:\n return self.fetch(url=url, filename=filename, decompress=decompress)\n else:\n filename = self.local_filename(url, filename, decompress)\n return join(self.cache_directory_path, filename)", "docstring": "What will the full local path be if we download the given file?" }, { "code": "def register_run_plugins(self, plugin_name, plugin_class):\n if plugin_name in self.registered_plugins:\n raise PluginException(\"Plugin {} already registered! \"\n \"Duplicate plugins?\".format(plugin_name))\n self.logger.debug(\"Registering plugin %s\", plugin_name)\n if plugin_class.get_allocators():\n register_func = self.plugin_types[PluginTypes.ALLOCATOR]\n register_func(plugin_name, plugin_class)\n self.registered_plugins.append(plugin_name)", "docstring": "Loads a plugin as a dictionary and attaches needed parts to correct Icetea run\n global parts.\n\n :param plugin_name: Name of the plugins\n :param plugin_class: PluginBase\n :return: Nothing" }, { "code": "def _setup_http_session(self):\n headers = {\"Content-type\": \"application/json\"}\n if (self._id_token):\n headers.update({\"authorization\": \"Bearer {}\".format(\n self._id_token)})\n self._session.headers.update(headers)\n self._session.verify = False", "docstring": "Sets up the common HTTP session parameters used by requests." }, { "code": "def _find_usage_networking_sgs(self):\n logger.debug(\"Getting usage for EC2 VPC resources\")\n sgs_per_vpc = defaultdict(int)\n rules_per_sg = defaultdict(int)\n for sg in self.resource_conn.security_groups.all():\n if sg.vpc_id is not None:\n sgs_per_vpc[sg.vpc_id] += 1\n rules_per_sg[sg.id] = len(sg.ip_permissions)\n for vpc_id, count in sgs_per_vpc.items():\n self.limits['Security groups per VPC']._add_current_usage(\n count,\n aws_type='AWS::EC2::VPC',\n resource_id=vpc_id,\n )\n for sg_id, count in rules_per_sg.items():\n self.limits['Rules per VPC security group']._add_current_usage(\n count,\n aws_type='AWS::EC2::SecurityGroupRule',\n resource_id=sg_id,\n )", "docstring": "calculate usage for VPC-related things" }, { "code": "def ulocalized_gmt0_time(self, time, context, request):\n value = get_date(context, time)\n if not value:\n return \"\"\n value = value.toZone(\"GMT+0\")\n return self.ulocalized_time(value, context, request)", "docstring": "Returns the localized time in string format, but in GMT+0" }, { "code": "def match_tagname(self, el, tag):\n name = (util.lower(tag.name) if not self.is_xml and tag.name is not None else tag.name)\n return not (\n name is not None and\n name not in (self.get_tag(el), '*')\n )", "docstring": "Match tag name." }, { "code": "async def filter_new_posts(self, source_id, post_ids):\n new_ids = []\n try:\n db_client = self._db\n posts_in_db = await db_client.get_known_posts(source_id, post_ids)\n new_ids = [p for p in post_ids if p not in posts_in_db]\n except Exception as exc:\n logger.error(\"Error when filtering for new posts {} {}\".format(source_id, post_ids))\n logger.exception(exc)\n return new_ids", "docstring": "Filters ist of post_id for new ones.\n\n :param source_id: id of the source\n :type string:\n :param post_ids: list of post ids\n :type list:\n :returns: list of unknown post ids." }, { "code": "def begin(self, request, data):\n request = self.get_request(\n http_url = self.REQUEST_TOKEN_URL,\n parameters = dict(oauth_callback = self.get_callback(request)))\n content = self.load_request(request)\n if not content:\n return redirect('netauth-login')\n request = self.get_request(token = Token.from_string(content), http_url=self.AUTHORIZE_URL)\n return redirect(request.to_url())", "docstring": "Try to get Request Token from OAuth Provider and\n redirect user to provider's site for approval." }, { "code": "def count_open_fds():\n pid = os.getpid()\n procs = subprocess.check_output(\n ['lsof', '-w', '-Ff', '-p', str(pid)])\n nprocs = len(\n [s for s in procs.split('\\n') if s and s[0] == 'f' and s[1:].isdigit()]\n )\n return nprocs", "docstring": "return the number of open file descriptors for current process.\n\n .. warning: will only work on UNIX-like os-es.\n\n http://stackoverflow.com/a/7142094" }, { "code": "def chown(dirs, user=None, group=None):\n if isinstance(dirs, basestring):\n dirs = [dirs]\n args = ' '.join(dirs)\n if user and group:\n return sudo('chown {}:{} {}'.format(user, group, args))\n elif user:\n return sudo('chown {} {}'.format(user, args))\n elif group:\n return sudo('chgrp {} {}'.format(group, args))\n else:\n return None", "docstring": "User sudo to set user and group ownership" }, { "code": "def add_unique_runid(testcase, run_id=None):\n testcase[\"description\"] = '{}
'.format(\n testcase.get(\"description\") or \"\", run_id or id(add_unique_runid)\n )", "docstring": "Adds run id to the test description.\n\n The `run_id` runs makes the descriptions unique between imports and force Polarion\n to update every testcase every time." }, { "code": "def __get_values(self):\n values = []\n if self.__remote:\n description = self.__client.describe(self.__point)\n if description is not None:\n if description['type'] != 'Point':\n raise IOTUnknown('%s is not a Point' % self.__point)\n values = description['meta']['values']\n else:\n limit = 100\n offset = 0\n while True:\n new = self.__point.list(limit=limit, offset=offset)\n values += new\n if len(new) < limit:\n break\n offset += limit\n lang = self.__client.default_lang\n for value in values:\n value['comment'] = value['comment'].get(lang, None) if value['comment'] else None\n return values", "docstring": "Retrieve value information either via describe or point value listing. MUST be called within lock." }, { "code": "def emit(self, record):\n level = record.levelno\n if not FLAGS.is_parsed():\n global _warn_preinit_stderr\n if _warn_preinit_stderr:\n sys.stderr.write(\n 'WARNING: Logging before flag parsing goes to stderr.\\n')\n _warn_preinit_stderr = False\n self._log_to_stderr(record)\n elif FLAGS['logtostderr'].value:\n self._log_to_stderr(record)\n else:\n super(PythonHandler, self).emit(record)\n stderr_threshold = converter.string_to_standard(\n FLAGS['stderrthreshold'].value)\n if ((FLAGS['alsologtostderr'].value or level >= stderr_threshold) and\n self.stream != sys.stderr):\n self._log_to_stderr(record)\n if _is_absl_fatal_record(record):\n self.flush()\n os.abort()", "docstring": "Prints a record out to some streams.\n\n If FLAGS.logtostderr is set, it will print to sys.stderr ONLY.\n If FLAGS.alsologtostderr is set, it will print to sys.stderr.\n If FLAGS.logtostderr is not set, it will log to the stream\n associated with the current thread.\n\n Args:\n record: logging.LogRecord, the record to emit." }, { "code": "def apply_to(self, x, columns=False):\n if isinstance(x, np.ndarray) and len(x.shape) == 2 and x.shape[0] == 3 and columns:\n return x + self.t.reshape((3,1))\n if isinstance(x, np.ndarray) and (x.shape == (3, ) or (len(x.shape) == 2 and x.shape[1] == 3)) and not columns:\n return x + self.t\n elif isinstance(x, Complete):\n return Complete(x.r, x.t + self.t)\n elif isinstance(x, Translation):\n return Translation(x.t + self.t)\n elif isinstance(x, Rotation):\n return Complete(x.r, self.t)\n elif isinstance(x, UnitCell):\n return x\n else:\n raise ValueError(\"Can not apply this translation to %s\" % x)", "docstring": "Apply this translation to the given object\n\n The argument can be several sorts of objects:\n\n * ``np.array`` with shape (3, )\n * ``np.array`` with shape (N, 3)\n * ``np.array`` with shape (3, N), use ``columns=True``\n * ``Translation``\n * ``Rotation``\n * ``Complete``\n * ``UnitCell``\n\n In case of arrays, the 3D vectors are translated. In case of trans-\n formations, a new transformation is returned that consists of this\n translation applied AFTER the given translation. In case of a unit\n cell, the original object is returned.\n\n This method is equivalent to ``self*x``." }, { "code": "def configure_lease(self, lease, lease_max, mount_point=DEFAULT_MOUNT_POINT):\n params = {\n 'lease': lease,\n 'lease_max': lease_max,\n }\n api_path = '/v1/{mount_point}/config/lease'.format(mount_point=mount_point)\n return self._adapter.post(\n url=api_path,\n json=params,\n )", "docstring": "Configure lease settings for the AWS secrets engine.\n\n It is optional, as there are default values for lease and lease_max.\n\n Supported methods:\n POST: /{mount_point}/config/lease. Produces: 204 (empty body)\n\n :param lease: Specifies the lease value provided as a string duration with time suffix. \"h\" (hour) is the\n largest suffix.\n :type lease: str | unicode\n :param lease_max: Specifies the maximum lease value provided as a string duration with time suffix. \"h\" (hour)\n is the largest suffix.\n :type lease_max: str | unicode\n :param mount_point: The \"path\" the method/backend was mounted on.\n :type mount_point: str | unicode\n :return: The response of the request.\n :rtype: requests.Response" }, { "code": "def format(logger,\n show_successful=True,\n show_errors=True,\n show_traceback=True):\n output = []\n errors = logger.get_aborted_actions()\n if show_errors and errors:\n output += _underline('Failed actions:')\n for log in logger.get_aborted_logs():\n if show_traceback:\n output.append(log.get_name() + ':')\n output.append(log.get_error())\n else:\n output.append(log.get_name() + ': ' + log.get_error(False))\n output.append('')\n if show_successful:\n output += _underline('Successful actions:')\n for log in logger.get_succeeded_logs():\n output.append(log.get_name())\n output.append('')\n return '\\n'.join(output).strip()", "docstring": "Prints a report of the actions that were logged by the given Logger.\n The report contains a list of successful actions, as well as the full\n error message on failed actions.\n\n :type logger: Logger\n :param logger: The logger that recorded what happened in the queue.\n :rtype: string\n :return: A string summarizing the status of every performed task." }, { "code": "def _iterate_prefix(self, callsign, timestamp=timestamp_now):\n prefix = callsign\n if re.search('(VK|AX|VI)9[A-Z]{3}', callsign):\n if timestamp > datetime(2006,1,1, tzinfo=UTC):\n prefix = callsign[0:3]+callsign[4:5]\n while len(prefix) > 0:\n try:\n return self._lookuplib.lookup_prefix(prefix, timestamp)\n except KeyError:\n prefix = prefix.replace(' ', '')[:-1]\n continue\n raise KeyError", "docstring": "truncate call until it corresponds to a Prefix in the database" }, { "code": "def update_from_json(self, path=join('config', 'hdx_dataset_static.json')):\n super(Dataset, self).update_from_json(path)\n self.separate_resources()", "docstring": "Update dataset metadata with static metadata from JSON file\n\n Args:\n path (str): Path to JSON dataset metadata. Defaults to config/hdx_dataset_static.json.\n\n Returns:\n None" }, { "code": "def do_history(self, line):\n self._split_args(line, 0, 0)\n for idx, item in enumerate(self._history):\n d1_cli.impl.util.print_info(\"{0: 3d} {1}\".format(idx, item))", "docstring": "history Display a list of commands that have been entered." }, { "code": "def compose_all(stream, Loader=Loader):\n loader = Loader(stream)\n try:\n while loader.check_node():\n yield loader.get_node()\n finally:\n loader.dispose()", "docstring": "Parse all YAML documents in a stream\n and produce corresponding representation trees." }, { "code": "def toPIL(self, **attribs):\n import PIL.Image\n bytes = self.convert(\"png\")\n sfile = io.BytesIO(bytes)\n pil = PIL.Image.open(sfile)\n return pil", "docstring": "Convert canvas to a PIL image" }, { "code": "def panzoom(marks):\n return PanZoom(scales={\n 'x': sum([mark._get_dimension_scales('x', preserve_domain=True) for mark in marks], []),\n 'y': sum([mark._get_dimension_scales('y', preserve_domain=True) for mark in marks], [])\n })", "docstring": "Helper function for panning and zooming over a set of marks.\n\n Creates and returns a panzoom interaction with the 'x' and 'y' dimension\n scales of the specified marks." }, { "code": "def _execute_command(self, command, workunit_name=None, workunit_labels=None):\n workunit_name = workunit_name or command.executable\n workunit_labels = {WorkUnitLabel.TOOL} | set(workunit_labels or ())\n with self.context.new_workunit(name=workunit_name,\n labels=workunit_labels,\n cmd=str(command)) as workunit:\n returncode = self._run_node_distribution_command(command, workunit)\n workunit.set_outcome(WorkUnit.SUCCESS if returncode == 0 else WorkUnit.FAILURE)\n return returncode, command", "docstring": "Executes a node or npm command via self._run_node_distribution_command.\n\n :param NodeDistribution.Command command: The command to run.\n :param string workunit_name: A name for the execution's work unit; default command.executable.\n :param list workunit_labels: Any extra :class:`pants.base.workunit.WorkUnitLabel`s to apply.\n :returns: A tuple of (returncode, command).\n :rtype: A tuple of (int,\n :class:`pants.contrib.node.subsystems.node_distribution.NodeDistribution.Command`)" }, { "code": "def build_docs(location=\"doc-source\", target=None, library=\"icetea_lib\"):\n cmd_ar = [\"sphinx-apidoc\", \"-o\", location, library]\n try:\n print(\"Generating api docs.\")\n retcode = check_call(cmd_ar)\n except CalledProcessError as error:\n print(\"Documentation build failed. Return code: {}\".format(error.returncode))\n return 3\n except OSError as error:\n print(error)\n print(\"Documentation build failed. Are you missing Sphinx? Please install sphinx using \"\n \"'pip install sphinx'.\")\n return 3\n target = \"doc{}html\".format(os.sep) if target is None else target\n cmd_ar = [\"sphinx-build\", \"-b\", \"html\", location, target]\n try:\n print(\"Building html documentation.\")\n retcode = check_call(cmd_ar)\n except CalledProcessError as error:\n print(\"Documentation build failed. Return code: {}\".format(error.returncode))\n return 3\n except OSError as error:\n print(error)\n print(\"Documentation build failed. Are you missing Sphinx? Please install sphinx using \"\n \"'pip install sphinx'.\")\n return 3\n print(\"Documentation built.\")\n return 0", "docstring": "Build documentation for Icetea. Start by autogenerating module documentation\n and finish by building html.\n\n :param location: Documentation source\n :param target: Documentation target path\n :param library: Library location for autodoc.\n :return: -1 if something fails. 0 if successfull." }, { "code": "def pickle_dumps(self, protocol=None):\n strio = StringIO()\n pmg_pickle_dump(self, strio,\n protocol=self.pickle_protocol if protocol is None\n else protocol)\n return strio.getvalue()", "docstring": "Return a string with the pickle representation.\n `protocol` selects the pickle protocol. self.pickle_protocol is\n used if `protocol` is None" }, { "code": "def get(self, key, get_cas=False):\n for server in self.servers:\n value, cas = server.get(key)\n if value is not None:\n if get_cas:\n return value, cas\n else:\n return value\n if get_cas:\n return None, None", "docstring": "Get a key from server.\n\n :param key: Key's name\n :type key: six.string_types\n :param get_cas: If true, return (value, cas), where cas is the new CAS value.\n :type get_cas: boolean\n :return: Returns a key data from server.\n :rtype: object" }, { "code": "def assert_page_source_contains(self, expected_value, failure_message='Expected page source to contain: \"{}\"'):\n assertion = lambda: expected_value in self.driver_wrapper.page_source()\n self.webdriver_assert(assertion, unicode(failure_message).format(expected_value))", "docstring": "Asserts that the page source contains the string passed in expected_value" }, { "code": "def update(self, job_id, name=NotUpdated, description=NotUpdated,\n is_public=NotUpdated, is_protected=NotUpdated):\n data = {}\n self._copy_if_updated(data, name=name, description=description,\n is_public=is_public, is_protected=is_protected)\n return self._patch('/jobs/%s' % job_id, data)", "docstring": "Update a Job." }, { "code": "def square_root(n, epsilon=0.001):\n guess = n / 2\n while abs(guess * guess - n) > epsilon:\n guess = (guess + (n / guess)) / 2\n return guess", "docstring": "Return square root of n, with maximum absolute error epsilon" }, { "code": "def safe_call(request: Request, methods: Methods, *, debug: bool) -> Response:\n with handle_exceptions(request, debug) as handler:\n result = call(methods.items[request.method], *request.args, **request.kwargs)\n handler.response = SuccessResponse(result=result, id=request.id)\n return handler.response", "docstring": "Call a Request, catching exceptions to ensure we always return a Response.\n\n Args:\n request: The Request object.\n methods: The list of methods that can be called.\n debug: Include more information in error responses.\n\n Returns:\n A Response object." }, { "code": "def valarray(shape, value=np.NaN, typecode=None):\n if typecode is None:\n typecode = bool\n out = np.ones(shape, dtype=typecode) * value\n if not isinstance(out, np.ndarray):\n out = np.asarray(out)\n return out", "docstring": "Return an array of all value." }, { "code": "def capitalize_unicode_name(s):\n index = s.find('capital')\n if index == -1: return s\n tail = s[index:].replace('capital', '').strip()\n tail = tail[0].upper() + tail[1:]\n return s[:index] + tail", "docstring": "Turns a string such as 'capital delta' into the shortened,\n capitalized version, in this case simply 'Delta'. Used as a\n transform in sanitize_identifier." }, { "code": "def get_first_lang():\n request_lang = request.headers.get('Accept-Language').split(',')\n if request_lang:\n lang = locale.normalize(request_lang[0]).split('.')[0]\n else:\n lang = False\n return lang", "docstring": "Get the first lang of Accept-Language Header." }, { "code": "def getTypeStr(_type):\n r\n if isinstance(_type, CustomType):\n return str(_type)\n if hasattr(_type, '__name__'):\n return _type.__name__\n return ''", "docstring": "r\"\"\"Gets the string representation of the given type." }, { "code": "def npm(usr_pwd=None, clean=False):\n\ttry: cmd('which npm')\n\texcept:\n\t\treturn\n\tprint('-[npm]----------')\n\tp = cmd(\"npm outdated -g | awk 'NR>1 {print $1}'\")\n\tif not p: return\n\tpkgs = getPackages(p)\n\tfor p in pkgs:\n\t\tcmd('{} {}'.format('npm update -g ', p), usr_pwd=usr_pwd, run=global_run)", "docstring": "Handle npm for Node.js" }, { "code": "def _remote_file_size(url=None, file_name=None, pb_dir=None):\n if file_name and pb_dir:\n url = posixpath.join(config.db_index_url, pb_dir, file_name)\n response = requests.head(url, headers={'Accept-Encoding': 'identity'})\n response.raise_for_status()\n remote_file_size = int(response.headers['content-length'])\n return remote_file_size", "docstring": "Get the remote file size in bytes\n\n Parameters\n ----------\n url : str, optional\n The full url of the file. Use this option to explicitly\n state the full url.\n file_name : str, optional\n The base file name. Use this argument along with pb_dir if you\n want the full url to be constructed.\n pb_dir : str, optional\n The base file name. Use this argument along with file_name if\n you want the full url to be constructed.\n\n Returns\n -------\n remote_file_size : int\n Size of the file in bytes" }, { "code": "def _add_membership_multicast_socket(self):\n self._membership_request = socket.inet_aton(self._multicast_group) \\\n + socket.inet_aton(self._multicast_ip)\n self._multicast_socket.setsockopt(\n socket.IPPROTO_IP,\n socket.IP_ADD_MEMBERSHIP,\n self._membership_request\n )", "docstring": "Make membership request to multicast\n\n :rtype: None" }, { "code": "def to_commit(obj):\n if obj.type == 'tag':\n obj = deref_tag(obj)\n if obj.type != \"commit\":\n raise ValueError(\"Cannot convert object %r to type commit\" % obj)\n return obj", "docstring": "Convert the given object to a commit if possible and return it" }, { "code": "def tokenize(self):\n tokens = []\n token_spec = [\n ('mlc', r'/\\*.*?\\*/'),\n ('slc', r'//[^\\r\\n]*?\\r?\\n'),\n ('perl', r'<%.*?%>'),\n ('incl', r'`include'),\n ]\n tok_regex = '|'.join('(?P<%s>%s)' % pair for pair in token_spec)\n for m in re.finditer(tok_regex, self.text, re.DOTALL):\n if m.lastgroup in (\"incl\", \"perl\"):\n tokens.append((m.lastgroup, m.start(0), m.end(0)-1))\n return tokens", "docstring": "Tokenize the input text\n\n Scans for instances of perl tags and include directives.\n Tokenization skips line and block comments.\n\n Returns\n -------\n list\n List of tuples: (typ, start, end)\n\n Where:\n\n - typ is \"perl\" or \"incl\"\n - start/end mark the first/last char offset of the token" }, { "code": "def export_wif(self) -> str:\n data = b''.join([b'\\x80', self.__private_key, b'\\01'])\n checksum = Digest.hash256(data[0:34])\n wif = base58.b58encode(b''.join([data, checksum[0:4]]))\n return wif.decode('ascii')", "docstring": "This interface is used to get export ECDSA private key in the form of WIF which\n is a way to encoding an ECDSA private key and make it easier to copy.\n\n :return: a WIF encode private key." }, { "code": "def effective_nsamples(self):\n try:\n act = numpy.array(list(self.acts.values())).max()\n except (AttributeError, TypeError):\n act = numpy.inf\n if self.burn_in is None:\n nperwalker = max(int(self.niterations // act), 1)\n elif self.burn_in.is_burned_in:\n nperwalker = int(\n (self.niterations - self.burn_in.burn_in_iteration) // act)\n nperwalker = max(nperwalker, 1)\n else:\n nperwalker = 0\n return self.nwalkers * nperwalker", "docstring": "The effective number of samples post burn-in that the sampler has\n acquired so far." }, { "code": "def get(self, url, data=None):\n response = self.http.get(url,\n headers=self.headers,\n params=data,\n **self.requests_params)\n return self.process(response)", "docstring": "Executes an HTTP GET request for the given URL.\n\n ``data`` should be a dictionary of url parameters" }, { "code": "def plot_sed(sed, showlnl=False, **kwargs):\n ax = kwargs.pop('ax', plt.gca())\n cmap = kwargs.get('cmap', 'BuGn')\n annotate_name(sed, ax=ax)\n SEDPlotter.plot_flux_points(sed, **kwargs)\n if np.any(sed['ts'] > 9.):\n if 'model_flux' in sed:\n SEDPlotter.plot_model(sed['model_flux'],\n noband=showlnl, **kwargs)\n if showlnl:\n SEDPlotter.plot_lnlscan(sed, **kwargs)\n ax.set_yscale('log')\n ax.set_xscale('log')\n ax.set_xlabel('Energy [MeV]')\n ax.set_ylabel('E$^{2}$dN/dE [MeV cm$^{-2}$ s$^{-1}$]')", "docstring": "Render a plot of a spectral energy distribution.\n\n Parameters\n ----------\n showlnl : bool \n Overlay a map of the delta-loglikelihood values vs. flux\n in each energy bin.\n\n cmap : str \n Colormap that will be used for the delta-loglikelihood\n map.\n\n llhcut : float\n Minimum delta-loglikelihood value.\n\n ul_ts_threshold : float \n TS threshold that determines whether the MLE or UL\n is plotted in each energy bin." }, { "code": "def filter(self, chromosome, **kwargs) :\n\t\tdef appendAllele(alleles, sources, snp) :\n\t\t\tpos = snp.start\n\t\t\tif snp.alt[0] == '-' :\n\t\t\t\tpass\n\t\t\telif snp.ref[0] == '-' :\n\t\t\t\tpass\n\t\t\telse :\n\t\t\t\tsources[snpSet] = snp\n\t\t\t\talleles.append(snp.alt)\n\t\t\trefAllele = chromosome.refSequence[pos]\n\t\t\talleles.append(refAllele)\n\t\t\tsources['ref'] = refAllele\n\t\t\treturn alleles, sources\n\t\twarn = 'Warning: the default snp filter ignores indels. IGNORED %s of SNP set: %s at pos: %s of chromosome: %s'\n\t\tsources = {}\n\t\talleles = []\n\t\tfor snpSet, data in kwargs.iteritems() :\n\t\t\tif type(data) is list :\n\t\t\t\tfor snp in data :\n\t\t\t\t\talleles, sources = appendAllele(alleles, sources, snp)\n\t\t\telse :\n\t\t\t\tallels, sources = appendAllele(alleles, sources, data)\n\t\treturn SequenceSNP(alleles, sources = sources)", "docstring": "The default filter mixes applied all SNPs and ignores Insertions and Deletions." }, { "code": "def threshold(image, block_size=DEFAULT_BLOCKSIZE, mask=None):\n if mask is None:\n mask = np.zeros(image.shape[:2], dtype=np.uint8)\n mask[:] = 255\n if len(image.shape) > 2 and image.shape[2] == 4:\n image = cv2.cvtColor(image, cv2.COLOR_BGRA2GRAY)\n res = _calc_block_mean_variance(image, mask, block_size)\n res = image.astype(np.float32) - res.astype(np.float32) + 255\n _, res = cv2.threshold(res, 215, 255, cv2.THRESH_BINARY)\n return res", "docstring": "Applies adaptive thresholding to the given image.\n\n Args:\n image: BGRA image.\n block_size: optional int block_size to use for adaptive thresholding.\n mask: optional mask.\n Returns:\n Thresholded image." }, { "code": "def revoker(self, revoker, **prefs):\n hash_algo = prefs.pop('hash', None)\n sig = PGPSignature.new(SignatureType.DirectlyOnKey, self.key_algorithm, hash_algo, self.fingerprint.keyid)\n sensitive = prefs.pop('sensitive', False)\n keyclass = RevocationKeyClass.Normal | (RevocationKeyClass.Sensitive if sensitive else 0x00)\n sig._signature.subpackets.addnew('RevocationKey',\n hashed=True,\n algorithm=revoker.key_algorithm,\n fingerprint=revoker.fingerprint,\n keyclass=keyclass)\n prefs['revocable'] = False\n return self._sign(self, sig, **prefs)", "docstring": "Generate a signature that specifies another key as being valid for revoking this key.\n\n :param revoker: The :py:obj:`PGPKey` to specify as a valid revocation key.\n :type revoker: :py:obj:`PGPKey`\n :raises: :py:exc:`~pgpy.errors.PGPError` if the key is passphrase-protected and has not been unlocked\n :raises: :py:exc:`~pgpy.errors.PGPError` if the key is public\n :returns: :py:obj:`PGPSignature`\n\n In addition to the optional keyword arguments accepted by :py:meth:`PGPKey.sign`, the following optional\n keyword arguments can be used with :py:meth:`PGPKey.revoker`.\n\n :keyword sensitive: If ``True``, this sets the sensitive flag on the RevocationKey subpacket. Currently,\n this has no other effect.\n :type sensitive: ``bool``" }, { "code": "def _set_relationship_type(self, type_identifier, display_name=None, display_label=None, description=None, domain='Relationship'):\n if display_name is None:\n display_name = type_identifier\n if display_label is None:\n display_label = display_name\n if description is None:\n description = 'Relationship Type for ' + display_name\n self._relationship_type = Type(authority='DLKIT',\n namespace='relationship.Relationship',\n identifier=type_identifier,\n display_name=display_name,\n display_label=display_label,\n description=description,\n domain=domain)", "docstring": "Sets the relationship type" }, { "code": "def state(self, *args, **kwargs):\n return self._makeApiCall(self.funcinfo[\"state\"], *args, **kwargs)", "docstring": "Get AWS State for a worker type\n\n Return the state of a given workertype as stored by the provisioner.\n This state is stored as three lists: 1 for running instances, 1 for\n pending requests. The `summary` property contains an updated summary\n similar to that returned from `listWorkerTypeSummaries`.\n\n This method is ``stable``" }, { "code": "def ClaimRecords(self,\n limit=10000,\n timeout=\"30m\",\n start_time=None,\n record_filter=lambda x: False,\n max_filtered=1000):\n if not self.locked:\n raise aff4.LockError(\"Queue must be locked to claim records.\")\n with data_store.DB.GetMutationPool() as mutation_pool:\n return mutation_pool.QueueClaimRecords(\n self.urn,\n self.rdf_type,\n limit=limit,\n timeout=timeout,\n start_time=start_time,\n record_filter=record_filter,\n max_filtered=max_filtered)", "docstring": "Returns and claims up to limit unclaimed records for timeout seconds.\n\n Returns a list of records which are now \"claimed\", a claimed record will\n generally be unavailable to be claimed until the claim times out. Note\n however that in case of an unexpected timeout or other error a record might\n be claimed twice at the same time. For this reason it should be considered\n weaker than a true lock.\n\n Args:\n limit: The number of records to claim.\n\n timeout: The duration of the claim.\n\n start_time: The time to start claiming records at. Only records with a\n timestamp after this point will be claimed.\n\n record_filter: A filter method to determine if the record should be\n returned. It will be called serially on each record and the record will\n be filtered (not returned or locked) if it returns True.\n\n max_filtered: If non-zero, limits the number of results read when\n filtered. Specifically, if max_filtered filtered results are read\n sequentially without any unfiltered results, we stop looking for\n results.\n\n Returns:\n A list (id, record) where record is a self.rdf_type and id is a record\n identifier which can be used to delete or release the record.\n\n Raises:\n LockError: If the queue is not locked." }, { "code": "def custom_resolve(self):\n if not callable(self.custom_resolver):\n return\n new_addresses = []\n for address in self.addresses:\n for new_address in self.custom_resolver(address):\n new_addresses.append(new_address)\n self.addresses = new_addresses", "docstring": "If a custom resolver is defined, perform custom resolution on\n the contained addresses.\n\n :return:" }, { "code": "def get_resource(self, path, params=None):\n url = '%s%s' % (path, self._param_list(params))\n headers = {\n 'Accept': 'application/json;odata=minimalmetadata'\n }\n response = O365_DAO().getURL(self._url(url), headers)\n if response.status != 200:\n raise DataFailureException(url, response.status, response.data)\n return json_loads(response.data)", "docstring": "O365 GET method. Return representation of the requested resource." }, { "code": "def tailor(pattern_or_root, dimensions=None, distributed_dim='time',\n read_only=False):\n return TileManager(pattern_or_root, dimensions=dimensions,\n distributed_dim=distributed_dim, read_only=read_only)", "docstring": "Return a TileManager to wrap the root descriptor and tailor all the\n dimensions to a specified window.\n\n Keyword arguments:\n root -- a NCObject descriptor.\n pattern -- a filename string to open a NCObject descriptor.\n dimensions -- a dictionary to configurate the dimensions limits." }, { "code": "def unpatch(self):\n if not self._patched:\n return\n for func in self._read_compilers + self._write_compilers:\n func.execute_sql = self._original[func]\n self.cache_backend.unpatch()\n self._patched = False", "docstring": "un-applies this patch." }, { "code": "def close(self):\n with self._close_lock:\n sfd = self._sfd\n if sfd >= 0:\n self._sfd = -1\n self._signals = frozenset()\n close(sfd)", "docstring": "Close the internal signalfd file descriptor if it isn't closed\n\n :raises OSError:\n If the underlying ``close(2)`` fails. The error message matches\n those found in the manual page." }, { "code": "def value_text(self):\n search = self._selected.get()\n for item in self._rbuttons:\n if item.value == search:\n return item.text\n return \"\"", "docstring": "Sets or returns the option selected in a ButtonGroup by its text value." }, { "code": "def save_current_figure_as(self):\n if self.current_thumbnail is not None:\n self.save_figure_as(self.current_thumbnail.canvas.fig,\n self.current_thumbnail.canvas.fmt)", "docstring": "Save the currently selected figure." }, { "code": "def add_summary(self, summary, global_step=None):\n if isinstance(summary, bytes):\n summ = summary_pb2.Summary()\n summ.ParseFromString(summary)\n summary = summ\n for value in summary.value:\n if not value.metadata:\n continue\n if value.tag in self._seen_summary_tags:\n value.ClearField(\"metadata\")\n continue\n self._seen_summary_tags.add(value.tag)\n event = event_pb2.Event(summary=summary)\n self._add_event(event, global_step)", "docstring": "Adds a `Summary` protocol buffer to the event file.\n This method wraps the provided summary in an `Event` protocol buffer and adds it\n to the event file.\n\n Parameters\n ----------\n summary : A `Summary` protocol buffer\n Optionally serialized as a string.\n global_step: Number\n Optional global step value to record with the summary." }, { "code": "def _use_memcache(self, key, options=None):\n flag = ContextOptions.use_memcache(options)\n if flag is None:\n flag = self._memcache_policy(key)\n if flag is None:\n flag = ContextOptions.use_memcache(self._conn.config)\n if flag is None:\n flag = True\n return flag", "docstring": "Return whether to use memcache for this key.\n\n Args:\n key: Key instance.\n options: ContextOptions instance, or None.\n\n Returns:\n True if the key should be cached in memcache, False otherwise." }, { "code": "def translate(self, vector, inc_alt_states=True):\n vector = numpy.array(vector)\n for atom in self.get_atoms(inc_alt_states=inc_alt_states):\n atom._vector += vector\n return", "docstring": "Translates every atom in the AMPAL object.\n\n Parameters\n ----------\n vector : 3D Vector (tuple, list, numpy.array)\n Vector used for translation.\n inc_alt_states : bool, optional\n If true, will rotate atoms in all states i.e. includes\n alternate conformations for sidechains." }, { "code": "def _create_interval_filter(interval):\n def filter_fn(value):\n if (not isinstance(value, six.integer_types) and\n not isinstance(value, float)):\n raise error.HParamsError(\n 'Cannot use an interval filter for a value of type: %s, Value: %s' %\n (type(value), value))\n return interval.min_value <= value and value <= interval.max_value\n return filter_fn", "docstring": "Returns a function that checkes whether a number belongs to an interval.\n\n Args:\n interval: A tensorboard.hparams.Interval protobuf describing the interval.\n Returns:\n A function taking a number (a float or an object of a type in\n six.integer_types) that returns True if the number belongs to (the closed)\n 'interval'." }, { "code": "def _polling_iteration(self):\n\t\tif self.__task is None:\n\t\t\tself.ready_event().set()\n\t\telif self.__task.check_events() is True:\n\t\t\tself.ready_event().set()\n\t\t\tself.registry().task_finished(self)", "docstring": "Poll for scheduled task stop events\n\n\t\t:return: None" }, { "code": "def merge_entities(doc):\n with doc.retokenize() as retokenizer:\n for ent in doc.ents:\n attrs = {\"tag\": ent.root.tag, \"dep\": ent.root.dep, \"ent_type\": ent.label}\n retokenizer.merge(ent, attrs=attrs)\n return doc", "docstring": "Merge entities into a single token.\n\n doc (Doc): The Doc object.\n RETURNS (Doc): The Doc object with merged entities.\n\n DOCS: https://spacy.io/api/pipeline-functions#merge_entities" }, { "code": "def job_runner(self):\n outputs = luigi.task.flatten(self.output())\n for output in outputs:\n if not isinstance(output, luigi.contrib.hdfs.HdfsTarget):\n warnings.warn(\"Job is using one or more non-HdfsTarget outputs\" +\n \" so it will be run in local mode\")\n return LocalJobRunner()\n else:\n return DefaultHadoopJobRunner()", "docstring": "Get the MapReduce runner for this job.\n\n If all outputs are HdfsTargets, the DefaultHadoopJobRunner will be used.\n Otherwise, the LocalJobRunner which streams all data through the local machine\n will be used (great for testing)." }, { "code": "def _print_drift_report(self):\n try:\n response = self._cloud_formation.describe_stack_resources(StackName=self._stack_name)\n rows = []\n for resource in response.get('StackResources', []):\n row = []\n row.append(resource.get('LogicalResourceId', 'unknown'))\n row.append(resource.get('PhysicalResourceId', 'unknown'))\n row.append(resource.get('ResourceStatus', 'unknown'))\n row.append(resource.get('DriftInformation', {}).get('StackResourceDriftStatus', 'unknown'))\n rows.append(row)\n print('Drift Report:')\n print(tabulate(rows, headers=[\n 'Logical ID',\n 'Physical ID',\n 'Resource Status',\n 'Drift Info'\n ]))\n except Exception as wtf:\n logging.error(wtf, exc_info=True)\n return False\n return True", "docstring": "Report the drift of the stack.\n\n Args:\n None\n\n Returns:\n Good or Bad; True or False\n\n Note: not yet implemented" }, { "code": "def _cli_check_format(fmt):\n if fmt is None:\n return None\n fmt = fmt.lower()\n if not fmt in api.get_formats():\n errstr = \"Format '\" + fmt + \"' does not exist.\\n\"\n errstr += \"For a complete list of formats, use the 'bse list-formats' command\"\n raise RuntimeError(errstr)\n return fmt", "docstring": "Checks that a basis set format exists and if not, raises a helpful exception" }, { "code": "async def generate_waifu_insult(self, avatar):\n if not isinstance(avatar, str):\n raise TypeError(\"type of 'avatar' must be str.\")\n async with aiohttp.ClientSession() as session:\n async with session.post(\"https://api.weeb.sh/auto-image/waifu-insult\", headers=self.__headers, data={\"avatar\": avatar}) as resp:\n if resp.status == 200:\n return await resp.read()\n else:\n raise Exception((await resp.json())['message'])", "docstring": "Generate a waifu insult image.\n\n This function is a coroutine.\n\n Parameters:\n avatar: str - http/s url pointing to an image, has to have proper headers and be a direct link to an image\n\n Return Type: image data" }, { "code": "def users_get(self, domain):\n path = self._get_management_path(domain)\n return self.http_request(path=path,\n method='GET')", "docstring": "Retrieve a list of users from the server.\n\n :param AuthDomain domain: The authentication domain to retrieve users from.\n :return: :class:`~.HttpResult`. The list of users can be obtained from\n the returned object's `value` property." }, { "code": "def to_struct(cls, name=None):\n if name is None:\n name = cls.__name__\n basic_attrs = dict([(attr_name, value)\n for attr_name, value in cls.get_attrs()\n if isinstance(value, Column)])\n if not basic_attrs:\n return None\n src = 'struct {0} {{'.format(name)\n for attr_name, value in basic_attrs.items():\n src += '{0} {1};'.format(value.type.typename, attr_name)\n src += '};'\n if ROOT.gROOT.ProcessLine(src) != 0:\n return None\n return getattr(ROOT, name, None)", "docstring": "Convert the TreeModel into a compiled C struct" }, { "code": "def GetBatchJobDownloadUrlWhenReady(client, batch_job_id,\n max_poll_attempts=MAX_POLL_ATTEMPTS):\n batch_job = GetBatchJob(client, batch_job_id)\n if batch_job['status'] == 'CANCELED':\n raise Exception('Batch Job with ID \"%s\" was canceled before completing.'\n % batch_job_id)\n poll_attempt = 0\n while (poll_attempt in range(max_poll_attempts) and\n batch_job['status'] in PENDING_STATUSES):\n sleep_interval = (30 * (2 ** poll_attempt) +\n (random.randint(0, 10000) / 1000))\n print 'Batch Job not ready, sleeping for %s seconds.' % sleep_interval\n time.sleep(sleep_interval)\n batch_job = GetBatchJob(client, batch_job_id)\n poll_attempt += 1\n if 'downloadUrl' in batch_job:\n url = batch_job['downloadUrl']['url']\n print ('Batch Job with Id \"%s\", Status \"%s\", and DownloadUrl \"%s\" ready.'\n % (batch_job['id'], batch_job['status'], url))\n return url\n print ('BatchJob with ID \"%s\" is being canceled because it was in a pending '\n 'state after polling %d times.' % (batch_job_id, max_poll_attempts))\n CancelBatchJob(client, batch_job)", "docstring": "Retrieves the downloadUrl when the BatchJob is complete.\n\n Args:\n client: an instantiated AdWordsClient used to poll the BatchJob.\n batch_job_id: a long identifying the BatchJob to be polled.\n max_poll_attempts: an int defining the number of times the BatchJob will be\n checked to determine whether it has completed.\n\n Returns:\n A str containing the downloadUrl of the completed BatchJob.\n\n Raises:\n Exception: If the BatchJob hasn't finished after the maximum poll attempts\n have been made." }, { "code": "def _endmsg(self, rd):\n msg = \"\"\n s = \"\"\n if rd.hours > 0:\n if rd.hours > 1:\n s = \"s\"\n msg += colors.bold(str(rd.hours)) + \" hour\" + s + \" \"\n s = \"\"\n if rd.minutes > 0:\n if rd.minutes > 1:\n s = \"s\"\n msg += colors.bold(str(rd.minutes)) + \" minute\" + s + \" \"\n milliseconds = int(rd.microseconds / 1000)\n if milliseconds > 0:\n msg += colors.bold(str(rd.seconds) + \".\" + str(milliseconds))\n msg += \" seconds\"\n return msg", "docstring": "Returns an end message with elapsed time" }, { "code": "def iterator(plugins, context):\n test = pyblish.logic.registered_test()\n state = {\n \"nextOrder\": None,\n \"ordersWithError\": set()\n }\n for plugin in plugins:\n state[\"nextOrder\"] = plugin.order\n message = test(**state)\n if message:\n raise StopIteration(\"Stopped due to %s\" % message)\n instances = pyblish.api.instances_by_plugin(context, plugin)\n if plugin.__instanceEnabled__:\n for instance in instances:\n yield plugin, instance\n else:\n yield plugin, None", "docstring": "An iterator for plug-in and instance pairs" }, { "code": "def expand_variable_dicts(\n list_of_variable_dicts: 'List[Union[Dataset, OrderedDict]]',\n) -> 'List[Mapping[Any, Variable]]':\n from .dataarray import DataArray\n from .dataset import Dataset\n var_dicts = []\n for variables in list_of_variable_dicts:\n if isinstance(variables, Dataset):\n var_dicts.append(variables.variables)\n continue\n sanitized_vars = OrderedDict()\n for name, var in variables.items():\n if isinstance(var, DataArray):\n coords = var._coords.copy()\n coords.pop(name, None)\n var_dicts.append(coords)\n var = as_variable(var, name=name)\n sanitized_vars[name] = var\n var_dicts.append(sanitized_vars)\n return var_dicts", "docstring": "Given a list of dicts with xarray object values, expand the values.\n\n Parameters\n ----------\n list_of_variable_dicts : list of dict or Dataset objects\n Each value for the mappings must be of the following types:\n - an xarray.Variable\n - a tuple `(dims, data[, attrs[, encoding]])` that can be converted in\n an xarray.Variable\n - or an xarray.DataArray\n\n Returns\n -------\n A list of ordered dictionaries corresponding to inputs, or coordinates from\n an input's values. The values of each ordered dictionary are all\n xarray.Variable objects." }, { "code": "def getFeedContent(self, feed, excludeRead=False, continuation=None, loadLimit=20, since=None, until=None):\n return self._getFeedContent(feed.fetchUrl, excludeRead, continuation, loadLimit, since, until)", "docstring": "Return items for a particular feed" }, { "code": "def _write_iodir(self, iodir=None):\n if iodir is not None:\n self.iodir = iodir\n self.i2c.write_list(self.IODIR, self.iodir)", "docstring": "Write the specified byte value to the IODIR registor. If no value\n specified the current buffered value will be written." }, { "code": "def logger_init(level):\n levellist = [logging.ERROR, logging.WARNING, logging.INFO, logging.DEBUG]\n handler = logging.StreamHandler()\n fmt = ('%(levelname) -10s %(asctime)s %(name) -30s %(funcName) '\n '-35s %(lineno) -5d: %(message)s')\n handler.setFormatter(logging.Formatter(fmt))\n logger = logging.root\n logger.addHandler(handler)\n logger.setLevel(levellist[level])", "docstring": "Initialize the logger for this thread.\n\n Sets the log level to ERROR (0), WARNING (1), INFO (2), or DEBUG (3),\n depending on the argument `level`." }, { "code": "def agent_service_deregister(consul_url=None, token=None, serviceid=None):\n ret = {}\n data = {}\n if not consul_url:\n consul_url = _get_config()\n if not consul_url:\n log.error('No Consul URL found.')\n ret['message'] = 'No Consul URL found.'\n ret['res'] = False\n return ret\n if not serviceid:\n raise SaltInvocationError('Required argument \"serviceid\" is missing.')\n function = 'agent/service/deregister/{0}'.format(serviceid)\n res = _query(consul_url=consul_url,\n function=function,\n token=token,\n method='PUT',\n data=data)\n if res['res']:\n ret['res'] = True\n ret['message'] = 'Service {0} removed from agent.'.format(serviceid)\n else:\n ret['res'] = False\n ret['message'] = 'Unable to remove service {0}.'.format(serviceid)\n return ret", "docstring": "Used to remove a service.\n\n :param consul_url: The Consul server URL.\n :param serviceid: A serviceid describing the service.\n :return: Boolean and message indicating success or failure.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' consul.agent_service_deregister serviceid='redis'" }, { "code": "def read_url(url):\n logging.debug('reading {url} ...'.format(url=url))\n token = os.environ.get(\"BOKEH_GITHUB_API_TOKEN\")\n headers = {}\n if token:\n headers['Authorization'] = 'token %s' % token\n request = Request(url, headers=headers)\n response = urlopen(request).read()\n return json.loads(response.decode(\"UTF-8\"))", "docstring": "Reads given URL as JSON and returns data as loaded python object." }, { "code": "def apply_t0(self, hits):\n if HAVE_NUMBA:\n apply_t0_nb(\n hits.time, hits.dom_id, hits.channel_id, self._lookup_tables\n )\n else:\n n = len(hits)\n cal = np.empty(n)\n lookup = self._calib_by_dom_and_channel\n for i in range(n):\n calib = lookup[hits['dom_id'][i]][hits['channel_id'][i]]\n cal[i] = calib[6]\n hits.time += cal\n return hits", "docstring": "Apply only t0s" }, { "code": "def ping_directories_handler(sender, **kwargs):\n entry = kwargs['instance']\n if entry.is_visible and settings.SAVE_PING_DIRECTORIES:\n for directory in settings.PING_DIRECTORIES:\n DirectoryPinger(directory, [entry])", "docstring": "Ping directories when an entry is saved." }, { "code": "def viable_source_types_for_generator (generator):\n assert isinstance(generator, Generator)\n if generator not in __viable_source_types_cache:\n __vstg_cached_generators.append(generator)\n __viable_source_types_cache[generator] = viable_source_types_for_generator_real (generator)\n return __viable_source_types_cache[generator]", "docstring": "Caches the result of 'viable_source_types_for_generator'." }, { "code": "def __PrintMessageCommentLines(self, message_type):\n description = message_type.description or '%s message type.' % (\n message_type.name)\n width = self.__printer.CalculateWidth() - 3\n for line in textwrap.wrap(description, width):\n self.__printer('// %s', line)\n PrintIndentedDescriptions(self.__printer, message_type.enum_types,\n 'Enums', prefix='// ')\n PrintIndentedDescriptions(self.__printer, message_type.message_types,\n 'Messages', prefix='// ')\n PrintIndentedDescriptions(self.__printer, message_type.fields,\n 'Fields', prefix='// ')", "docstring": "Print the description of this message." }, { "code": "def script_post_save(model, os_path, contents_manager, **kwargs):\n from nbconvert.exporters.script import ScriptExporter\n if model['type'] != 'notebook':\n return\n global _script_exporter\n if _script_exporter is None:\n _script_exporter = ScriptExporter(parent=contents_manager)\n log = contents_manager.log\n base, ext = os.path.splitext(os_path)\n script, resources = _script_exporter.from_filename(os_path)\n script_fname = base + resources.get('output_extension', '.txt')\n log.info(\"Saving script /%s\", to_api_path(script_fname, contents_manager.root_dir))\n with io.open(script_fname, 'w', encoding='utf-8') as f:\n f.write(script)", "docstring": "convert notebooks to Python script after save with nbconvert\n\n replaces `ipython notebook --script`" }, { "code": "def get_option(self, option):\n value = getattr(self, option, None)\n if value is not None:\n return value\n return getattr(settings, \"COUNTRIES_{0}\".format(option.upper()))", "docstring": "Get a configuration option, trying the options attribute first and\n falling back to a Django project setting." }, { "code": "def send_command_ack(self, device_id, action):\n yield from self._ready_to_send.acquire()\n acknowledgement = None\n try:\n self._command_ack.clear()\n self.send_command(device_id, action)\n log.debug('waiting for acknowledgement')\n try:\n yield from asyncio.wait_for(self._command_ack.wait(),\n TIMEOUT.seconds, loop=self.loop)\n log.debug('packet acknowledged')\n except concurrent.futures._base.TimeoutError:\n acknowledgement = {'ok': False, 'message': 'timeout'}\n log.warning('acknowledge timeout')\n else:\n acknowledgement = self._last_ack.get('ok', False)\n finally:\n self._ready_to_send.release()\n return acknowledgement", "docstring": "Send command, wait for gateway to repond with acknowledgment." }, { "code": "def _get_sample(self, mode, encoding):\n self._open_file(mode, encoding)\n self._sample = self._file.read(UniversalCsvReader.sample_size)\n self._file.close()", "docstring": "Get a sample from the next current input file.\n\n :param str mode: The mode for opening the file.\n :param str|None encoding: The encoding of the file. None for open the file in binary mode." }, { "code": "def _get_obj_ct(self, obj):\n if not hasattr(obj, '_wfct'):\n if hasattr(obj, 'polymorphic_ctype'):\n obj._wfct = obj.polymorphic_ctype\n else:\n obj._wfct = ContentType.objects.get_for_model(obj)\n return obj._wfct", "docstring": "Look up and return object's content type and cache for reuse" }, { "code": "def getLogger(cls, name=None):\n return logging.getLogger(\"{0}.{1}\".format(cls.BASENAME, name) if name else cls.BASENAME)", "docstring": "Retrieves the Python native logger\n\n :param name: The name of the logger instance in the VSG namespace (VSG.); a None value will use the VSG root.\n :return: The instacne of the Python logger object." }, { "code": "def from_outcars_and_structures(cls, outcars, structures,\n calc_ionic_from_zval=False):\n p_elecs = []\n p_ions = []\n for i, o in enumerate(outcars):\n p_elecs.append(o.p_elec)\n if calc_ionic_from_zval:\n p_ions.append(\n get_total_ionic_dipole(structures[i], o.zval_dict))\n else:\n p_ions.append(o.p_ion)\n return cls(p_elecs, p_ions, structures)", "docstring": "Create Polarization object from list of Outcars and Structures in order\n of nonpolar to polar.\n\n Note, we recommend calculating the ionic dipole moment using calc_ionic\n than using the values in Outcar (see module comments). To do this set\n calc_ionic_from_zval = True" }, { "code": "def exists_alias(self, alias_name, index_name=None):\n return self._es_conn.indices.exists_alias(index=index_name, name=alias_name)", "docstring": "Check whether or not the given alias exists\n\n :return: True if alias already exist" }, { "code": "def Print(self):\n for hypo, prob in sorted(self.Items()):\n print(hypo, prob)", "docstring": "Prints the hypotheses and their probabilities." }, { "code": "def get_image_path(image_lists, label_name, index, image_dir, category):\n if label_name not in image_lists:\n tf.logging.fatal('Label does not exist %s.', label_name)\n label_lists = image_lists[label_name]\n if category not in label_lists:\n tf.logging.fatal('Category does not exist %s.', category)\n category_list = label_lists[category]\n if not category_list:\n tf.logging.fatal('Label %s has no images in the category %s.',\n label_name, category)\n mod_index = index % len(category_list)\n base_name = category_list[mod_index]\n sub_dir = label_lists['dir']\n full_path = os.path.join(image_dir, sub_dir, base_name)\n return full_path", "docstring": "Returns a path to an image for a label at the given index.\n\n Args:\n image_lists: OrderedDict of training images for each label.\n label_name: Label string we want to get an image for.\n index: Int offset of the image we want. This will be moduloed by the\n available number of images for the label, so it can be arbitrarily large.\n image_dir: Root folder string of the subfolders containing the training\n images.\n category: Name string of set to pull images from - training, testing, or\n validation.\n\n Returns:\n File system path string to an image that meets the requested parameters." }, { "code": "def report_onlysize(bytes_so_far, total_size, speed, eta):\n percent = int(bytes_so_far * 100 / total_size)\n current = approximate_size(bytes_so_far).center(10)\n total = approximate_size(total_size).center(10)\n sys.stdout.write('D: {0}% -{1}/{2}'.format(percent, current, total) + \"eta {0}\".format(eta))\n sys.stdout.write(\"\\r\")\n sys.stdout.flush()", "docstring": "This callback for the download function is used when console width\n is not enough to print the bar.\n It prints only the sizes" }, { "code": "def log(self, timer_name, node):\n timestamp = time.time()\n if hasattr(self, timer_name):\n getattr(self, timer_name).append({\n \"node\":node,\n \"time\":timestamp})\n else:\n setattr(self, timer_name, [{\"node\":node, \"time\":timestamp}])", "docstring": "logs a event in the timer" }, { "code": "def __getFileObj(self, f):\r\n if not f:\r\n raise ShapefileException(\"No file-like object available.\")\r\n elif hasattr(f, \"write\"):\r\n return f\r\n else:\r\n pth = os.path.split(f)[0]\r\n if pth and not os.path.exists(pth):\r\n os.makedirs(pth)\r\n return open(f, \"wb+\")", "docstring": "Safety handler to verify file-like objects" }, { "code": "def custom_template_name(self):\n base_path = getattr(settings, \"CUSTOM_SPECIAL_COVERAGE_PATH\", \"special_coverage/custom\")\n if base_path is None:\n base_path = \"\"\n return \"{0}/{1}_custom.html\".format(\n base_path, self.slug.replace(\"-\", \"_\")\n ).lstrip(\"/\")", "docstring": "Returns the path for the custom special coverage template we want." }, { "code": "def _update_show_toolbars_action(self):\r\n if self.toolbars_visible:\r\n text = _(\"Hide toolbars\")\r\n tip = _(\"Hide toolbars\")\r\n else:\r\n text = _(\"Show toolbars\")\r\n tip = _(\"Show toolbars\")\r\n self.show_toolbars_action.setText(text)\r\n self.show_toolbars_action.setToolTip(tip)", "docstring": "Update the text displayed in the menu entry." }, { "code": "async def pulse(self):\n get_state = GetState(pyvlx=self.pyvlx)\n await get_state.do_api_call()\n if not get_state.success:\n raise PyVLXException(\"Unable to send get state.\")", "docstring": "Send get state request to API to keep the connection alive." }, { "code": "def wrap(self, row: Union[Mapping[str, Any], Sequence[Any]]):\n return (\n self.dataclass(\n **{\n ident: row[column_name]\n for ident, column_name in self.ids_and_column_names.items()\n }\n )\n if isinstance(row, Mapping)\n else self.dataclass(\n **{ident: val for ident, val in zip(self.ids_and_column_names.keys(), row)}\n )\n )", "docstring": "Return row tuple for row." }, { "code": "def get_version():\n _globals = {}\n _locals = {}\n exec(\n compile(\n open(TOP + \"/manta/version.py\").read(), TOP + \"/manta/version.py\",\n 'exec'), _globals, _locals)\n return _locals[\"__version__\"]", "docstring": "Get the python-manta version without having to import the manta package,\n which requires deps to already be installed." }, { "code": "def encode_hook(self, hook, msg):\n if 'name' in hook:\n msg.name = str_to_bytes(hook['name'])\n else:\n self.encode_modfun(hook, msg.modfun)\n return msg", "docstring": "Encodes a commit hook dict into the protobuf message. Used in\n bucket properties.\n\n :param hook: the hook to encode\n :type hook: dict\n :param msg: the protobuf message to fill\n :type msg: riak.pb.riak_pb2.RpbCommitHook\n :rtype riak.pb.riak_pb2.RpbCommitHook" }, { "code": "def _format_type_in_doc(self, namespace, data_type):\n if is_void_type(data_type):\n return 'None'\n elif is_user_defined_type(data_type):\n return ':class:`{}.{}.{}`'.format(\n self.args.types_package, namespace.name, fmt_type(data_type))\n else:\n return fmt_type(data_type)", "docstring": "Returns a string that can be recognized by Sphinx as a type reference\n in a docstring." }, { "code": "def enum(cls, options, values):\n names, real = zip(*options)\n del names\n def factory(i, name):\n return cls(i, name, (len(real),), lambda a: real[a[0]], values)\n return factory", "docstring": "Create an ArgumentType where you choose one of a set of known values." }, { "code": "def inspect_filter_calculation(self):\n try:\n node = self.ctx.cif_filter\n self.ctx.cif = node.outputs.cif\n except exceptions.NotExistent:\n self.report('aborting: CifFilterCalculation<{}> did not return the required cif output'.format(node.uuid))\n return self.exit_codes.ERROR_CIF_FILTER_FAILED", "docstring": "Inspect the result of the CifFilterCalculation, verifying that it produced a CifData output node." }, { "code": "def main():\n logging.basicConfig()\n logger.info(\"mmi-runner\")\n warnings.warn(\n \"You are using the mmi-runner script, please switch to `mmi runner`\",\n DeprecationWarning\n )\n arguments = docopt.docopt(__doc__)\n kwargs = parse_args(arguments)\n runner = mmi.runner.Runner(\n **kwargs\n )\n runner.run()", "docstring": "run mmi runner" }, { "code": "def getVisibility(self):\n try:\n if self.map[GET_VISIBILITY_PROPERTY] == 'VISIBLE':\n return VISIBLE\n elif self.map[GET_VISIBILITY_PROPERTY] == 'INVISIBLE':\n return INVISIBLE\n elif self.map[GET_VISIBILITY_PROPERTY] == 'GONE':\n return GONE\n else:\n return -2\n except:\n return -1", "docstring": "Gets the View visibility" }, { "code": "def unbind(self, handler, argspec):\n self.handlers[argspec.key].remove((handler, argspec))\n if not len(self.handlers[argspec.key]):\n del self.handlers[argspec.key]", "docstring": "handler will no longer be called if args match argspec\n\n :param argspec: instance of ArgSpec - args to be matched" }, { "code": "def listrecursive(path, ext=None):\n filenames = set()\n for root, dirs, files in os.walk(path):\n if ext:\n if ext == 'tif' or ext == 'tiff':\n tmp = fnmatch.filter(files, '*.' + 'tiff')\n files = tmp + fnmatch.filter(files, '*.' + 'tif')\n else:\n files = fnmatch.filter(files, '*.' + ext)\n for filename in files:\n filenames.add(os.path.join(root, filename))\n filenames = list(filenames)\n filenames.sort()\n return sorted(filenames)", "docstring": "List files recurisvely" }, { "code": "def get_fetcher_assets(self, dt):\n if self._extra_source_df is None:\n return []\n day = normalize_date(dt)\n if day in self._extra_source_df.index:\n assets = self._extra_source_df.loc[day]['sid']\n else:\n return []\n if isinstance(assets, pd.Series):\n return [x for x in assets if isinstance(x, Asset)]\n else:\n return [assets] if isinstance(assets, Asset) else []", "docstring": "Returns a list of assets for the current date, as defined by the\n fetcher data.\n\n Returns\n -------\n list: a list of Asset objects." }, { "code": "def is_job_done(job_id, conn=None):\n result = False\n get_done = RBJ.get_all(DONE, index=STATUS_FIELD)\n for item in get_done.filter({ID_FIELD: job_id}).run(conn):\n result = item\n return result", "docstring": "is_job_done function checks to if Brain.Jobs Status is 'Done'\n\n :param job_id: id for the job\n :param conn: (optional) to run on\n :return: if job is done if" }, { "code": "def mnemonic(self, value):\n if value not in REIL_MNEMONICS:\n raise Exception(\"Invalid instruction mnemonic : %s\" % str(value))\n self._mnemonic = value", "docstring": "Set instruction mnemonic." }, { "code": "def pause(self):\n self._mq.send(\"p\", True, type=1)\n self._paused = True", "docstring": "Pause pulse capture" }, { "code": "def apply_and_save(self):\n patches = self.patches\n content = None\n with open(self.IN_PATH) as f_in:\n content = f_in.read()\n for key in self.replaced_word_dict:\n content = content.replace(key, self.replaced_word_dict[key])\n out_patches = []\n for patch in patches:\n pattern = re.compile(patch['src'], re.MULTILINE)\n (content, subs_num) = re.subn(pattern, patch['dest'],\n content)\n if subs_num > 0:\n patch['applied'] = True\n out_patches.append(patch)\n for patch in out_patches:\n if patch.get('required') and not patch.get('applied'):\n Log.warn('Patch not applied {0}'.format(patch['src']))\n with open(self.OUT_PATH, 'w') as f_out:\n f_out.write(content)\n self.pathces = out_patches\n content = None", "docstring": "Apply replaced words and patches, and save setup.py file." }, { "code": "def sas_interconnect_types(self):\n if not self.__sas_interconnect_types:\n self.__sas_interconnect_types = SasInterconnectTypes(self.__connection)\n return self.__sas_interconnect_types", "docstring": "Gets the SasInterconnectTypes API client.\n\n Returns:\n SasInterconnectTypes:" }, { "code": "def pull_all_external(collector, **kwargs):\n deps = set()\n images = collector.configuration[\"images\"]\n for layer in Builder().layered(images):\n for image_name, image in layer:\n for dep in image.commands.external_dependencies:\n deps.add(dep)\n for dep in sorted(deps):\n kwargs[\"image\"] = dep\n pull_arbitrary(collector, **kwargs)", "docstring": "Pull all the external dependencies of all the images" }, { "code": "def shutdown(message=None, timeout=5, force_close=True, reboot=False,\n in_seconds=False, only_on_pending_reboot=False):\n if six.PY2:\n message = _to_unicode(message)\n timeout = _convert_minutes_seconds(timeout, in_seconds)\n if only_on_pending_reboot and not get_pending_reboot():\n return False\n if message and not isinstance(message, six.string_types):\n message = message.decode('utf-8')\n try:\n win32api.InitiateSystemShutdown('127.0.0.1', message, timeout,\n force_close, reboot)\n return True\n except pywintypes.error as exc:\n (number, context, message) = exc.args\n log.error('Failed to shutdown the system')\n log.error('nbr: %s', number)\n log.error('ctx: %s', context)\n log.error('msg: %s', message)\n return False", "docstring": "Shutdown a running system.\n\n Args:\n\n message (str):\n The message to display to the user before shutting down.\n\n timeout (int):\n The length of time (in seconds) that the shutdown dialog box should\n be displayed. While this dialog box is displayed, the shutdown can\n be aborted using the ``system.shutdown_abort`` function.\n\n If timeout is not zero, InitiateSystemShutdown displays a dialog box\n on the specified computer. The dialog box displays the name of the\n user who called the function, the message specified by the lpMessage\n parameter, and prompts the user to log off. The dialog box beeps\n when it is created and remains on top of other windows (system\n modal). The dialog box can be moved but not closed. A timer counts\n down the remaining time before the shutdown occurs.\n\n If timeout is zero, the computer shuts down immediately without\n displaying the dialog box and cannot be stopped by\n ``system.shutdown_abort``.\n\n Default is 5 minutes\n\n in_seconds (bool):\n ``True`` will cause the ``timeout`` parameter to be in seconds.\n ``False`` will be in minutes. Default is ``False``.\n\n .. versionadded:: 2015.8.0\n\n force_close (bool):\n ``True`` will force close all open applications. ``False`` will\n display a dialog box instructing the user to close open\n applications. Default is ``True``.\n\n reboot (bool):\n ``True`` restarts the computer immediately after shutdown. ``False``\n powers down the system. Default is ``False``.\n\n only_on_pending_reboot (bool): If this is set to True, then the shutdown\n will only proceed if the system reports a pending reboot. To\n optionally shutdown in a highstate, consider using the shutdown\n state instead of this module.\n\n only_on_pending_reboot (bool):\n If ``True`` the shutdown will only proceed if there is a reboot\n pending. ``False`` will shutdown the system. Default is ``False``.\n\n Returns:\n bool:\n ``True`` if successful (a shutdown or reboot will occur), otherwise\n ``False``\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' system.shutdown \"System will shutdown in 5 minutes\"" }, { "code": "def filter(self, local_name=None, name=None, ns_uri=None, node_type=None,\n filter_fn=None, first_only=False):\n if filter_fn is None:\n def filter_fn(n):\n if node_type is not None:\n if isinstance(node_type, int):\n if not n.is_type(node_type):\n return False\n elif n.__class__ != node_type:\n return False\n if name is not None and n.name != name:\n return False\n if local_name is not None and n.local_name != local_name:\n return False\n if ns_uri is not None and n.ns_uri != ns_uri:\n return False\n return True\n nodelist = filter(filter_fn, self)\n if first_only:\n return nodelist[0] if nodelist else None\n else:\n return NodeList(nodelist)", "docstring": "Apply filters to the set of nodes in this list.\n\n :param local_name: a local name used to filter the nodes.\n :type local_name: string or None\n :param name: a name used to filter the nodes.\n :type name: string or None\n :param ns_uri: a namespace URI used to filter the nodes.\n If *None* all nodes are returned regardless of namespace.\n :type ns_uri: string or None\n :param node_type: a node type definition used to filter the nodes.\n :type node_type: int node type constant, class, or None\n :param filter_fn: an arbitrary function to filter nodes in this list.\n This function must accept a single :class:`Node` argument and\n return a bool indicating whether to include the node in the\n filtered results.\n\n .. note:: if ``filter_fn`` is provided all other filter arguments\n are ignore.\n :type filter_fn: function or None\n\n :return: the type of the return value depends on the value of the\n ``first_only`` parameter and how many nodes match the filter:\n\n - if ``first_only=False`` return a :class:`NodeList` of filtered\n nodes, which will be empty if there are no matching nodes.\n - if ``first_only=True`` and at least one node matches,\n return the first matching :class:`Node`\n - if ``first_only=True`` and there are no matching nodes,\n return *None*" }, { "code": "def _modifyItemTag(self, item_id, action, tag):\n return self.httpPost(ReaderUrl.EDIT_TAG_URL,\n {'i': item_id, action: tag, 'ac': 'edit-tags'})", "docstring": "wrapper around actual HTTP POST string for modify tags" }, { "code": "def process(self, metric):\n if not boto:\n return\n collector = str(metric.getCollectorPath())\n metricname = str(metric.getMetricPath())\n for rule in self.rules:\n self.log.debug(\n \"Comparing Collector: [%s] with (%s) \"\n \"and Metric: [%s] with (%s)\",\n str(rule['collector']),\n collector,\n str(rule['metric']),\n metricname\n )\n if ((str(rule['collector']) == collector and\n str(rule['metric']) == metricname)):\n if rule['collect_by_instance'] and self.instance_id:\n self.send_metrics_to_cloudwatch(\n rule,\n metric,\n {'InstanceId': self.instance_id})\n if rule['collect_without_dimension']:\n self.send_metrics_to_cloudwatch(\n rule,\n metric,\n {})", "docstring": "Process a metric and send it to CloudWatch" }, { "code": "def get_arrays_from_file(params_file, params=None):\n try:\n f = h5py.File(params_file, 'r')\n except:\n raise ValueError('File not found.')\n if params is not None:\n if not isinstance(params, list):\n params = [params]\n for p in params:\n if p not in f.keys():\n raise ValueError('Parameter {} is not in {}'\n .format(p, params_file))\n else:\n params = [str(k) for k in f.keys()]\n params_values = {p:f[p][:] for p in params}\n try:\n bandwidth = f.attrs[\"bandwidth\"]\n except KeyError:\n bandwidth = \"scott\"\n f.close()\n return params_values, bandwidth", "docstring": "Reads the values of one or more parameters from an hdf file and\n returns as a dictionary.\n\n Parameters\n ----------\n params_file : str\n The hdf file that contains the values of the parameters.\n params : {None, list}\n If provided, will just retrieve the given parameter names.\n\n Returns\n -------\n dict\n A dictionary of the parameters mapping `param_name -> array`." }, { "code": "def get_file_listing_sha(listing_paths: Iterable) -> str:\n return sha256(''.join(sorted(listing_paths)).encode('utf-8')).hexdigest()", "docstring": "Return sha256 string for group of FTP listings." }, { "code": "def _shutdown_unlocked(self, context, lru=None, new_context=None):\n LOG.info('%r._shutdown_unlocked(): shutting down %r', self, context)\n context.shutdown()\n via = self._via_by_context.get(context)\n if via:\n lru = self._lru_by_via.get(via)\n if lru:\n if context in lru:\n lru.remove(context)\n if new_context:\n lru.append(new_context)\n self._forget_context_unlocked(context)", "docstring": "Arrange for `context` to be shut down, and optionally add `new_context`\n to the LRU list while holding the lock." }, { "code": "def clear(self):\n if os.path.exists(self.path):\n os.remove(self.path)", "docstring": "Remove all existing done markers and the file used to store the dones." }, { "code": "def create_appointment_group(self, appointment_group, **kwargs):\n from canvasapi.appointment_group import AppointmentGroup\n if (\n isinstance(appointment_group, dict) and\n 'context_codes' in appointment_group and\n 'title' in appointment_group\n ):\n kwargs['appointment_group'] = appointment_group\n elif (\n isinstance(appointment_group, dict) and\n 'context_codes' not in appointment_group\n ):\n raise RequiredFieldMissing(\n \"Dictionary with key 'context_codes' is missing.\"\n )\n elif isinstance(appointment_group, dict) and 'title' not in appointment_group:\n raise RequiredFieldMissing(\"Dictionary with key 'title' is missing.\")\n response = self.__requester.request(\n 'POST',\n 'appointment_groups',\n _kwargs=combine_kwargs(**kwargs)\n )\n return AppointmentGroup(self.__requester, response.json())", "docstring": "Create a new Appointment Group.\n\n :calls: `POST /api/v1/appointment_groups \\\n `_\n\n :param appointment_group: The attributes of the appointment group.\n :type appointment_group: `dict`\n :param title: The title of the appointment group.\n :type title: `str`\n :rtype: :class:`canvasapi.appointment_group.AppointmentGroup`" }, { "code": "def claim_exp(self, data):\n expiration = getattr(settings, 'OAUTH_ID_TOKEN_EXPIRATION', 30)\n expires = self.now + timedelta(seconds=expiration)\n return timegm(expires.utctimetuple())", "docstring": "Required expiration time." }, { "code": "def request(self, method, params):\n identifier = random.randint(1, 1000)\n self._transport.write(jsonrpc_request(method, identifier, params))\n self._buffer[identifier] = {'flag': asyncio.Event()}\n yield from self._buffer[identifier]['flag'].wait()\n result = self._buffer[identifier]['data']\n del self._buffer[identifier]['data']\n return result", "docstring": "Send a JSONRPC request." }, { "code": "def update_ngram(self, ngram, count):\n query = \"UPDATE _{0}_gram SET count = {1}\".format(len(ngram), count)\n query += self._build_where_clause(ngram)\n query += \";\"\n self.execute_sql(query)", "docstring": "Updates a given ngram in the database. The ngram has to be in the\n database, otherwise this method will stop with an error.\n\n Parameters\n ----------\n ngram : iterable of str\n A list, set or tuple of strings.\n count : int\n The count for the given n-gram." }, { "code": "def _prepare_load_balancers(self):\n stack = {\n A.NAME: self[A.NAME],\n A.VERSION: self[A.VERSION],\n }\n for load_balancer in self.get(R.LOAD_BALANCERS, []):\n svars = {A.STACK: stack}\n load_balancer[A.loadbalancer.VARS] = svars", "docstring": "Prepare load balancer variables" }, { "code": "def build_message(self, stat, value):\n return ' '.join((self.prefix + str(stat), str(value), str(round(time()))))", "docstring": "Build a metric in Graphite format." }, { "code": "def get_multiplicon_seeds(self, redundant=False):\n for node in self._multiplicon_graph.nodes():\n if not len(self._multiplicon_graph.in_edges(node)):\n if not self.is_redundant_multiplicon(node):\n yield node\n elif redundant:\n yield node\n else:\n continue\n else:\n continue", "docstring": "Return a generator of the IDs of multiplicons that are initial\n seeding 'pairs' in level 2 multiplicons.\n\n Arguments:\n\n o redundant - if true, report redundant multiplicons" }, { "code": "def _cls_fqn(self, cls):\n ns = self._namespace_stack[-1]\n if ns in ['__base__', None]:\n return cls.__name__\n else:\n return ns + '.' + cls.__name__", "docstring": "Returns fully qualified name for the class based on current namespace\n and the class name." }, { "code": "def eval_constraints(self, constraints):\n try:\n return all(self.eval_ast(c) for c in constraints)\n except errors.ClaripyZeroDivisionError:\n return False", "docstring": "Returns whether the constraints is satisfied trivially by using the\n last model." }, { "code": "def random_subset_ids_by_count(self, count_per_class=1):\n class_sizes = self.class_sizes\n subsets = list()\n if count_per_class < 1:\n warnings.warn('Atleast one sample must be selected from each class')\n return list()\n elif count_per_class >= self.num_samples:\n warnings.warn('All samples requested - returning a copy!')\n return self.keys\n for class_id, class_size in class_sizes.items():\n this_class = self.keys_with_value(self.classes, class_id)\n random.shuffle(this_class)\n subset_size_this_class = max(0, min(class_size, count_per_class))\n if subset_size_this_class < 1 or this_class is None:\n warnings.warn('No subjects from class {} were selected.'.format(class_id))\n else:\n subsets_this_class = this_class[0:count_per_class]\n subsets.extend(subsets_this_class)\n if len(subsets) > 0:\n return subsets\n else:\n warnings.warn('Zero samples were selected. Returning an empty list!')\n return list()", "docstring": "Returns a random subset of sample ids of specified size by count,\n within each class.\n\n Parameters\n ----------\n count_per_class : int\n Exact number of samples per each class.\n\n Returns\n -------\n subset : list\n Combined list of sample ids from all classes." }, { "code": "def score(self, env=None, score_out=None):\n messages = {}\n self.assignment.set_args(\n score=True,\n score_out=score_out,\n )\n if env is None:\n import __main__\n env = __main__.__dict__\n self.run('scoring', messages, env=env)\n return messages['scoring']", "docstring": "Run the scoring protocol.\n\n score_out -- str; a file name to write the point breakdown\n into.\n\n Returns: dict; maps score tag (str) -> points (float)" }, { "code": "def interconnect_all(self):\n for dep in topologically_sorted(self._provides):\n if hasattr(dep, '__injections__') and not hasattr(dep, '__injections_source__'):\n self.inject(dep)", "docstring": "Propagate dependencies for provided instances" }, { "code": "def _update_task(self, task):\n self.task = task\n self.task.data.update(self.task_data)\n self.task_type = task.task_spec.__class__.__name__\n self.spec = task.task_spec\n self.task_name = task.get_name()\n self.activity = getattr(self.spec, 'service_class', '')\n self._set_lane_data()", "docstring": "Assigns current task step to self.task\n then updates the task's data with self.task_data\n\n Args:\n task: Task object." }, { "code": "def add_how(voevent, descriptions=None, references=None):\n if not voevent.xpath('How'):\n etree.SubElement(voevent, 'How')\n if descriptions is not None:\n for desc in _listify(descriptions):\n etree.SubElement(voevent.How, 'Description')\n voevent.How.Description[-1] = desc\n if references is not None:\n voevent.How.extend(_listify(references))", "docstring": "Add descriptions or references to the How section.\n\n Args:\n voevent(:class:`Voevent`): Root node of a VOEvent etree.\n descriptions(str): Description string, or list of description\n strings.\n references(:py:class:`voeventparse.misc.Reference`): A reference element\n (or list thereof)." }, { "code": "def move_into(self, destination_folder):\n headers = self.headers\n endpoint = 'https://outlook.office.com/api/v2.0/me/MailFolders/' + self.id + '/move'\n payload = '{ \"DestinationId\": \"' + destination_folder.id + '\"}'\n r = requests.post(endpoint, headers=headers, data=payload)\n if check_response(r):\n return_folder = r.json()\n return self._json_to_folder(self.account, return_folder)", "docstring": "Move the Folder into a different folder.\n\n This makes the Folder provided a child folder of the destination_folder.\n\n Raises:\n AuthError: Raised if Outlook returns a 401, generally caused by an invalid or expired access token.\n\n Args:\n destination_folder: A :class:`Folder ` that should become the parent\n\n Returns:\n A new :class:`Folder ` that is now\n inside of the destination_folder." }, { "code": "def init_app(self, app):\n host = app.config.get('STATS_HOSTNAME', 'localhost')\n port = app.config.get('STATS_PORT', 8125)\n base_key = app.config.get('STATS_BASE_KEY', app.name)\n client = _StatsClient(\n host=host,\n port=port,\n prefix=base_key,\n )\n app.before_request(client.flask_time_start)\n app.after_request(client.flask_time_end)\n if not hasattr(app, 'extensions'):\n app.extensions = {}\n app.extensions.setdefault('stats', {})\n app.extensions['stats'][self] = client\n return client", "docstring": "Inititialise the extension with the app object.\n\n :param app: Your application object" }, { "code": "def defaultSystem():\n rsystem = platform.system()\n if rsystem in os_canon:\n rsystem = os_canon[rsystem][0]\n return rsystem", "docstring": "Return the canonicalized system name." }, { "code": "def __parse(self) -> object:\n char = self.data[self.idx: self.idx + 1]\n if char in [b'1', b'2', b'3', b'4', b'5', b'6', b'7', b'8', b'9', b'0']:\n str_len = int(self.__read_to(b':'))\n return self.__read(str_len)\n elif char == b'i':\n self.idx += 1\n return int(self.__read_to(b'e'))\n elif char == b'd':\n return self.__parse_dict()\n elif char == b'l':\n return self.__parse_list()\n elif char == b'':\n raise bencodepy.DecodingError('Unexpected End of File at index position of {0}.'.format(str(self.idx)))\n else:\n raise bencodepy.DecodingError(\n 'Invalid token character ({0}) at position {1}.'.format(str(char), str(self.idx)))", "docstring": "Selects the appropriate method to decode next bencode element and returns the result." }, { "code": "def restore_row(self, row, schema):\n row = list(row)\n for index, field in enumerate(schema.fields):\n if self.__dialect == 'postgresql':\n if field.type in ['array', 'object']:\n continue\n row[index] = field.cast_value(row[index])\n return row", "docstring": "Restore row from SQL" }, { "code": "def get_transactions(self, include_investment=False):\n assert_pd()\n s = StringIO(self.get_transactions_csv(\n include_investment=include_investment))\n s.seek(0)\n df = pd.read_csv(s, parse_dates=['Date'])\n df.columns = [c.lower().replace(' ', '_') for c in df.columns]\n df.category = (df.category.str.lower()\n .replace('uncategorized', pd.np.nan))\n return df", "docstring": "Returns the transaction data as a Pandas DataFrame." }, { "code": "def change_nick(self, nick):\n old_nick = self.nick\n self.nick = IRCstr(nick)\n for c in self.channels:\n c.users.remove(old_nick)\n c.users.add(self.nick)", "docstring": "Update this user's nick in all joined channels." }, { "code": "def setup_ssh_tunnel(job_id, local_port, remote_port):\n cmd = ['dx', 'ssh', '--suppress-running-check', job_id, '-o', 'StrictHostKeyChecking no']\n cmd += ['-f', '-L', '{0}:localhost:{1}'.format(local_port, remote_port), '-N']\n subprocess.check_call(cmd)", "docstring": "Setup an ssh tunnel to the given job-id. This will establish\n the port over the given local_port to the given remote_port\n and then exit, keeping the tunnel in place until the job is\n terminated." }, { "code": "def save(self):\n if self.rater is not None:\n self.rater.set('modified', datetime.now().isoformat())\n xml = parseString(tostring(self.root))\n with open(self.xml_file, 'w') as f:\n f.write(xml.toxml())", "docstring": "Save xml to file." }, { "code": "def delete(self, monitor_id):\n if not self._state:\n raise InvalidState(\"State was not properly obtained from the app\")\n monitors = self.list()\n bit = None\n for monitor in monitors:\n if monitor_id != monitor['monitor_id']:\n continue\n bit = monitor['monitor_id']\n if not bit:\n raise MonitorNotFound(\"No monitor was found with that term.\")\n url = self.ALERTS_DELETE_URL.format(requestX=self._state[3])\n self._log.debug(\"Deleting alert using: %s\" % url)\n payload = [None, monitor_id]\n params = json.dumps(payload, separators=(',', ':'))\n data = {'params': params}\n response = self._session.post(url, data=data, headers=self.HEADERS)\n if response.status_code != 200:\n raise ActionError(\"Failed to delete by ID: %s\"\n % response.content)\n return True", "docstring": "Delete a monitor by ID." }, { "code": "def undo(self):\n _, _, undo_state = self._undo_stack.back()\n spike_clusters_new = self._spike_clusters_base.copy()\n for spike_ids, cluster_ids, _ in self._undo_stack:\n if spike_ids is not None:\n spike_clusters_new[spike_ids] = cluster_ids\n changed = np.nonzero(self._spike_clusters !=\n spike_clusters_new)[0]\n clusters_changed = spike_clusters_new[changed]\n up = self._do_assign(changed, clusters_changed)\n up.history = 'undo'\n up.undo_state = undo_state\n self.emit('cluster', up)\n return up", "docstring": "Undo the last cluster assignment operation.\n\n Returns\n -------\n\n up : UpdateInfo instance of the changes done by this operation." }, { "code": "def get_all_chats(self):\n chats = self.wapi_functions.getAllChats()\n if chats:\n return [factory_chat(chat, self) for chat in chats]\n else:\n return []", "docstring": "Fetches all chats\n\n :return: List of chats\n :rtype: list[Chat]" }, { "code": "def get_all_longest_col_lengths(self):\n response = {}\n for col in self.col_list:\n response[col] = self._longest_val_in_column(col)\n return response", "docstring": "iterate over all columns and get their longest values\n\n :return: dict, {\"column_name\": 132}" }, { "code": "def profile(fun, *args, **kwargs):\n timer_name = kwargs.pop(\"prof_name\", None)\n if not timer_name:\n module = inspect.getmodule(fun)\n c = [module.__name__]\n parentclass = labtypes.get_class_that_defined_method(fun)\n if parentclass:\n c.append(parentclass.__name__)\n c.append(fun.__name__)\n timer_name = \".\".join(c)\n start(timer_name)\n ret = fun(*args, **kwargs)\n stop(timer_name)\n return ret", "docstring": "Profile a function." }, { "code": "def list_of(validate_item):\n def validate(value, should_raise=True):\n validate_type = is_type(list)\n if not validate_type(value, should_raise=should_raise):\n return False\n for item in value:\n try:\n validate_item(item)\n except TypeError as e:\n if should_raise:\n samtranslator.model.exceptions.prepend(e, \"list contained an invalid item\")\n raise\n return False\n return True\n return validate", "docstring": "Returns a validator function that succeeds only if the input is a list, and each item in the list passes as input\n to the provided validator validate_item.\n\n :param callable validate_item: the validator function for items in the list\n :returns: a function which returns True its input is an list of valid items, and raises TypeError otherwise\n :rtype: callable" }, { "code": "def set_of(*generators):\n class SetOfGenerators(ArbitraryInterface):\n @classmethod\n def arbitrary(cls):\n arbitrary_set = set()\n for generator in generators:\n arbitrary_set |= {\n arbitrary(generator)\n for _ in range(arbitrary(int) % 100)\n }\n return arbitrary_set\n SetOfGenerators.__name__ = ''.join([\n 'set_of(', ', '.join(generator.__name__ for generator in generators),\n ')'\n ])\n return SetOfGenerators", "docstring": "Generates a set consisting solely of the specified generators.\n This is a class factory, it makes a class which is a closure around the\n specified generators." }, { "code": "def deepSetAttr(obj, path, val):\n first, _, rest = path.rpartition('.')\n return setattr(deepGetAttr(obj, first) if first else obj, rest, val)", "docstring": "Sets a deep attribute on an object by resolving a dot-delimited\n path. If path does not exist an `AttributeError` will be raised`." }, { "code": "def periodogram_auto(self, oversampling=5, nyquist_factor=3,\n return_periods=True):\n N = len(self.t)\n T = np.max(self.t) - np.min(self.t)\n df = 1. / T / oversampling\n f0 = df\n Nf = int(0.5 * oversampling * nyquist_factor * N)\n freq = f0 + df * np.arange(Nf)\n return 1. / freq, self._score_frequency_grid(f0, df, Nf)", "docstring": "Compute the periodogram on an automatically-determined grid\n\n This function uses heuristic arguments to choose a suitable frequency\n grid for the data. Note that depending on the data window function,\n the model may be sensitive to periodicity at higher frequencies than\n this function returns!\n\n The final number of frequencies will be\n Nf = oversampling * nyquist_factor * len(t) / 2\n\n Parameters\n ----------\n oversampling : float\n the number of samples per approximate peak width\n nyquist_factor : float\n the highest frequency, in units of the nyquist frequency for points\n spread uniformly through the data range.\n\n Returns\n -------\n period : ndarray\n the grid of periods\n power : ndarray\n the power at each frequency" }, { "code": "def is_discrete(self):\n return self.bounds[1] == self.bounds[0] and\\\n self.included == (True,True)", "docstring": "Check whether this interval contains exactly one number\n\n :rtype: bool" }, { "code": "def to_df(self, method: str = 'MEMORY', **kwargs) -> 'pd.DataFrame':\n ll = self._is_valid()\n if ll:\n print(ll['LOG'])\n return None\n else:\n return self.sas.sasdata2dataframe(self.table, self.libref, self.dsopts, method, **kwargs)", "docstring": "Export this SAS Data Set to a Pandas Data Frame\n\n :param method: defaults to MEMORY; the original method. CSV is the other choice which uses an intermediary csv file; faster for large data\n :param kwargs:\n :return: Pandas data frame" }, { "code": "def start_all_linking(self, link_type, group_id):\n self.logger.info(\"start_all_linking for type %s group %s\",\n link_type, group_id)\n self.direct_command_hub('0264' + link_type + group_id)", "docstring": "Begin all linking" }, { "code": "def entity_list(args):\n r = fapi.get_entities_with_type(args.project, args.workspace)\n fapi._check_response_code(r, 200)\n return [ '{0}\\t{1}'.format(e['entityType'], e['name']) for e in r.json() ]", "docstring": "List entities in a workspace." }, { "code": "def all_equal(keys, axis=semantics.axis_default):\n index = as_index(keys, axis)\n return index.groups == 1", "docstring": "returns true of all keys are equal" }, { "code": "def draw(self):\n nodes_pos = {}\n for node in self.graph.nodes():\n nodes_pos[node] = (node.geom.x, node.geom.y)\n plt.figure()\n nx.draw_networkx(self.graph, nodes_pos, node_size=16, font_size=8)\n plt.show()", "docstring": "Draw MV grid's graph using the geo data of nodes\n\n Notes\n -----\n This method uses the coordinates stored in the nodes' geoms which\n are usually conformal, not equidistant. Therefore, the plot might\n be distorted and does not (fully) reflect the real positions or\n distances between nodes." }, { "code": "def convert_string(string):\n if is_int(string):\n return int(string)\n elif is_float(string):\n return float(string)\n elif convert_bool(string)[0]:\n return convert_bool(string)[1]\n elif string == 'None':\n return None\n else:\n return string", "docstring": "Convert string to int, float or bool." }, { "code": "def toml(uncertainty):\n text = uncertainty.text.strip()\n if not text.startswith('['):\n text = '[%s]' % text\n for k, v in uncertainty.attrib.items():\n try:\n v = ast.literal_eval(v)\n except ValueError:\n v = repr(v)\n text += '\\n%s = %s' % (k, v)\n return text", "docstring": "Converts an uncertainty node into a TOML string" }, { "code": "def start(self, children):\n composites = []\n for composite_dict in children:\n if False and self.include_position:\n key_token = composite_dict[1]\n key_name = key_token.value.lower()\n composites_position = self.get_position_dict(composite_dict)\n composites_position[key_name] = self.create_position_dict(key_token, None)\n composites.append(composite_dict)\n if len(composites) == 1:\n return composites[0]\n else:\n return composites", "docstring": "Parses a MapServer Mapfile\n Parsing of partial Mapfiles or lists of composites is also possible" }, { "code": "def from_wif(cls, wif, network=BitcoinMainNet):\n wif = ensure_str(wif)\n try:\n extended_key_bytes = base58.b58decode_check(wif)\n except ValueError as e:\n raise ChecksumException(e)\n network_bytes = extended_key_bytes[0]\n if not isinstance(network_bytes, six.integer_types):\n network_bytes = ord(network_bytes)\n if (network_bytes != network.SECRET_KEY):\n raise incompatible_network_exception_factory(\n network_name=network.NAME,\n expected_prefix=network.SECRET_KEY,\n given_prefix=network_bytes)\n extended_key_bytes = extended_key_bytes[1:]\n compressed = False\n if len(extended_key_bytes) == 33:\n extended_key_bytes = extended_key_bytes[:-1]\n compressed = True\n return cls(long_or_int(hexlify(extended_key_bytes), 16), network,\n compressed=compressed)", "docstring": "Import a key in WIF format.\n\n WIF is Wallet Import Format. It is a base58 encoded checksummed key.\n See https://en.bitcoin.it/wiki/Wallet_import_format for a full\n description.\n\n This supports compressed WIFs - see this for an explanation:\n http://bitcoin.stackexchange.com/questions/7299/when-importing-private-keys-will-compressed-or-uncompressed-format-be-used # nopep8\n (specifically http://bitcoin.stackexchange.com/a/7958)" }, { "code": "def rate_limits(self):\n if not self._rate_limits:\n self._rate_limits = utilities.get_rate_limits(self.response)\n return self._rate_limits", "docstring": "Returns a list of rate limit details." }, { "code": "def _merge_any_two_boxes(self, box_list):\n n = len(box_list)\n for i in range(n):\n for j in range(i + 1, n):\n if self._are_nearby_parallel_boxes(box_list[i], box_list[j]):\n a, b = box_list[i], box_list[j]\n merged_points = np.vstack([a.points, b.points])\n merged_box = RotatedBox.from_points(merged_points, self.box_type)\n if merged_box.width / merged_box.height >= self.min_box_aspect:\n box_list.remove(a)\n box_list.remove(b)\n box_list.append(merged_box)\n return True\n return False", "docstring": "Given a list of boxes, finds two nearby parallel ones and merges them. Returns false if none found." }, { "code": "def write_text(filename, data, add=False):\n write_type = 'a' if add else 'w'\n with open(filename, write_type) as file:\n print(data, end='', file=file)", "docstring": "Write image data to text file\n\n :param filename: name of text file to write data to\n :type filename: str\n :param data: image data to write to text file\n :type data: numpy array\n :param add: whether to append to existing file or not. Default is ``False``\n :type add: bool" }, { "code": "def flat_list_to_polymer(atom_list, atom_group_s=4):\n atom_labels = ['N', 'CA', 'C', 'O', 'CB']\n atom_elements = ['N', 'C', 'C', 'O', 'C']\n atoms_coords = [atom_list[x:x + atom_group_s]\n for x in range(0, len(atom_list), atom_group_s)]\n atoms = [[Atom(x[0], x[1]) for x in zip(y, atom_elements)]\n for y in atoms_coords]\n if atom_group_s == 5:\n monomers = [Residue(OrderedDict(zip(atom_labels, x)), 'ALA')\n for x in atoms]\n elif atom_group_s == 4:\n monomers = [Residue(OrderedDict(zip(atom_labels, x)), 'GLY')\n for x in atoms]\n else:\n raise ValueError(\n 'Parameter atom_group_s must be 4 or 5 so atoms can be labeled correctly.')\n polymer = Polypeptide(monomers=monomers)\n return polymer", "docstring": "Takes a flat list of atomic coordinates and converts it to a `Polymer`.\n\n Parameters\n ----------\n atom_list : [Atom]\n Flat list of coordinates.\n atom_group_s : int, optional\n Size of atom groups.\n\n Returns\n -------\n polymer : Polypeptide\n `Polymer` object containing atom coords converted `Monomers`.\n\n Raises\n ------\n ValueError\n Raised if `atom_group_s` != 4 or 5" }, { "code": "def install(self, io_handler, module_name):\n bundle = self._context.install_bundle(module_name)\n io_handler.write_line(\"Bundle ID: {0}\", bundle.get_bundle_id())\n return bundle.get_bundle_id()", "docstring": "Installs the bundle with the given module name" }, { "code": "def get_task_progress(self, task_name):\n params = {'instanceprogress': task_name, 'taskname': task_name}\n resp = self._client.get(self.resource(), params=params)\n return Instance.Task.TaskProgress.parse(self._client, resp)", "docstring": "Get task's current progress\n\n :param task_name: task_name\n :return: the task's progress\n :rtype: :class:`odps.models.Instance.Task.TaskProgress`" }, { "code": "def export(self, out_filename):\n with zipfile.ZipFile(out_filename, 'w', zipfile.ZIP_DEFLATED) as arc:\n id_list = list(self.get_thread_info())\n for num, my_info in enumerate(id_list):\n logging.info('Working on item %i : %s', num, my_info['number'])\n my_thread = GitHubCommentThread(\n self.gh_info.owner, self.gh_info.realm, my_info['title'],\n self.gh_info.user, self.gh_info.token,\n thread_id=my_info['number'])\n csec = my_thread.get_comment_section()\n cdict = [item.to_dict() for item in csec.comments]\n my_json = json.dumps(cdict)\n arc.writestr('%i__%s' % (my_info['number'], my_info['title']),\n my_json)", "docstring": "Export desired threads as a zipfile to out_filename." }, { "code": "def Read(f):\n try:\n yaml_data = yaml.load(f)\n except yaml.YAMLError as e:\n raise ParseError('%s' % e)\n except IOError as e:\n raise YAMLLoadError('%s' % e)\n _CheckData(yaml_data)\n try:\n return Config(\n yaml_data.get('blacklist', ()),\n yaml_data.get('whitelist', ('*')))\n except UnicodeDecodeError as e:\n raise YAMLLoadError('%s' % e)", "docstring": "Reads and returns Config data from a yaml file.\n\n Args:\n f: Yaml file to parse.\n\n Returns:\n Config object as defined in this file.\n\n Raises:\n Error (some subclass): If there is a problem loading or parsing the file." }, { "code": "def combine_with(self, rgbd_im):\n new_data = self.data.copy()\n depth_data = self.depth.data\n other_depth_data = rgbd_im.depth.data\n depth_zero_px = self.depth.zero_pixels()\n depth_replace_px = np.where(\n (other_depth_data != 0) & (\n other_depth_data < depth_data))\n depth_replace_px = np.c_[depth_replace_px[0], depth_replace_px[1]]\n new_data[depth_zero_px[:, 0], depth_zero_px[:, 1],\n :] = rgbd_im.data[depth_zero_px[:, 0], depth_zero_px[:, 1], :]\n new_data[depth_replace_px[:, 0], depth_replace_px[:, 1],\n :] = rgbd_im.data[depth_replace_px[:, 0], depth_replace_px[:, 1], :]\n return RgbdImage(new_data, frame=self.frame)", "docstring": "Replaces all zeros in the source rgbd image with the values of a different rgbd image\n\n Parameters\n ----------\n rgbd_im : :obj:`RgbdImage`\n rgbd image to combine with\n\n Returns\n -------\n :obj:`RgbdImage`\n the combined rgbd image" }, { "code": "def flush(self):\n if self.shutdown:\n return\n self.flush_buffers(force=True)\n self.queue.put(FLUSH_MARKER)\n self.queue.join()", "docstring": "Ensure all logging output has been flushed." }, { "code": "def _mpl_to_vispy(fig):\n renderer = VispyRenderer()\n exporter = Exporter(renderer)\n with warnings.catch_warnings(record=True):\n exporter.run(fig)\n renderer._vispy_done()\n return renderer.canvas", "docstring": "Convert a given matplotlib figure to vispy\n\n This function is experimental and subject to change!\n Requires matplotlib and mplexporter.\n\n Parameters\n ----------\n fig : instance of matplotlib Figure\n The populated figure to display.\n\n Returns\n -------\n canvas : instance of Canvas\n The resulting vispy Canvas." }, { "code": "def _guess_record(self, rtype, name=None, content=None):\n records = self._list_records_internal(\n identifier=None, rtype=rtype, name=name, content=content)\n if len(records) == 1:\n return records[0]\n if len(records) > 1:\n raise Exception(\n 'Identifier was not provided and several existing '\n 'records match the request for {0}/{1}'.format(rtype, name))\n raise Exception(\n 'Identifier was not provided and no existing records match '\n 'the request for {0}/{1}'.format(rtype, name))", "docstring": "Tries to find existing unique record by type, name and content" }, { "code": "def create_for_block(\n cls, i=None, name=None, cname=None, version=None, **kwargs):\n if cname is None:\n cname = name or 'values_block_{idx}'.format(idx=i)\n if name is None:\n name = cname\n try:\n if version[0] == 0 and version[1] <= 10 and version[2] == 0:\n m = re.search(r\"values_block_(\\d+)\", name)\n if m:\n name = \"values_{group}\".format(group=m.groups()[0])\n except IndexError:\n pass\n return cls(name=name, cname=cname, **kwargs)", "docstring": "return a new datacol with the block i" }, { "code": "def get_crash_signature(error_line):\n search_term = None\n match = CRASH_RE.match(error_line)\n if match and is_helpful_search_term(match.group(1)):\n search_term = match.group(1)\n return search_term", "docstring": "Try to get a crash signature from the given error_line string." }, { "code": "def field_value(self, value):\n if not self.is_array:\n return self.field_type(value)\n if isinstance(value, (list, tuple, set)):\n return [self.field_type(item) for item in value]\n return self.field_type(value)", "docstring": "Validate against NodeType." }, { "code": "def _get_kernel_data(self, nmr_samples, thinning, return_output):\n kernel_data = {\n 'data': self._data,\n 'method_data': self._get_mcmc_method_kernel_data(),\n 'nmr_iterations': Scalar(nmr_samples * thinning, ctype='ulong'),\n 'iteration_offset': Scalar(self._sampling_index, ctype='ulong'),\n 'rng_state': Array(self._rng_state, 'uint', mode='rw', ensure_zero_copy=True),\n 'current_chain_position': Array(self._current_chain_position, 'mot_float_type',\n mode='rw', ensure_zero_copy=True),\n 'current_log_likelihood': Array(self._current_log_likelihood, 'mot_float_type',\n mode='rw', ensure_zero_copy=True),\n 'current_log_prior': Array(self._current_log_prior, 'mot_float_type',\n mode='rw', ensure_zero_copy=True),\n }\n if return_output:\n kernel_data.update({\n 'samples': Zeros((self._nmr_problems, self._nmr_params, nmr_samples), ctype='mot_float_type'),\n 'log_likelihoods': Zeros((self._nmr_problems, nmr_samples), ctype='mot_float_type'),\n 'log_priors': Zeros((self._nmr_problems, nmr_samples), ctype='mot_float_type'),\n })\n return kernel_data", "docstring": "Get the kernel data we will input to the MCMC sampler.\n\n This sets the items:\n\n * data: the pointer to the user provided data\n * method_data: the data specific to the MCMC method\n * nmr_iterations: the number of iterations to sample\n * iteration_offset: the current sample index, that is, the offset to the given number of iterations\n * rng_state: the random number generator state\n * current_chain_position: the current position of the sampled chain\n * current_log_likelihood: the log likelihood of the current position on the chain\n * current_log_prior: the log prior of the current position on the chain\n\n Additionally, if ``return_output`` is True, we add to that the arrays:\n\n * samples: for the samples\n * log_likelihoods: for storing the log likelihoods\n * log_priors: for storing the priors\n\n Args:\n nmr_samples (int): the number of samples we will draw\n thinning (int): the thinning factor we want to use\n return_output (boolean): if the kernel should return output\n\n Returns:\n dict[str: mot.lib.utils.KernelData]: the kernel input data" }, { "code": "def on_attribute(self, node):\n ctx = node.ctx.__class__\n if ctx == ast.Store:\n msg = \"attribute for storage: shouldn't be here!\"\n self.raise_exception(node, exc=RuntimeError, msg=msg)\n sym = self.run(node.value)\n if ctx == ast.Del:\n return delattr(sym, node.attr)\n fmt = \"cannnot access attribute '%s' for %s\"\n if node.attr not in UNSAFE_ATTRS:\n fmt = \"no attribute '%s' for %s\"\n try:\n return getattr(sym, node.attr)\n except AttributeError:\n pass\n obj = self.run(node.value)\n msg = fmt % (node.attr, obj)\n self.raise_exception(node, exc=AttributeError, msg=msg)", "docstring": "Extract attribute." }, { "code": "def _auto_commit(self, by_count=False):\n if (self._stopping or self._shuttingdown or (not self._start_d) or\n (self._last_processed_offset is None) or\n (not self.consumer_group) or\n (by_count and not self.auto_commit_every_n)):\n return\n if (not by_count or self._last_committed_offset is None or\n (self._last_processed_offset - self._last_committed_offset\n ) >= self.auto_commit_every_n):\n if not self._commit_ds:\n commit_d = self.commit()\n commit_d.addErrback(self._handle_auto_commit_error)\n else:\n d = Deferred()\n d.addCallback(self._retry_auto_commit, by_count)\n self._commit_ds.append(d)", "docstring": "Check if we should start a new commit operation and commit" }, { "code": "def config(config_dict: typing.Mapping) -> Config:\n logger.debug(f\"Updating with {config_dict}\")\n _cfg.update(config_dict)\n return _cfg", "docstring": "Configures the konch shell. This function should be called in a\n .konchrc file.\n\n :param dict config_dict: Dict that may contain 'context', 'banner', and/or\n 'shell' (default shell class to use)." }, { "code": "def clean_bytes(line):\n text = line.decode('utf-8').replace('\\r', '').strip('\\n')\n return re.sub(r'\\x1b[^m]*m', '', text).replace(\"``\", \"`\\u200b`\").strip('\\n')", "docstring": "Cleans a byte sequence of shell directives and decodes it." }, { "code": "def get_index(self, filename):\r\n index = self.fsmodel.index(filename)\r\n if index.isValid() and index.model() is self.fsmodel:\r\n return self.proxymodel.mapFromSource(index)", "docstring": "Return index associated with filename" }, { "code": "def generate_and_merge_schemas(samples):\n merged = generate_schema_for_sample(next(iter(samples)))\n for sample in samples:\n merged = merge_schema(merged, generate_schema_for_sample(sample))\n return merged", "docstring": "Iterates through the given samples, generating schemas\n and merging them, returning the resulting merged schema." }, { "code": "def all_elements_equal(value):\n if is_scalar(value):\n return True\n return np.array(value == value.flatten()[0]).all()", "docstring": "Checks if all elements in the given value are equal to each other.\n\n If the input is a single value the result is trivial. If not, we compare all the values to see\n if they are exactly the same.\n\n Args:\n value (ndarray or number): a numpy array or a single number.\n\n Returns:\n bool: true if all elements are equal to each other, false otherwise" }, { "code": "def _parse_scale(scale_exp):\n m = re.search(\"(\\w+?)\\{(.*?)\\}\", scale_exp)\n if m is None:\n raise InvalidFormat('Unable to parse the given time period.')\n scale = m.group(1)\n range = m.group(2)\n if scale not in SCALES:\n raise InvalidFormat('%s is not a valid scale.' % scale)\n ranges = re.split(\"\\s\", range)\n return scale, ranges", "docstring": "Parses a scale expression and returns the scale, and a list of ranges." }, { "code": "def pipe_value(self, message):\n 'Send a new value into the ws pipe'\n jmsg = json.dumps(message)\n self.send(jmsg)", "docstring": "Send a new value into the ws pipe" }, { "code": "async def get(self, cmd, daap_data=True, timeout=None, **args):\n def _get_request():\n return self.http.get_data(\n self._mkurl(cmd, *args),\n headers=_DMAP_HEADERS,\n timeout=timeout)\n await self._assure_logged_in()\n return await self._do(_get_request, is_daap=daap_data)", "docstring": "Perform a DAAP GET command." }, { "code": "def clear_published_date(self):\n if (self.get_published_date_metadata().is_read_only() or\n self.get_published_date_metadata().is_required()):\n raise errors.NoAccess()\n self._my_map['publishedDate'] = self._published_date_default", "docstring": "Removes the puiblished date.\n\n raise: NoAccess - ``Metadata.isRequired()`` is ``true`` or\n ``Metadata.isReadOnly()`` is ``true``\n *compliance: mandatory -- This method must be implemented.*" }, { "code": "def find_next(lines, find_str, start_index):\n mode = None\n if isinstance(find_str, basestring):\n mode = 'normal'\n message = find_str\n elif isinstance(find_str, Invert):\n mode = 'invert'\n message = str(find_str)\n else:\n raise TypeError(\"Unsupported message type\")\n for i in range(start_index, len(lines)):\n if re.search(message, lines[i]):\n return mode == 'normal', i, lines[i]\n elif message in lines[i]:\n return mode == 'normal', i, lines[i]\n if mode == 'invert':\n return True, len(lines), None\n raise LookupError(\"Not found\")", "docstring": "Find the next instance of find_str from lines starting from start_index.\n\n :param lines: Lines to look through\n :param find_str: String or Invert to look for\n :param start_index: Index to start from\n :return: (boolean, index, line)" }, { "code": "def stop_daemon(self, payload=None):\n kill_signal = signals['9']\n self.process_handler.kill_all(kill_signal, True)\n self.running = False\n return {'message': 'Pueue daemon shutting down',\n 'status': 'success'}", "docstring": "Kill current processes and initiate daemon shutdown.\n\n The daemon will shut down after a last check on all killed processes." }, { "code": "def BuildDefaultValue(self, value_cls):\n try:\n return value_cls()\n except Exception as e:\n logging.exception(e)\n raise DefaultValueError(\n \"Can't create default for value %s: %s\" % (value_cls.__name__, e))", "docstring": "Renders default value of a given class.\n\n Args:\n value_cls: Default value of this class will be rendered. This class has to\n be (or to be a subclass of) a self.value_class (i.e. a class that this\n renderer is capable of rendering).\n\n Returns:\n An initialized default value.\n\n Raises:\n DefaultValueError: if something goes wrong." }, { "code": "def close(self):\n from matplotlib.pyplot import close\n for ax in self.axes[::-1]:\n ax.set_xscale('linear')\n ax.set_yscale('linear')\n ax.cla()\n close(self)", "docstring": "Close the plot and release its memory." }, { "code": "def from_sds(var, *args, **kwargs):\n var.__dict__['dtype'] = HTYPE_TO_DTYPE[var.info()[3]]\n shape = var.info()[2]\n var.__dict__['shape'] = shape if isinstance(shape, (tuple, list)) else tuple(shape)\n return da.from_array(var, *args, **kwargs)", "docstring": "Create a dask array from a SD dataset." }, { "code": "def close(self) -> None:\n self._channel.close()\n self._channel = self._stub_v1 = self._stub_v2 = None", "docstring": "Close the gRPC channel and free the acquired resources. Using a closed client is\n not supported." }, { "code": "def retract(self, idx_or_declared_fact):\n self.facts.retract(idx_or_declared_fact)\n if not self.running:\n added, removed = self.get_activations()\n self.strategy.update_agenda(self.agenda, added, removed)", "docstring": "Retracts a specific fact, using its index\n\n .. note::\n This updates the agenda" }, { "code": "def run_in_terminal(self, func, render_cli_done=False, cooked_mode=True):\n if render_cli_done:\n self._return_value = True\n self._redraw()\n self.renderer.reset()\n else:\n self.renderer.erase()\n self._return_value = None\n if cooked_mode:\n with self.input.cooked_mode():\n result = func()\n else:\n result = func()\n self.renderer.reset()\n self.renderer.request_absolute_cursor_position()\n self._redraw()\n return result", "docstring": "Run function on the terminal above the prompt.\n\n What this does is first hiding the prompt, then running this callable\n (which can safely output to the terminal), and then again rendering the\n prompt which causes the output of this function to scroll above the\n prompt.\n\n :param func: The callable to execute.\n :param render_cli_done: When True, render the interface in the\n 'Done' state first, then execute the function. If False,\n erase the interface first.\n :param cooked_mode: When True (the default), switch the input to\n cooked mode while executing the function.\n\n :returns: the result of `func`." }, { "code": "def create_session(self, ticket, payload=None, expires=None):\n assert isinstance(self.session_storage_adapter, CASSessionAdapter)\n logging.debug('[CAS] Creating session for ticket {}'.format(ticket))\n self.session_storage_adapter.create(\n ticket,\n payload=payload,\n expires=expires,\n )", "docstring": "Create a session record from a service ticket." }, { "code": "def save_model(self, filename, num_iteration=None, start_iteration=0):\n if num_iteration is None:\n num_iteration = self.best_iteration\n _safe_call(_LIB.LGBM_BoosterSaveModel(\n self.handle,\n ctypes.c_int(start_iteration),\n ctypes.c_int(num_iteration),\n c_str(filename)))\n _dump_pandas_categorical(self.pandas_categorical, filename)\n return self", "docstring": "Save Booster to file.\n\n Parameters\n ----------\n filename : string\n Filename to save Booster.\n num_iteration : int or None, optional (default=None)\n Index of the iteration that should be saved.\n If None, if the best iteration exists, it is saved; otherwise, all iterations are saved.\n If <= 0, all iterations are saved.\n start_iteration : int, optional (default=0)\n Start index of the iteration that should be saved.\n\n Returns\n -------\n self : Booster\n Returns self." }, { "code": "def close(self):\n super(LockingDatabase, self).close()\n if not self.readonly:\n self.release_lock()", "docstring": "Closes the database, releasing lock." }, { "code": "def prev(self, n=1):\n i = abs(self.tell - n)\n return self.get(i, n)", "docstring": "Get the previous n data from file.\n\n Keyword argument:\n n -- number of structs to be retrieved (default 1)\n Must be greater than 0.\n\n Return:\n A data in the format of obj_fmt, if n = 1. A list of\n structs, otherwise." }, { "code": "def plot_signal(signal, sig_len, n_sig, fs, time_units, sig_style, axes):\n \"Plot signal channels\"\n if len(sig_style) == 1:\n sig_style = n_sig * sig_style\n if time_units == 'samples':\n t = np.linspace(0, sig_len-1, sig_len)\n else:\n downsample_factor = {'seconds':fs, 'minutes':fs * 60,\n 'hours':fs * 3600}\n t = np.linspace(0, sig_len-1, sig_len) / downsample_factor[time_units]\n if signal.ndim == 1:\n axes[0].plot(t, signal, sig_style[0], zorder=3)\n else:\n for ch in range(n_sig):\n axes[ch].plot(t, signal[:,ch], sig_style[ch], zorder=3)", "docstring": "Plot signal channels" }, { "code": "def _parse_description(self, description_text):\n text = description_text\n text = text.strip()\n lines = text.split('\\n')\n data = {}\n for line in lines:\n if \":\" in line:\n idx = line.index(\":\")\n key = line[:idx]\n value = line[idx+1:].lstrip().rstrip()\n data[key] = value\n else:\n if isinstance(value, list) is False:\n value = [value]\n value.append(line.lstrip().rstrip())\n data[key] = value\n return data", "docstring": "Turn description to dictionary." }, { "code": "def addToStore(store, identifier, name):\n persistedFactory = store.findOrCreate(_PersistedFactory, identifier=identifier)\n persistedFactory.name = name\n return persistedFactory", "docstring": "Adds a persisted factory with given identifier and object name to\n the given store.\n\n This is intended to have the identifier and name partially\n applied, so that a particular module with an exercise in it can\n just have an ``addToStore`` function that remembers it in the\n store.\n\n If a persisted factory with the same identifier already exists,\n the name will be updated." }, { "code": "def start_tcp_server(self, ip, port, name=None, timeout=None, protocol=None, family='ipv4'):\n self._start_server(TCPServer, ip, port, name, timeout, protocol, family)", "docstring": "Starts a new TCP server to given `ip` and `port`.\n\n Server can be given a `name`, default `timeout` and a `protocol`.\n `family` can be either ipv4 (default) or ipv6. Notice that you have to\n use `Accept Connection` keyword for server to receive connections.\n\n Examples:\n | Start TCP server | 10.10.10.2 | 53 |\n | Start TCP server | 10.10.10.2 | 53 | Server1 |\n | Start TCP server | 10.10.10.2 | 53 | name=Server1 | protocol=GTPV2 |\n | Start TCP server | 10.10.10.2 | 53 | timeout=5 |\n | Start TCP server | 0:0:0:0:0:0:0:1 | 53 | family=ipv6 |" }, { "code": "def get_arrays(self, type_img):\n if type_img.lower() == 'lola':\n return LolaMap(self.ppdlola, *self.window, path_pdsfile=self.path_pdsfiles).image()\n elif type_img.lower() == 'wac':\n return WacMap(self.ppdwac, *self.window, path_pdsfile=self.path_pdsfiles).image()\n else:\n raise ValueError('The img type has to be either \"Lola\" or \"Wac\"')", "docstring": "Return arrays the region of interest\n\n Args:\n type_img (str): Either lola or wac.\n\n Returns:\n A tupple of three arrays ``(X,Y,Z)`` with ``X`` contains the\n longitudes, ``Y`` contains the latitude and ``Z`` the values\n extracted for the region of interest.\n\n Note:\n The argument has to be either lola or wac. Note case sensitive.\n All return arrays have the same size.\n\n All coordinates are in degree." }, { "code": "def get_class_from_settings_from_apps(settings_key):\n cls_path = getattr(settings, settings_key, None)\n if not cls_path:\n raise NotImplementedError()\n try:\n app_label = cls_path.split('.')[-2]\n model_name = cls_path.split('.')[-1]\n except ValueError:\n raise ImproperlyConfigured(\"{0} must be of the form \"\n \"'app_label.model_name'\".format(\n settings_key))\n app = apps.get_app_config(app_label).models_module\n if not app:\n raise ImproperlyConfigured(\"{0} setting refers to an app that has not \"\n \"been installed\".format(settings_key))\n return getattr(app, model_name)", "docstring": "Try and get a class from a settings path by lookin in installed apps." }, { "code": "def configure_logging(verbosity):\n root = logging.getLogger()\n formatter = logging.Formatter('%(asctime)s.%(msecs)03d %(levelname).3s %(name)s %(message)s',\n '%y-%m-%d %H:%M:%S')\n handler = logging.StreamHandler()\n handler.setFormatter(formatter)\n loglevels = [logging.CRITICAL, logging.ERROR, logging.WARNING, logging.INFO, logging.DEBUG]\n if verbosity >= len(loglevels):\n verbosity = len(loglevels) - 1\n level = loglevels[verbosity]\n root.setLevel(level)\n root.addHandler(handler)", "docstring": "Set up the global logging level.\n\n Args:\n verbosity (int): The logging verbosity" }, { "code": "def parse_content(self, content, allow_no_value=False):\n super(IniConfigFile, self).parse_content(content)\n config = RawConfigParser(allow_no_value=allow_no_value)\n fp = io.StringIO(u\"\\n\".join(content))\n config.readfp(fp, filename=self.file_name)\n self.data = config", "docstring": "Parses content of the config file.\n\n In child class overload and call super to set flag\n ``allow_no_values`` and allow keys with no value in\n config file::\n\n def parse_content(self, content):\n super(YourClass, self).parse_content(content,\n allow_no_values=True)" }, { "code": "def commuting_sets_by_indices(pauli_sums, commutation_check):\n assert isinstance(pauli_sums, list)\n group_inds = []\n group_terms = []\n for i, pauli_sum in enumerate(pauli_sums):\n for j, term in enumerate(pauli_sum):\n if len(group_inds) == 0:\n group_inds.append([(i, j)])\n group_terms.append([term])\n continue\n for k, group in enumerate(group_terms):\n if commutation_check(group, term):\n group_inds[k] += [(i, j)]\n group_terms[k] += [term]\n break\n else:\n group_inds.append([(i, j)])\n group_terms.append([term])\n return group_inds", "docstring": "For a list of pauli sums, find commuting sets and keep track of which pauli sum they came from.\n\n :param pauli_sums: A list of PauliSum\n :param commutation_check: a function that checks if all elements of a list\n and a single pauli term commute.\n :return: A list of commuting sets. Each set is a list of tuples (i, j) to find the particular\n commuting term. i is the index of the pauli sum from whence the term came. j is the\n index within the set." }, { "code": "def register(self, es, append=None, modulo=None):\n if not isinstance(es, CMAEvolutionStrategy):\n raise TypeError(\"only class CMAEvolutionStrategy can be \" +\n \"registered for logging\")\n self.es = es\n if append is not None:\n self.append = append\n if modulo is not None:\n self.modulo = modulo\n self.registered = True\n return self", "docstring": "register a `CMAEvolutionStrategy` instance for logging,\n ``append=True`` appends to previous data logged under the same name,\n by default previous data are overwritten." }, { "code": "def _get_arg_tokens(cli):\n arg = cli.input_processor.arg\n return [\n (Token.Prompt.Arg, '(arg: '),\n (Token.Prompt.Arg.Text, str(arg)),\n (Token.Prompt.Arg, ') '),\n ]", "docstring": "Tokens for the arg-prompt." }, { "code": "def remove_sites_from_neighbours( self, remove_labels ):\n if type( remove_labels ) is str:\n remove_labels = [ remove_labels ]\n self.neighbours = set( n for n in self.neighbours if n.label not in remove_labels )", "docstring": "Removes sites from the set of neighbouring sites if these have labels in remove_labels.\n\n Args:\n Remove_labels (List) or (Str): List of Site labels to be removed from the cluster neighbour set.\n\n Returns:\n None" }, { "code": "def get_environments():\n envs = []\n for root, subfolders, files in os.walk('environments'):\n for filename in files:\n if filename.endswith(\".json\"):\n path = os.path.join(\n root[len('environments'):], filename[:-len('.json')])\n envs.append(get_environment(path))\n return sorted(envs, key=lambda x: x['name'])", "docstring": "Gets all environments found in the 'environments' directory" }, { "code": "def update_contact_of_client(self, contact_id, contact_dict):\n return self._create_put_request(resource=CONTACTS, billomat_id=contact_id, send_data=contact_dict)", "docstring": "Updates a contact\n\n :param contact_id: the id of the contact\n :param contact_dict: dict\n :return: dict" }, { "code": "def check_who_read(self, messages):\n for m in messages:\n readers = []\n for p in m.thread.participation_set.all():\n if p.date_last_check is None:\n pass\n elif p.date_last_check > m.sent_at:\n readers.append(p.participant.id)\n setattr(m, \"readers\", readers)\n return messages", "docstring": "Check who read each message." }, { "code": "def _wrap_rpc_behavior(handler, fn):\n if handler is None:\n return None\n if handler.request_streaming and handler.response_streaming:\n behavior_fn = handler.stream_stream\n handler_factory = grpc.stream_stream_rpc_method_handler\n elif handler.request_streaming and not handler.response_streaming:\n behavior_fn = handler.stream_unary\n handler_factory = grpc.stream_unary_rpc_method_handler\n elif not handler.request_streaming and handler.response_streaming:\n behavior_fn = handler.unary_stream\n handler_factory = grpc.unary_stream_rpc_method_handler\n else:\n behavior_fn = handler.unary_unary\n handler_factory = grpc.unary_unary_rpc_method_handler\n return handler_factory(\n fn(behavior_fn, handler.request_streaming,\n handler.response_streaming),\n request_deserializer=handler.request_deserializer,\n response_serializer=handler.response_serializer\n )", "docstring": "Returns a new rpc handler that wraps the given function" }, { "code": "def close(self):\n if self._writer is not None:\n self.flush()\n self._writer.close()\n self._writer = None", "docstring": "Closes the record writer." }, { "code": "def add_volume(self,colorchange=True,column=None,name='',str='{name}',**kwargs):\n\t\tif not column:\n\t\t\tcolumn=self._d['volume']\n\t\tup_color=kwargs.pop('up_color',self.theme['up_color'])\n\t\tdown_color=kwargs.pop('down_color',self.theme['down_color'])\n\t\tstudy={'kind':'volume',\n\t\t\t 'name':name,\n\t\t\t 'params':{'colorchange':colorchange,'base':'close','column':column,\n\t\t\t\t\t\t 'str':None},\n\t\t\t 'display':utils.merge_dict({'up_color':up_color,'down_color':down_color},kwargs)}\n\t\tself._add_study(study)", "docstring": "Add 'volume' study to QuantFigure.studies\n\n\t\tParameters:\n\t\t\tcolorchange : bool\n\t\t\t\tIf True then each volume bar will have a fill color \n\t\t\t\tdepending on if 'base' had a positive or negative\n\t\t\t\tchange compared to the previous value\n\t\t\t\tIf False then each volume bar will have a fill color \n\t\t\t\tdepending on if the volume data itself had a positive or negative\n\t\t\t\tchange compared to the previous value\n\t\t\tcolumn :string\n\t\t\t\tDefines the data column name that contains the volume data. \n\t\t\t\tDefault: 'volume'\n\t\t\tname : string\n\t\t\t\tName given to the study\n\t\t\tstr : string\n\t\t\t\tLabel factory for studies\n\t\t\t\tThe following wildcards can be used:\n\t\t\t\t\t{name} : Name of the column\n\t\t\t\t\t{study} : Name of the study\n\t\t\t\t\t{period} : Period used\n\t\t\t\tExamples:\n\t\t\t\t\t'study: {study} - period: {period}'\n\t\t\t\n\t\tkwargs : \n\t\t\tbase : string\n\t\t\t\tDefines the column which will define the\n\t\t\t\tpositive/negative changes (if colorchange=True).\n\t\t\t\tDefault = 'close'\n\t\t\tup_color : string\n\t\t\t\tColor for positive bars\n\t\t\tdown_color : string\n\t\t\t\tColor for negative bars" }, { "code": "def create_topics(self, new_topics, timeout_ms=None, validate_only=False):\n version = self._matching_api_version(CreateTopicsRequest)\n timeout_ms = self._validate_timeout(timeout_ms)\n if version == 0:\n if validate_only:\n raise IncompatibleBrokerVersion(\n \"validate_only requires CreateTopicsRequest >= v1, which is not supported by Kafka {}.\"\n .format(self.config['api_version']))\n request = CreateTopicsRequest[version](\n create_topic_requests=[self._convert_new_topic_request(new_topic) for new_topic in new_topics],\n timeout=timeout_ms\n )\n elif version <= 2:\n request = CreateTopicsRequest[version](\n create_topic_requests=[self._convert_new_topic_request(new_topic) for new_topic in new_topics],\n timeout=timeout_ms,\n validate_only=validate_only\n )\n else:\n raise NotImplementedError(\n \"Support for CreateTopics v{} has not yet been added to KafkaAdminClient.\"\n .format(version))\n return self._send_request_to_controller(request)", "docstring": "Create new topics in the cluster.\n\n :param new_topics: A list of NewTopic objects.\n :param timeout_ms: Milliseconds to wait for new topics to be created\n before the broker returns.\n :param validate_only: If True, don't actually create new topics.\n Not supported by all versions. Default: False\n :return: Appropriate version of CreateTopicResponse class." }, { "code": "def get_column_index(self, header):\n try:\n index = self._column_headers.index(header)\n return index\n except ValueError:\n raise_suppressed(KeyError((\"'{}' is not a header for any \"\n \"column\").format(header)))", "docstring": "Get index of a column from it's header.\n\n Parameters\n ----------\n header: str\n header of the column.\n\n Raises\n ------\n ValueError:\n If no column could be found corresponding to `header`." }, { "code": "def __create_entry(self, entrytype, data, index, ttl=None):\n if entrytype == 'HS_ADMIN':\n op = 'creating HS_ADMIN entry'\n msg = 'This method can not create HS_ADMIN entries.'\n raise IllegalOperationException(operation=op, msg=msg)\n entry = {'index':index, 'type':entrytype, 'data':data}\n if ttl is not None:\n entry['ttl'] = ttl\n return entry", "docstring": "Create an entry of any type except HS_ADMIN.\n\n :param entrytype: THe type of entry to create, e.g. 'URL' or\n 'checksum' or ... Note: For entries of type 'HS_ADMIN', please\n use __create_admin_entry(). For type '10320/LOC', please use\n 'add_additional_URL()'\n :param data: The actual value for the entry. Can be a simple string,\n e.g. \"example\", or a dict {\"format\":\"string\", \"value\":\"example\"}.\n :param index: The integer to be used as index.\n :param ttl: Optional. If not set, the library's default is set. If\n there is no default, it is not set by this library, so Handle\n System sets it.\n :return: The entry as a dict." }, { "code": "def is_schema_of_common_names(schema: GraphQLSchema) -> bool:\n query_type = schema.query_type\n if query_type and query_type.name != \"Query\":\n return False\n mutation_type = schema.mutation_type\n if mutation_type and mutation_type.name != \"Mutation\":\n return False\n subscription_type = schema.subscription_type\n if subscription_type and subscription_type.name != \"Subscription\":\n return False\n return True", "docstring": "Check whether this schema uses the common naming convention.\n\n GraphQL schema define root types for each type of operation. These types are the\n same as any other type and can be named in any manner, however there is a common\n naming convention:\n\n schema {\n query: Query\n mutation: Mutation\n }\n\n When using this naming convention, the schema description can be omitted." }, { "code": "def random_filename(path=None):\n filename = uuid4().hex\n if path is not None:\n filename = os.path.join(path, filename)\n return filename", "docstring": "Make a UUID-based file name which is extremely unlikely\n to exist already." }, { "code": "def contribute_to_class(self, cls, name):\n self.update_rel_to(cls)\n self.set_attributes_from_name(name)\n self.model = cls\n if not self.remote_field.through and not cls._meta.abstract:\n self.remote_field.through = create_many_to_many_intermediary_model(\n self, cls)\n super(M2MFromVersion, self).contribute_to_class(cls, name)", "docstring": "Because django doesn't give us a nice way to provide\n a through table without losing functionality. We have to\n provide our own through table creation that uses the\n FKToVersion field to be used for the from field." }, { "code": "def register_trading_control(self, control):\n if self.initialized:\n raise RegisterTradingControlPostInit()\n self.trading_controls.append(control)", "docstring": "Register a new TradingControl to be checked prior to order calls." }, { "code": "def shape(cls, dataset):\n if not dataset.data:\n return (0, len(dataset.dimensions()))\n rows, cols = 0, 0\n ds = cls._inner_dataset_template(dataset)\n for d in dataset.data:\n ds.data = d\n r, cols = ds.interface.shape(ds)\n rows += r\n return rows+len(dataset.data)-1, cols", "docstring": "Returns the shape of all subpaths, making it appear like a\n single array of concatenated subpaths separated by NaN values." }, { "code": "def _set_init_params(self, qrs_amp_recent, noise_amp_recent, rr_recent,\n last_qrs_ind):\n self.qrs_amp_recent = qrs_amp_recent\n self.noise_amp_recent = noise_amp_recent\n self.qrs_thr = max(0.25*self.qrs_amp_recent\n + 0.75*self.noise_amp_recent,\n self.qrs_thr_min * self.transform_gain)\n self.rr_recent = rr_recent\n self.last_qrs_ind = last_qrs_ind\n self.last_qrs_peak_num = None", "docstring": "Set initial online parameters" }, { "code": "def importFile(self, srcUrl, sharedFileName=None):\n self._assertContextManagerUsed()\n return self._jobStore.importFile(srcUrl, sharedFileName=sharedFileName)", "docstring": "Imports the file at the given URL into job store.\n\n See :func:`toil.jobStores.abstractJobStore.AbstractJobStore.importFile` for a\n full description" }, { "code": "def loadSessions(self, callback, bare_jid, device_ids):\n if self.is_async:\n self.__loadSessionsAsync(callback, bare_jid, device_ids, {})\n else:\n return self.__loadSessionsSync(bare_jid, device_ids)", "docstring": "Return a dict containing the session for each device id. By default, this method\n calls loadSession for each device id." }, { "code": "def bitstring_probs_to_z_moments(p):\n zmat = np.array([[1, 1],\n [1, -1]])\n return _apply_local_transforms(p, (zmat for _ in range(p.ndim)))", "docstring": "Convert between bitstring probabilities and joint Z moment expectations.\n\n :param np.array p: An array that enumerates bitstring probabilities. When\n flattened out ``p = [p_00...0, p_00...1, ...,p_11...1]``. The total number of elements must\n therefore be a power of 2. The canonical shape has a separate axis for each qubit, such that\n ``p[i,j,...,k]`` gives the estimated probability of bitstring ``ij...k``.\n :return: ``z_moments``, an np.array with one length-2 axis per qubit which contains the\n expectations of all monomials in ``{I, Z_0, Z_1, ..., Z_{n-1}}``. The expectations of each\n monomial can be accessed via::\n\n = z_moments[j_0,j_1,...,j_m]\n\n :rtype: np.array" }, { "code": "def _reduce_age(self, now):\n if self.max_age:\n keys = [\n key for key, value in iteritems(self.data)\n if now - value['date'] > self.max_age\n ]\n for key in keys:\n del self.data[key]", "docstring": "Reduce size of cache by date.\n\n :param datetime.datetime now: Current time" }, { "code": "def files(self):\n self._printer('\\tFiles Walk')\n for directory in self.directory:\n for path in os.listdir(directory):\n full_path = os.path.join(directory, path)\n if os.path.isfile(full_path):\n if not path.startswith('.'):\n self.filepaths.append(full_path)\n return self._get_filepaths()", "docstring": "Return list of files in root directory" }, { "code": "def grammatical_join(l, initial_joins=\", \", final_join=\" and \"):\n return initial_joins.join(l[:-2] + [final_join.join(l[-2:])])", "docstring": "Display a list of items nicely, with a different string before the final\n item. Useful for using lists in sentences.\n\n >>> grammatical_join(['apples', 'pears', 'bananas'])\n 'apples, pears and bananas'\n\n >>> grammatical_join(['apples', 'pears', 'bananas'], initial_joins=\";\", final_join=\"; or \")\n 'apples; pears; or bananas'\n\n :param l: List of strings to join\n :param initial_joins: the string to join the non-ultimate items with\n :param final_join: the string to join the final item with\n :return: items joined with commas except \" and \" before the final one." }, { "code": "def get_output_content(job_id, max_size=1024, conn=None):\n content = None\n if RBO.index_list().contains(IDX_OUTPUT_JOB_ID).run(conn):\n check_status = RBO.get_all(job_id, index=IDX_OUTPUT_JOB_ID).run(conn)\n else:\n check_status = RBO.filter({OUTPUTJOB_FIELD: {ID_FIELD: job_id}}).run(conn)\n for status_item in check_status:\n content = _truncate_output_content_if_required(status_item, max_size)\n return content", "docstring": "returns the content buffer for a job_id if that job output exists\n\n :param job_id: id for the job\n :param max_size: truncate after [max_size] bytes\n :param conn: (optional) to run on\n :return: or " }, { "code": "def ReadAllClientActionRequests(self, client_id, cursor=None):\n query = (\"SELECT request, UNIX_TIMESTAMP(leased_until), leased_by, \"\n \"leased_count \"\n \"FROM client_action_requests \"\n \"WHERE client_id = %s\")\n cursor.execute(query, [db_utils.ClientIDToInt(client_id)])\n ret = []\n for req, leased_until, leased_by, leased_count in cursor.fetchall():\n request = rdf_flows.ClientActionRequest.FromSerializedString(req)\n if leased_until is not None:\n request.leased_by = leased_by\n request.leased_until = mysql_utils.TimestampToRDFDatetime(leased_until)\n else:\n request.leased_by = None\n request.leased_until = None\n request.ttl = db.Database.CLIENT_MESSAGES_TTL - leased_count\n ret.append(request)\n return sorted(ret, key=lambda req: (req.flow_id, req.request_id))", "docstring": "Reads all client messages available for a given client_id." }, { "code": "def confirm(prompt_str, default=False):\n if default:\n default_str = 'y'\n prompt = '%s [Y/n]' % prompt_str\n else:\n default_str = 'n'\n prompt = '%s [y/N]' % prompt_str\n ans = click.prompt(prompt, default=default_str, show_default=False)\n if ans.lower() in ('y', 'yes', 'yeah', 'yup', 'yolo'):\n return True\n return False", "docstring": "Show a confirmation prompt to a command-line user.\n\n :param string prompt_str: prompt to give to the user\n :param bool default: Default value to True or False" }, { "code": "def update_generators():\n for generator in _GENERATOR_DB.keys():\n install_templates_translations(generator)\n add_variables_to_context(generator)\n interlink_static_files(generator)\n interlink_removed_content(generator)\n interlink_translated_content(generator)", "docstring": "Update the context of all generators\n\n Ads useful variables and translations into the template context\n and interlink translations" }, { "code": "def cluster(\n self, cluster_id, location_id=None, serve_nodes=None, default_storage_type=None\n ):\n return Cluster(\n cluster_id,\n self,\n location_id=location_id,\n serve_nodes=serve_nodes,\n default_storage_type=default_storage_type,\n )", "docstring": "Factory to create a cluster associated with this instance.\n\n For example:\n\n .. literalinclude:: snippets.py\n :start-after: [START bigtable_create_cluster]\n :end-before: [END bigtable_create_cluster]\n\n :type cluster_id: str\n :param cluster_id: The ID of the cluster.\n\n :type instance: :class:`~google.cloud.bigtable.instance.Instance`\n :param instance: The instance where the cluster resides.\n\n :type location_id: str\n :param location_id: (Creation Only) The location where this cluster's\n nodes and storage reside. For best performance,\n clients should be located as close as possible to\n this cluster.\n For list of supported locations refer to\n https://cloud.google.com/bigtable/docs/locations\n\n :type serve_nodes: int\n :param serve_nodes: (Optional) The number of nodes in the cluster.\n\n :type default_storage_type: int\n :param default_storage_type: (Optional) The type of storage\n Possible values are represented by the\n following constants:\n :data:`google.cloud.bigtable.enums.StorageType.SSD`.\n :data:`google.cloud.bigtable.enums.StorageType.SHD`,\n Defaults to\n :data:`google.cloud.bigtable.enums.StorageType.UNSPECIFIED`.\n\n :rtype: :class:`~google.cloud.bigtable.instance.Cluster`\n :returns: a cluster owned by this instance." }, { "code": "def remove_negative_entries(A):\n r\n A = A.tocoo()\n data = A.data\n row = A.row\n col = A.col\n pos = data > 0.0\n datap = data[pos]\n rowp = row[pos]\n colp = col[pos]\n Aplus = coo_matrix((datap, (rowp, colp)), shape=A.shape)\n return Aplus", "docstring": "r\"\"\"Remove all negative entries from sparse matrix.\n\n Aplus=max(0, A)\n\n Parameters\n ----------\n A : (M, M) scipy.sparse matrix\n Input matrix\n\n Returns\n -------\n Aplus : (M, M) scipy.sparse matrix\n Input matrix with negative entries set to zero." }, { "code": "def get(cls, *args, **kwargs):\n if len(args) == 1:\n pk = args[0]\n elif kwargs:\n if len(kwargs) == 1 and cls._field_is_pk(list(kwargs.keys())[0]):\n pk = list(kwargs.values())[0]\n else:\n result = cls.collection(**kwargs).sort(by='nosort')\n if len(result) == 0:\n raise DoesNotExist(u\"No object matching filter: %s\" % kwargs)\n elif len(result) > 1:\n raise ValueError(u\"More than one object matching filter: %s\" % kwargs)\n else:\n try:\n pk = result[0]\n except IndexError:\n raise DoesNotExist(u\"No object matching filter: %s\" % kwargs)\n else:\n raise ValueError(\"Invalid `get` usage with args %s and kwargs %s\" % (args, kwargs))\n return cls(pk)", "docstring": "Retrieve one instance from db according to given kwargs.\n\n Optionnaly, one arg could be used to retrieve it from pk." }, { "code": "def _create_netmap_config(self):\n netmap_path = os.path.join(self.working_dir, \"NETMAP\")\n try:\n with open(netmap_path, \"w\", encoding=\"utf-8\") as f:\n for bay in range(0, 16):\n for unit in range(0, 4):\n f.write(\"{ubridge_id}:{bay}/{unit}{iou_id:>5d}:{bay}/{unit}\\n\".format(ubridge_id=str(self.application_id + 512),\n bay=bay,\n unit=unit,\n iou_id=self.application_id))\n log.info(\"IOU {name} [id={id}]: NETMAP file created\".format(name=self._name,\n id=self._id))\n except OSError as e:\n raise IOUError(\"Could not create {}: {}\".format(netmap_path, e))", "docstring": "Creates the NETMAP file." }, { "code": "def add_modifier(self, modifier, keywords, relative_pos,\n action, parameter=None):\n if relative_pos == 0:\n raise ValueError(\"relative_pos cannot be 0\")\n modifier_dict = self._modifiers.get(modifier, {})\n value = (action, parameter, relative_pos)\n for keyword in keywords:\n action_list = list(modifier_dict.get(keyword, []))\n action_list.append(value)\n modifier_dict[keyword] = tuple(action_list)\n self._modifiers[modifier] = modifier_dict", "docstring": "Modify existing tasks based on presence of a keyword.\n\n Parameters\n ----------\n modifier : str\n A string value which would trigger the given Modifier.\n keywords : iterable of str\n sequence of strings which are keywords for some task,\n which has to be modified.\n relative_pos : int\n Relative position of the task which should be modified\n in the presence of `modifier`. It's value can never be 0. Data\n fields should also be considered when calculating the relative\n position.\n action : str\n String value representing the action which should be performed\n on the task. Action represents calling a arbitrary function\n to perform th emodification.\n parameter : object\n value required by the `action`.(Default None)" }, { "code": "def refit(self, data, label, decay_rate=0.9, **kwargs):\n if self.__set_objective_to_none:\n raise LightGBMError('Cannot refit due to null objective function.')\n predictor = self._to_predictor(copy.deepcopy(kwargs))\n leaf_preds = predictor.predict(data, -1, pred_leaf=True)\n nrow, ncol = leaf_preds.shape\n train_set = Dataset(data, label, silent=True)\n new_booster = Booster(self.params, train_set, silent=True)\n _safe_call(_LIB.LGBM_BoosterMerge(\n new_booster.handle,\n predictor.handle))\n leaf_preds = leaf_preds.reshape(-1)\n ptr_data, type_ptr_data, _ = c_int_array(leaf_preds)\n _safe_call(_LIB.LGBM_BoosterRefit(\n new_booster.handle,\n ptr_data,\n ctypes.c_int(nrow),\n ctypes.c_int(ncol)))\n new_booster.network = self.network\n new_booster.__attr = self.__attr.copy()\n return new_booster", "docstring": "Refit the existing Booster by new data.\n\n Parameters\n ----------\n data : string, numpy array, pandas DataFrame, H2O DataTable's Frame or scipy.sparse\n Data source for refit.\n If string, it represents the path to txt file.\n label : list, numpy 1-D array or pandas Series / one-column DataFrame\n Label for refit.\n decay_rate : float, optional (default=0.9)\n Decay rate of refit,\n will use ``leaf_output = decay_rate * old_leaf_output + (1.0 - decay_rate) * new_leaf_output`` to refit trees.\n **kwargs\n Other parameters for refit.\n These parameters will be passed to ``predict`` method.\n\n Returns\n -------\n result : Booster\n Refitted Booster." }, { "code": "def warn(self, collection):\n super(CodeElement, self).warn(collection)\n if not \"implicit none\" in self.modifiers:\n collection.append(\"WARNING: implicit none not set in {}\".format(self.name))", "docstring": "Checks the module for documentation and best-practice warnings." }, { "code": "def regions(self):\n regions = []\n elem = self.dimensions[\"region\"].elem\n for option_elem in elem.find_all(\"option\"):\n region = option_elem.text.strip()\n regions.append(region)\n return regions", "docstring": "Get a list of all regions" }, { "code": "def sets(self, keyword, value):\n if isinstance(value, str):\n value = KQMLString(value)\n self.set(keyword, value)", "docstring": "Set the element of the list after the given keyword as string.\n\n Parameters\n ----------\n keyword : str\n The keyword parameter to find in the list.\n Putting a colon before the keyword is optional, if no colon is\n given, it is added automatically (e.g. \"keyword\" will be found as\n \":keyword\" in the list).\n\n value : str\n The value is instantiated as KQMLString and added to the list.\n\n Example:\n kl = KQMLList.from_string('(FAILURE)')\n kl.sets('reason', 'this is a custom string message, not a token')" }, { "code": "def bet_place(\n self,\n betting_market_id,\n amount_to_bet,\n backer_multiplier,\n back_or_lay,\n account=None,\n **kwargs\n ):\n from . import GRAPHENE_BETTING_ODDS_PRECISION\n assert isinstance(amount_to_bet, Amount)\n assert back_or_lay in [\"back\", \"lay\"]\n if not account:\n if \"default_account\" in self.config:\n account = self.config[\"default_account\"]\n if not account:\n raise ValueError(\"You need to provide an account\")\n account = Account(account)\n bm = BettingMarket(betting_market_id)\n op = operations.Bet_place(\n **{\n \"fee\": {\"amount\": 0, \"asset_id\": \"1.3.0\"},\n \"bettor_id\": account[\"id\"],\n \"betting_market_id\": bm[\"id\"],\n \"amount_to_bet\": amount_to_bet.json(),\n \"backer_multiplier\": (\n int(backer_multiplier * GRAPHENE_BETTING_ODDS_PRECISION)\n ),\n \"back_or_lay\": back_or_lay,\n \"prefix\": self.prefix,\n }\n )\n return self.finalizeOp(op, account[\"name\"], \"active\", **kwargs)", "docstring": "Place a bet\n\n :param str betting_market_id: The identifier for the market to bet\n in\n :param peerplays.amount.Amount amount_to_bet: Amount to bet with\n :param int backer_multiplier: Multipler for backer\n :param str back_or_lay: \"back\" or \"lay\" the bet\n :param str account: (optional) the account to bet (defaults\n to ``default_account``)" }, { "code": "def init_properties(env='dev', app='unnecessary', **_):\n aws_env = boto3.session.Session(profile_name=env)\n s3client = aws_env.resource('s3')\n generated = get_details(app=app, env=env)\n archaius = generated.archaius()\n archaius_file = ('{path}/application.properties').format(path=archaius['path'])\n try:\n s3client.Object(archaius['bucket'], archaius_file).get()\n LOG.info('Found: %(bucket)s/%(file)s', {'bucket': archaius['bucket'], 'file': archaius_file})\n return True\n except boto3.exceptions.botocore.client.ClientError:\n s3client.Object(archaius['bucket'], archaius_file).put()\n LOG.info('Created: %(bucket)s/%(file)s', {'bucket': archaius['bucket'], 'file': archaius_file})\n return False", "docstring": "Make sure _application.properties_ file exists in S3.\n\n For Applications with Archaius support, there needs to be a file where the\n cloud environment variable points to.\n\n Args:\n env (str): Deployment environment/account, i.e. dev, stage, prod.\n app (str): GitLab Project name.\n\n Returns:\n True when application.properties was found.\n False when application.properties needed to be created." }, { "code": "def record_content_length(self):\n untldict = py2dict(self)\n untldict.pop('meta', None)\n return len(str(untldict))", "docstring": "Calculate length of record, excluding metadata." }, { "code": "def _sd_of_eigenvector(data, vec, measurement='poles', bidirectional=True):\n lon, lat = _convert_measurements(data, measurement)\n vals, vecs = cov_eig(lon, lat, bidirectional)\n x, y, z = vecs[:, vec]\n s, d = stereonet_math.geographic2pole(*stereonet_math.cart2sph(x, y, z))\n return s[0], d[0]", "docstring": "Unifies ``fit_pole`` and ``fit_girdle``." }, { "code": "def list_datacenters(conn=None, call=None):\n if call != 'function':\n raise SaltCloudSystemExit(\n 'The list_datacenters function must be called with '\n '-f or --function.'\n )\n datacenters = []\n if not conn:\n conn = get_conn()\n for item in conn.list_datacenters()['items']:\n datacenter = {'id': item['id']}\n datacenter.update(item['properties'])\n datacenters.append({item['properties']['name']: datacenter})\n return {'Datacenters': datacenters}", "docstring": "List all the data centers\n\n CLI Example:\n\n .. code-block:: bash\n\n salt-cloud -f list_datacenters my-profitbricks-config" }, { "code": "def _contains_policies(self, resource_properties):\n return resource_properties is not None \\\n and isinstance(resource_properties, dict) \\\n and self.POLICIES_PROPERTY_NAME in resource_properties", "docstring": "Is there policies data in this resource?\n\n :param dict resource_properties: Properties of the resource\n :return: True if we can process this resource. False, otherwise" }, { "code": "def configure(self, options, conf):\n super(ProgressivePlugin, self).configure(options, conf)\n if (getattr(options, 'verbosity', 0) > 1 and\n getattr(options, 'enable_plugin_id', False)):\n print ('Using --with-id and --verbosity=2 or higher with '\n 'nose-progressive causes visualization errors. Remove one '\n 'or the other to avoid a mess.')\n if options.with_bar:\n options.with_styling = True", "docstring": "Turn style-forcing on if bar-forcing is on.\n\n It'd be messy to position the bar but still have the rest of the\n terminal capabilities emit ''." }, { "code": "def insertPrimaryDataset(self):\n try :\n body = request.body.read()\n indata = cjson.decode(body)\n indata = validateJSONInputNoCopy(\"primds\", indata)\n indata.update({\"creation_date\": dbsUtils().getTime(), \"create_by\": dbsUtils().getCreateBy() })\n self.dbsPrimaryDataset.insertPrimaryDataset(indata)\n except cjson.DecodeError as dc:\n dbsExceptionHandler(\"dbsException-invalid-input2\", \"Wrong format/data from insert PrimaryDataset input\", self.logger.exception, str(dc))\n except dbsException as de:\n dbsExceptionHandler(de.eCode, de.message, self.logger.exception, de.message)\n except HTTPError as he:\n raise he\n except Exception as ex:\n sError = \"DBSWriterModel/insertPrimaryDataset. %s\\n Exception trace: \\n %s\" \\\n % (ex, traceback.format_exc())\n dbsExceptionHandler('dbsException-server-error', dbsExceptionCode['dbsException-server-error'], self.logger.exception, sError)", "docstring": "API to insert A primary dataset in DBS\n\n :param primaryDSObj: primary dataset object\n :type primaryDSObj: dict\n :key primary_ds_type: TYPE (out of valid types in DBS, MC, DATA) (Required)\n :key primary_ds_name: Name of the primary dataset (Required)" }, { "code": "def kill(self, container, signal=None):\n url = self._url(\"/containers/{0}/kill\", container)\n params = {}\n if signal is not None:\n if not isinstance(signal, six.string_types):\n signal = int(signal)\n params['signal'] = signal\n res = self._post(url, params=params)\n self._raise_for_status(res)", "docstring": "Kill a container or send a signal to a container.\n\n Args:\n container (str): The container to kill\n signal (str or int): The signal to send. Defaults to ``SIGKILL``\n\n Raises:\n :py:class:`docker.errors.APIError`\n If the server returns an error." }, { "code": "def add_item(self, assessment_id, item_id):\n if assessment_id.get_identifier_namespace() != 'assessment.Assessment':\n raise errors.InvalidArgument\n self._part_item_design_session.add_item(item_id, self._get_first_part_id(assessment_id))", "docstring": "Adds an existing ``Item`` to an assessment.\n\n arg: assessment_id (osid.id.Id): the ``Id`` of the\n ``Assessment``\n arg: item_id (osid.id.Id): the ``Id`` of the ``Item``\n raise: NotFound - ``assessment_id`` or ``item_id`` not found\n raise: NullArgument - ``assessment_id`` or ``item_id`` is\n ``null``\n raise: OperationFailed - unable to complete request\n raise: PermissionDenied - authorization failure occurred\n *compliance: mandatory -- This method must be implemented.*" }, { "code": "def _surpress_formatting_errors(fn):\n @wraps(fn)\n def inner(*args, **kwargs):\n try:\n return fn(*args, **kwargs)\n except ValueError:\n return \"\"\n return inner", "docstring": "I know this is dangerous and the wrong way to solve the problem, but when\n using both row and columns summaries it's easier to just swallow errors\n so users can format their tables how they need." }, { "code": "def NumRegressors(npix, pld_order, cross_terms=True):\n res = 0\n for k in range(1, pld_order + 1):\n if cross_terms:\n res += comb(npix + k - 1, k)\n else:\n res += npix\n return int(res)", "docstring": "Return the number of regressors for `npix` pixels\n and PLD order `pld_order`.\n\n :param bool cross_terms: Include pixel cross-terms? Default :py:obj:`True`" }, { "code": "async def set_action(self, on=None, bri=None, hue=None, sat=None, xy=None,\n ct=None, alert=None, effect=None, transitiontime=None,\n bri_inc=None, sat_inc=None, hue_inc=None, ct_inc=None,\n xy_inc=None, scene=None):\n data = {\n key: value for key, value in {\n 'on': on,\n 'bri': bri,\n 'hue': hue,\n 'sat': sat,\n 'xy': xy,\n 'ct': ct,\n 'alert': alert,\n 'effect': effect,\n 'transitiontime': transitiontime,\n 'bri_inc': bri_inc,\n 'sat_inc': sat_inc,\n 'hue_inc': hue_inc,\n 'ct_inc': ct_inc,\n 'xy_inc': xy_inc,\n 'scene': scene,\n }.items() if value is not None\n }\n await self._request('put', 'groups/{}/action'.format(self.id),\n json=data)", "docstring": "Change action of a group." }, { "code": "def _fixedpoint(D, tol=1e-7, maxiter=None):\n N, K = D.shape\n logp = log(D).mean(axis=0)\n a0 = _init_a(D)\n if maxiter is None:\n maxiter = MAXINT\n for i in xrange(maxiter):\n a1 = _ipsi(psi(a0.sum()) + logp)\n if abs(loglikelihood(D, a1)-loglikelihood(D, a0)) < tol:\n return a1\n a0 = a1\n raise Exception('Failed to converge after {} iterations, values are {}.'\n .format(maxiter, a1))", "docstring": "Simple fixed point iteration method for MLE of Dirichlet distribution" }, { "code": "def download_file(self, regex, dest_dir):\n log = logging.getLogger(self.cls_logger + '.download_file')\n if not isinstance(regex, basestring):\n log.error('regex argument is not a string')\n return None\n if not isinstance(dest_dir, basestring):\n log.error('dest_dir argument is not a string')\n return None\n if not os.path.isdir(dest_dir):\n log.error('Directory not found on file system: %s', dest_dir)\n return None\n key = self.find_key(regex)\n if key is None:\n log.warn('Could not find a matching S3 key for: %s', regex)\n return None\n return self.__download_from_s3(key, dest_dir)", "docstring": "Downloads a file by regex from the specified S3 bucket\n\n This method takes a regular expression as the arg, and attempts\n to download the file to the specified dest_dir as the\n destination directory. This method sets the downloaded filename\n to be the same as it is on S3.\n\n :param regex: (str) Regular expression matching the S3 key for\n the file to be downloaded.\n :param dest_dir: (str) Full path destination directory\n :return: (str) Downloaded file destination if the file was\n downloaded successfully, None otherwise." }, { "code": "def tally(self, name, value):\n value = value or 0\n if 'used' not in self.usages[name]:\n self.usages[name]['used'] = 0\n self.usages[name]['used'] += int(value)\n self.update_available(name)", "docstring": "Adds to the \"used\" metric for the given quota." }, { "code": "def dysmetria_score(self, data_frame):\n tap_data = data_frame[data_frame.action_type == 0]\n ds = np.mean(np.sqrt((tap_data.x - tap_data.x_target) ** 2 + (tap_data.y - tap_data.y_target) ** 2))\n duration = math.ceil(data_frame.td[-1])\n return ds, duration", "docstring": "This method calculates accuracy of target taps in pixels\n\n :param data_frame: the data frame\n :type data_frame: pandas.DataFrame\n :return ds: dysmetria score in pixels\n :rtype ds: float" }, { "code": "def queue_purge(self, queue, **kwargs):\n return self.channel.queue_purge(queue=queue).message_count", "docstring": "Discard all messages in the queue. This will delete the messages\n and results in an empty queue." }, { "code": "def get_prefix_source(cls):\n try:\n return cls.override_prefix()\n except AttributeError:\n if hasattr(cls, '_prefix_source'):\n return cls.site + cls._prefix_source\n else:\n return cls.site", "docstring": "Return the prefix source, by default derived from site." }, { "code": "def create(self, auth, type, desc, defer=False):\n return self._call('create', auth, [type, desc], defer)", "docstring": "Create something in Exosite.\n\n Args:\n auth: \n type: What thing to create.\n desc: Information about thing." }, { "code": "def classify_elements(self,\n file,\n file_content_type=None,\n model=None,\n **kwargs):\n if file is None:\n raise ValueError('file must be provided')\n headers = {}\n if 'headers' in kwargs:\n headers.update(kwargs.get('headers'))\n sdk_headers = get_sdk_headers('compare-comply', 'V1',\n 'classify_elements')\n headers.update(sdk_headers)\n params = {'version': self.version, 'model': model}\n form_data = {}\n form_data['file'] = (None, file, file_content_type or\n 'application/octet-stream')\n url = '/v1/element_classification'\n response = self.request(\n method='POST',\n url=url,\n headers=headers,\n params=params,\n files=form_data,\n accept_json=True)\n return response", "docstring": "Classify the elements of a document.\n\n Analyzes the structural and semantic elements of a document.\n\n :param file file: The document to classify.\n :param str file_content_type: The content type of file.\n :param str model: The analysis model to be used by the service. For the **Element\n classification** and **Compare two documents** methods, the default is\n `contracts`. For the **Extract tables** method, the default is `tables`. These\n defaults apply to the standalone methods as well as to the methods' use in\n batch-processing requests.\n :param dict headers: A `dict` containing the request headers\n :return: A `DetailedResponse` containing the result, headers and HTTP status code.\n :rtype: DetailedResponse" }, { "code": "def start(self):\n fname = self.conf['file']\n logging.info(\"Configfile watcher plugin: Starting to watch route spec \"\n \"file '%s' for changes...\" % fname)\n route_spec = {}\n try:\n route_spec = read_route_spec_config(fname)\n if route_spec:\n self.last_route_spec_update = datetime.datetime.now()\n self.q_route_spec.put(route_spec)\n except ValueError as e:\n logging.warning(\"Cannot parse route spec: %s\" % str(e))\n abspath = os.path.abspath(fname)\n parent_dir = os.path.dirname(abspath)\n handler = RouteSpecChangeEventHandler(\n route_spec_fname = fname,\n route_spec_abspath = abspath,\n q_route_spec = self.q_route_spec,\n plugin = self)\n self.observer_thread = watchdog.observers.Observer()\n self.observer_thread.name = \"ConfMon\"\n self.observer_thread.schedule(handler, parent_dir)\n self.observer_thread.start()", "docstring": "Start the configfile change monitoring thread." }, { "code": "def is_product_owner(self, team_id):\n if self.is_super_admin():\n return True\n team_id = uuid.UUID(str(team_id))\n return team_id in self.child_teams_ids", "docstring": "Ensure the user is a PRODUCT_OWNER." }, { "code": "def gen_file_jinja(self, template_file, data, output, dest_path):\n if not os.path.exists(dest_path):\n os.makedirs(dest_path)\n output = join(dest_path, output)\n logger.debug(\"Generating: %s\" % output)\n env = Environment()\n env.loader = FileSystemLoader(self.TEMPLATE_DIR)\n template = env.get_template(template_file)\n target_text = template.render(data)\n open(output, \"w\").write(target_text)\n return dirname(output), output", "docstring": "Fills data to the project template, using jinja2." }, { "code": "def list_targets_by_instance(self, instance_id, target_list=None):\n if target_list is not None:\n return [target for target in target_list\n if target['instance_id'] == instance_id]\n else:\n ports = self._target_ports_by_instance(instance_id)\n reachable_subnets = self._get_reachable_subnets(\n ports, fetch_router_ports=True)\n name = self._get_server_name(instance_id)\n targets = []\n for p in ports:\n for ip in p.fixed_ips:\n if ip['subnet_id'] not in reachable_subnets:\n continue\n if netaddr.IPAddress(ip['ip_address']).version != 4:\n continue\n targets.append(FloatingIpTarget(p, ip['ip_address'], name))\n return targets", "docstring": "Returns a list of FloatingIpTarget objects of FIP association.\n\n :param instance_id: ID of target VM instance\n :param target_list: (optional) a list returned by list_targets().\n If specified, looking up is done against the specified list\n to save extra API calls to a back-end. Otherwise target list\n is retrieved from a back-end inside the method." }, { "code": "def db(self, entity, query_filters=\"size=10\"):\n if self.entity_api_key == \"\":\n return {'status': 'failure', 'response': 'No API key found in request'}\n historic_url = self.base_url + \"api/0.1.0/historicData?\" + query_filters\n historic_headers = {\n \"apikey\": self.entity_api_key,\n \"Content-Type\": \"application/json\"\n }\n historic_query_data = json.dumps({\n \"query\": {\n \"match\": {\n \"key\": entity\n }\n }\n })\n with self.no_ssl_verification():\n r = requests.get(historic_url, data=historic_query_data, headers=historic_headers)\n response = dict()\n if \"No API key\" in str(r.content.decode(\"utf-8\")):\n response[\"status\"] = \"failure\"\n else:\n r = r.content.decode(\"utf-8\")\n response = r\n return response", "docstring": "This function allows an entity to access the historic data.\n\n Args:\n entity (string): Name of the device to listen to\n query_filters (string): Elastic search response format string\n example, \"pretty=true&size=10\"" }, { "code": "def imagej_shape(shape, rgb=None):\n shape = tuple(int(i) for i in shape)\n ndim = len(shape)\n if 1 > ndim > 6:\n raise ValueError('invalid ImageJ hyperstack: not 2 to 6 dimensional')\n if rgb is None:\n rgb = shape[-1] in (3, 4) and ndim > 2\n if rgb and shape[-1] not in (3, 4):\n raise ValueError('invalid ImageJ hyperstack: not a RGB image')\n if not rgb and ndim == 6 and shape[-1] != 1:\n raise ValueError('invalid ImageJ hyperstack: not a non-RGB image')\n if rgb or shape[-1] == 1:\n return (1, ) * (6 - ndim) + shape\n return (1, ) * (5 - ndim) + shape + (1,)", "docstring": "Return shape normalized to 6D ImageJ hyperstack TZCYXS.\n\n Raise ValueError if not a valid ImageJ hyperstack shape.\n\n >>> imagej_shape((2, 3, 4, 5, 3), False)\n (2, 3, 4, 5, 3, 1)" }, { "code": "def write_array_empty(self, key, value):\n arr = np.empty((1,) * value.ndim)\n self._handle.create_array(self.group, key, arr)\n getattr(self.group, key)._v_attrs.value_type = str(value.dtype)\n getattr(self.group, key)._v_attrs.shape = value.shape", "docstring": "write a 0-len array" }, { "code": "def pad(obj, pad_length):\n _check_supported(obj)\n copied = deepcopy(obj)\n copied.pad(pad_length)\n return copied", "docstring": "Return a copy of the object with piano-roll padded with zeros at the end\n along the time axis.\n\n Parameters\n ----------\n pad_length : int\n The length to pad along the time axis with zeros." }, { "code": "def map_block_storage(service, pool, image):\n cmd = [\n 'rbd',\n 'map',\n '{}/{}'.format(pool, image),\n '--user',\n service,\n '--secret',\n _keyfile_path(service),\n ]\n check_call(cmd)", "docstring": "Map a RADOS block device for local use." }, { "code": "def walk(self):\n intervals = sorted(self._intervals)\n def nextFull():\n start, stop = intervals.pop(0)\n while intervals:\n if intervals[0][0] <= stop:\n _, thisStop = intervals.pop(0)\n if thisStop > stop:\n stop = thisStop\n else:\n break\n return (start, stop)\n if intervals:\n if intervals[0][0] > 0:\n yield (self.EMPTY, (0, intervals[0][0]))\n while intervals:\n lastFull = nextFull()\n yield (self.FULL, lastFull)\n if intervals:\n yield (self.EMPTY, (lastFull[1], intervals[0][0]))\n if lastFull[1] < self._targetLength:\n yield (self.EMPTY, (lastFull[1], self._targetLength))\n else:\n yield (self.EMPTY, (0, self._targetLength))", "docstring": "Get the non-overlapping read intervals that match the subject.\n\n @return: A generator that produces (TYPE, (START, END)) tuples, where\n where TYPE is either self.EMPTY or self.FULL and (START, STOP) is\n the interval. The endpoint (STOP) of the interval is not considered\n to be in the interval. I.e., the interval is really [START, STOP)." }, { "code": "def str_from_file(path):\n with open(path) as f:\n s = f.read().strip()\n return s", "docstring": "Return file contents as string." }, { "code": "def xpathNsLookup(self, prefix):\n ret = libxml2mod.xmlXPathNsLookup(self._o, prefix)\n return ret", "docstring": "Search in the namespace declaration array of the context\n for the given namespace name associated to the given prefix" }, { "code": "def _read_para_hip_mac_2(self, code, cbit, clen, *, desc, length, version):\n _hmac = self._read_fileng(clen)\n hip_mac_2 = dict(\n type=desc,\n critical=cbit,\n length=clen,\n hmac=_hmac,\n )\n _plen = length - clen\n if _plen:\n self._read_fileng(_plen)\n return hip_mac_2", "docstring": "Read HIP HIP_MAC_2 parameter.\n\n Structure of HIP HIP_MAC_2 parameter [RFC 7401]:\n 0 1 2 3\n 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1\n +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n | Type | Length |\n +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n | |\n | HMAC |\n / /\n / +-------------------------------+\n | | Padding |\n +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n\n Octets Bits Name Description\n 0 0 hip_mac_2.type Parameter Type\n 1 15 hip_mac_2.critical Critical Bit\n 2 16 hip_mac_2.length Length of Contents\n 4 32 hip_mac_2.hmac HMAC\n ? ? - Padding" }, { "code": "def predict(self, data, num_iteration=None,\n raw_score=False, pred_leaf=False, pred_contrib=False,\n data_has_header=False, is_reshape=True, **kwargs):\n predictor = self._to_predictor(copy.deepcopy(kwargs))\n if num_iteration is None:\n num_iteration = self.best_iteration\n return predictor.predict(data, num_iteration,\n raw_score, pred_leaf, pred_contrib,\n data_has_header, is_reshape)", "docstring": "Make a prediction.\n\n Parameters\n ----------\n data : string, numpy array, pandas DataFrame, H2O DataTable's Frame or scipy.sparse\n Data source for prediction.\n If string, it represents the path to txt file.\n num_iteration : int or None, optional (default=None)\n Limit number of iterations in the prediction.\n If None, if the best iteration exists, it is used; otherwise, all iterations are used.\n If <= 0, all iterations are used (no limits).\n raw_score : bool, optional (default=False)\n Whether to predict raw scores.\n pred_leaf : bool, optional (default=False)\n Whether to predict leaf index.\n pred_contrib : bool, optional (default=False)\n Whether to predict feature contributions.\n\n Note\n ----\n If you want to get more explanations for your model's predictions using SHAP values,\n like SHAP interaction values,\n you can install the shap package (https://github.com/slundberg/shap).\n Note that unlike the shap package, with ``pred_contrib`` we return a matrix with an extra\n column, where the last column is the expected value.\n\n data_has_header : bool, optional (default=False)\n Whether the data has header.\n Used only if data is string.\n is_reshape : bool, optional (default=True)\n If True, result is reshaped to [nrow, ncol].\n **kwargs\n Other parameters for the prediction.\n\n Returns\n -------\n result : numpy array\n Prediction result." }, { "code": "def remove_gateway_router(self, router):\n router_id = self._find_router_id(router)\n return self.network_conn.remove_gateway_router(router=router_id)", "docstring": "Removes an external network gateway from the specified router" }, { "code": "def get_OID_field(fs):\n if arcpyFound == False:\n raise Exception(\"ArcPy is required to use this function\")\n desc = arcpy.Describe(fs)\n if desc.hasOID:\n return desc.OIDFieldName\n return None", "docstring": "returns a featureset's object id field" }, { "code": "def is_object(brain_or_object):\n if is_portal(brain_or_object):\n return True\n if is_at_content(brain_or_object):\n return True\n if is_dexterity_content(brain_or_object):\n return True\n if is_brain(brain_or_object):\n return True\n return False", "docstring": "Check if the passed in object is a supported portal content object\n\n :param brain_or_object: A single catalog brain or content object\n :type brain_or_object: Portal Object\n :returns: True if the passed in object is a valid portal content" }, { "code": "def _validate(self):\n if self.region_type not in regions_attributes:\n raise ValueError(\"'{0}' is not a valid region type in this package\"\n .format(self.region_type))\n if self.coordsys not in valid_coordsys['DS9'] + valid_coordsys['CRTF']:\n raise ValueError(\"'{0}' is not a valid coordinate reference frame \"\n \"in astropy\".format(self.coordsys))", "docstring": "Checks whether all the attributes of this object is valid." }, { "code": "def get_current_environment(self, note=None):\n\t\tshutit_global.shutit_global_object.yield_to_draw()\n\t\tself.handle_note(note)\n\t\tres = self.get_current_shutit_pexpect_session_environment().environment_id\n\t\tself.handle_note_after(note)\n\t\treturn res", "docstring": "Returns the current environment id from the current\n\t\tshutit_pexpect_session" }, { "code": "def str2int(self, num):\n radix, alphabet = self.radix, self.alphabet\n if radix <= 36 and alphabet[:radix].lower() == BASE85[:radix].lower():\n return int(num, radix)\n ret = 0\n lalphabet = alphabet[:radix]\n for char in num:\n if char not in lalphabet:\n raise ValueError(\"invalid literal for radix2int() with radix \"\n \"%d: '%s'\" % (radix, num))\n ret = ret * radix + self.cached_map[char]\n return ret", "docstring": "Converts a string into an integer.\n\n If possible, the built-in python conversion will be used for speed\n purposes.\n\n :param num: A string that will be converted to an integer.\n\n :rtype: integer\n\n :raise ValueError: when *num* is invalid" }, { "code": "def get_all_destinations(self, server_id):\n server = self._get_server(server_id)\n return server.conn.EnumerateInstances(DESTINATION_CLASSNAME,\n namespace=server.interop_ns)", "docstring": "Return all listener destinations in a WBEM server.\n\n This function contacts the WBEM server and retrieves the listener\n destinations by enumerating the instances of CIM class\n \"CIM_ListenerDestinationCIMXML\" in the Interop namespace of the WBEM\n server.\n\n Parameters:\n\n server_id (:term:`string`):\n The server ID of the WBEM server, returned by\n :meth:`~pywbem.WBEMSubscriptionManager.add_server`.\n\n Returns:\n\n :class:`py:list` of :class:`~pywbem.CIMInstance`: The listener\n destination instances.\n\n Raises:\n\n Exceptions raised by :class:`~pywbem.WBEMConnection`." }, { "code": "def columns(self, **kw):\n fut = self._run_operation(self._impl.columns, **kw)\n return fut", "docstring": "Creates a results set of column names in specified tables by\n executing the ODBC SQLColumns function. Each row fetched has the\n following columns.\n\n :param table: the table tname\n :param catalog: the catalog name\n :param schema: the schmea name\n :param column: string search pattern for column names." }, { "code": "def stdchannel_redirected(stdchannel, dest_filename, fake=False):\n if fake:\n yield\n return\n oldstdchannel = dest_file = None\n try:\n oldstdchannel = os.dup(stdchannel.fileno())\n dest_file = open(dest_filename, 'w')\n os.dup2(dest_file.fileno(), stdchannel.fileno())\n yield\n finally:\n if oldstdchannel is not None:\n os.dup2(oldstdchannel, stdchannel.fileno())\n if dest_file is not None:\n dest_file.close()", "docstring": "A context manager to temporarily redirect stdout or stderr\n\n e.g.:\n\n with stdchannel_redirected(sys.stderr, os.devnull):\n if compiler.has_function('clock_gettime', libraries=['rt']):\n libraries.append('rt')" }, { "code": "def needed(name, required):\n return [\n relative_field(r, name) if r and startswith_field(r, name) else None\n for r in required\n ]", "docstring": "RETURN SUBSET IF name IN REQUIRED" }, { "code": "def _update_dict(self, newdict):\n if self.bugzilla:\n self.bugzilla.post_translation({}, newdict)\n aliases = self.bugzilla._get_bug_aliases()\n for newname, oldname in aliases:\n if oldname not in newdict:\n continue\n if newname not in newdict:\n newdict[newname] = newdict[oldname]\n elif newdict[newname] != newdict[oldname]:\n log.debug(\"Update dict contained differing alias values \"\n \"d[%s]=%s and d[%s]=%s , dropping the value \"\n \"d[%s]\", newname, newdict[newname], oldname,\n newdict[oldname], oldname)\n del(newdict[oldname])\n for key in newdict.keys():\n if key not in self._bug_fields:\n self._bug_fields.append(key)\n self.__dict__.update(newdict)\n if 'id' not in self.__dict__ and 'bug_id' not in self.__dict__:\n raise TypeError(\"Bug object needs a bug_id\")", "docstring": "Update internal dictionary, in a way that ensures no duplicate\n entries are stored WRT field aliases" }, { "code": "def nonull_dict(self):\n return {k: v for k, v in six.iteritems(self.dict) if v and k != '_codes'}", "docstring": "Like dict, but does not hold any null values.\n\n :return:" }, { "code": "def code_memory_read(self, addr, num_bytes):\n buf_size = num_bytes\n buf = (ctypes.c_uint8 * buf_size)()\n res = self._dll.JLINKARM_ReadCodeMem(addr, buf_size, buf)\n if res < 0:\n raise errors.JLinkException(res)\n return list(buf)[:res]", "docstring": "Reads bytes from code memory.\n\n Note:\n This is similar to calling ``memory_read`` or ``memory_read8``,\n except that this uses a cache and reads ahead. This should be used\n in instances where you want to read a small amount of bytes at a\n time, and expect to always read ahead.\n\n Args:\n self (JLink): the ``JLink`` instance\n addr (int): starting address from which to read\n num_bytes (int): number of bytes to read\n\n Returns:\n A list of bytes read from the target.\n\n Raises:\n JLinkException: if memory could not be read." }, { "code": "def handleStatus(self, version, code, message):\n \"extends handleStatus to instantiate a local response object\"\n proxy.ProxyClient.handleStatus(self, version, code, message)\n self._response = client.Response(version, code, message, {}, None)", "docstring": "extends handleStatus to instantiate a local response object" }, { "code": "def add_binary(self, data, address=0, overwrite=False):\n address *= self.word_size_bytes\n self._segments.add(_Segment(address,\n address + len(data),\n bytearray(data),\n self.word_size_bytes),\n overwrite)", "docstring": "Add given data at given address. Set `overwrite` to ``True`` to\n allow already added data to be overwritten." }, { "code": "def remove_one(self):\n self.__bulk.add_delete(self.__selector, _DELETE_ONE,\n collation=self.__collation)", "docstring": "Remove a single document matching the selector criteria." }, { "code": "def to_json(self):\n roots = []\n for r in self.roots:\n roots.append(r.to_json())\n return {'roots': roots}", "docstring": "Returns the JSON representation of this graph." }, { "code": "def save_expectations_config(\n self,\n filepath=None,\n discard_failed_expectations=True,\n discard_result_format_kwargs=True,\n discard_include_configs_kwargs=True,\n discard_catch_exceptions_kwargs=True,\n suppress_warnings=False\n ):\n if filepath == None:\n pass\n expectations_config = self.get_expectations_config(\n discard_failed_expectations,\n discard_result_format_kwargs,\n discard_include_configs_kwargs,\n discard_catch_exceptions_kwargs,\n suppress_warnings\n )\n expectation_config_str = json.dumps(expectations_config, indent=2)\n open(filepath, 'w').write(expectation_config_str)", "docstring": "Writes ``_expectation_config`` to a JSON file.\n\n Writes the DataAsset's expectation config to the specified JSON ``filepath``. Failing expectations \\\n can be excluded from the JSON expectations config with ``discard_failed_expectations``. The kwarg key-value \\\n pairs :ref:`result_format`, :ref:`include_config`, and :ref:`catch_exceptions` are optionally excluded from the JSON \\\n expectations config.\n\n Args:\n filepath (string): \\\n The location and name to write the JSON config file to.\n discard_failed_expectations (boolean): \\\n If True, excludes expectations that do not return ``success = True``. \\\n If False, all expectations are written to the JSON config file.\n discard_result_format_kwargs (boolean): \\\n If True, the :ref:`result_format` attribute for each expectation is not written to the JSON config file. \\\n discard_include_configs_kwargs (boolean): \\\n If True, the :ref:`include_config` attribute for each expectation is not written to the JSON config file.\\\n discard_catch_exceptions_kwargs (boolean): \\\n If True, the :ref:`catch_exceptions` attribute for each expectation is not written to the JSON config \\\n file.\n suppress_warnings (boolean): \\\n It True, all warnings raised by Great Expectations, as a result of dropped expectations, are \\\n suppressed." }, { "code": "def create(self, publish):\n target_url = self.client.get_url('PUBLISH', 'POST', 'create')\n r = self.client.request('POST', target_url, json=publish._serialize())\n return self.create_from_result(r.json())", "docstring": "Creates a new publish group." }, { "code": "def to_ascii_hex(value: int, digits: int) -> str:\n if digits < 1:\n return ''\n text = ''\n for _ in range(0, digits):\n text = chr(ord('0') + (value % 0x10)) + text\n value //= 0x10\n return text", "docstring": "Converts an int value to ASCII hex, as used by LifeSOS.\n Unlike regular hex, it uses the first 6 characters that follow\n numerics on the ASCII table instead of A - F." }, { "code": "def _forward_mode(self, *args):\n f_val, f_diff = self.f._forward_mode(*args)\n g_val, g_diff = self.g._forward_mode(*args)\n val = f_val + g_val\n diff = f_diff + g_diff\n return val, diff", "docstring": "Forward mode differentiation for a sum" }, { "code": "def from_header(self, param_name, field):\n return self.__from_source(param_name, field, lambda: request.headers, 'header')", "docstring": "A decorator that converts a request header into a function parameter based on the specified field.\n\n :param str param_name: The parameter which receives the argument.\n :param Field field: The field class or instance used to deserialize the request header to a Python object.\n :return: A function" }, { "code": "def get_empty_dimension(**kwargs):\n dimension = JSONObject(Dimension())\n dimension.id = None\n dimension.name = ''\n dimension.description = ''\n dimension.project_id = None\n dimension.units = []\n return dimension", "docstring": "Returns a dimension object initialized with empty values" }, { "code": "def scale_image(self):\n new_width = int(self.figcanvas.fwidth *\n self._scalestep ** self._scalefactor)\n new_height = int(self.figcanvas.fheight *\n self._scalestep ** self._scalefactor)\n self.figcanvas.setFixedSize(new_width, new_height)", "docstring": "Scale the image size." }, { "code": "def clear(self):\r\n with self._hlock:\r\n self.handlers.clear()\r\n with self._mlock:\r\n self.memoize.clear()", "docstring": "Discards all registered handlers and cached results" }, { "code": "def qteGetMode(self, mode: str):\n for item in self._qteModeList:\n if item[0] == mode:\n return item\n return None", "docstring": "Return a tuple containing the ``mode``, its value, and\n its associated ``QLabel`` instance.\n\n |Args|\n\n * ``mode`` (**str**): size and position of new window.\n\n |Returns|\n\n * (**str**, **object**, **QLabel**: (mode, value, label).\n\n |Raises|\n\n * **QtmacsArgumentError** if at least one argument has an invalid type." }, { "code": "def _parse(read_method: Callable) -> HTTPResponse:\n response = read_method(4096)\n while b'HTTP/' not in response or b'\\r\\n\\r\\n' not in response:\n response += read_method(4096)\n fake_sock = _FakeSocket(response)\n response = HTTPResponse(fake_sock)\n response.begin()\n return response", "docstring": "Trick to standardize the API between sockets and SSLConnection objects." }, { "code": "def _comparator_lt(filter_value, tested_value):\n if is_string(filter_value):\n value_type = type(tested_value)\n try:\n filter_value = value_type(filter_value)\n except (TypeError, ValueError):\n if value_type is int:\n try:\n filter_value = float(filter_value)\n except (TypeError, ValueError):\n return False\n else:\n return False\n try:\n return tested_value < filter_value\n except TypeError:\n return False", "docstring": "Tests if the filter value is strictly greater than the tested value\n\n tested_value < filter_value" }, { "code": "def text(message: Text,\n default: Text = \"\",\n validate: Union[Type[Validator],\n Callable[[Text], bool],\n None] = None,\n qmark: Text = DEFAULT_QUESTION_PREFIX,\n style: Optional[Style] = None,\n **kwargs: Any) -> Question:\n merged_style = merge_styles([DEFAULT_STYLE, style])\n validator = build_validator(validate)\n def get_prompt_tokens():\n return [(\"class:qmark\", qmark),\n (\"class:question\", ' {} '.format(message))]\n p = PromptSession(get_prompt_tokens,\n style=merged_style,\n validator=validator,\n **kwargs)\n p.default_buffer.reset(Document(default))\n return Question(p.app)", "docstring": "Prompt the user to enter a free text message.\n\n This question type can be used to prompt the user for some text input.\n\n Args:\n message: Question text\n\n default: Default value will be returned if the user just hits\n enter.\n\n validate: Require the entered value to pass a validation. The\n value can not be submited until the validator accepts\n it (e.g. to check minimum password length).\n\n This can either be a function accepting the input and\n returning a boolean, or an class reference to a\n subclass of the prompt toolkit Validator class.\n\n qmark: Question prefix displayed in front of the question.\n By default this is a `?`\n\n style: A custom color and style for the question parts. You can\n configure colors as well as font types for different elements.\n\n Returns:\n Question: Question instance, ready to be prompted (using `.ask()`)." }, { "code": "def analyze_frames(cls, workdir):\r\n record = cls(None, workdir)\r\n obj = {}\r\n with open(os.path.join(workdir, 'frames', 'frames.json')) as f:\r\n obj = json.load(f)\r\n record.device_info = obj['device']\r\n record.frames = obj['frames']\r\n record.analyze_all()\r\n record.save()", "docstring": "generate draft from recorded frames" }, { "code": "def array_append(path, *values, **kwargs):\n return _gen_4spec(LCB_SDCMD_ARRAY_ADD_LAST, path,\n MultiValue(*values),\n create_path=kwargs.pop('create_parents', False),\n **kwargs)", "docstring": "Add new values to the end of an array.\n\n :param path: Path to the array. The path should contain the *array itself*\n and not an element *within* the array\n :param values: one or more values to append\n :param create_parents: Create the array if it does not exist\n\n .. note::\n\n Specifying multiple values in `values` is more than just syntactical\n sugar. It allows the server to insert the values as one single unit.\n If you have multiple values to append to the same array, ensure they\n are specified as multiple arguments to `array_append` rather than\n multiple `array_append` commands to :cb_bmeth:`mutate_in`\n\n This operation is only valid in :cb_bmeth:`mutate_in`.\n\n .. seealso:: :func:`array_prepend`, :func:`upsert`" }, { "code": "def stats(self, ops=(min, max, np.median, sum)):\n names = [op.__name__ for op in ops]\n ops = [_zero_on_type_error(op) for op in ops]\n columns = [[op(column) for op in ops] for column in self.columns]\n table = type(self)().with_columns(zip(self.labels, columns))\n stats = table._unused_label('statistic')\n table[stats] = names\n table.move_to_start(stats)\n return table", "docstring": "Compute statistics for each column and place them in a table." }, { "code": "def get_list_by_name(self, display_name):\n if not display_name:\n raise ValueError('Must provide a valid list display name')\n url = self.build_url(self._endpoints.get('get_list_by_name').format(display_name=display_name))\n response = self.con.get(url)\n if not response:\n return []\n data = response.json()\n return self.list_constructor(parent=self, **{self._cloud_data_key: data})", "docstring": "Returns a sharepoint list based on the display name of the list" }, { "code": "def get_queryset(self):\n queryset = super(MostVotedManager, self).get_queryset()\n sql =\n messages = queryset.extra(\n select={\n 'vote_count': sql,\n }\n )\n return messages.order_by('-vote_count', 'received_time')", "docstring": "Query for the most voted messages sorting by the sum of\n voted and after by date." }, { "code": "def load_pretrained(self, wgts_fname:str, itos_fname:str, strict:bool=True):\n \"Load a pretrained model and adapts it to the data vocabulary.\"\n old_itos = pickle.load(open(itos_fname, 'rb'))\n old_stoi = {v:k for k,v in enumerate(old_itos)}\n wgts = torch.load(wgts_fname, map_location=lambda storage, loc: storage)\n if 'model' in wgts: wgts = wgts['model']\n wgts = convert_weights(wgts, old_stoi, self.data.train_ds.vocab.itos)\n self.model.load_state_dict(wgts, strict=strict)", "docstring": "Load a pretrained model and adapts it to the data vocabulary." }, { "code": "def end_task_type(self, task_type_str):\n assert (\n task_type_str in self._task_dict\n ), \"Task type has not been started yet: {}\".format(task_type_str)\n self._log_progress()\n del self._task_dict[task_type_str]", "docstring": "Call when processing of all tasks of the given type is completed, typically\n just after exiting a loop that processes many tasks of the given type.\n\n Progress messages logged at intervals will typically not include the final entry\n which shows that processing is 100% complete, so a final progress message is\n logged here." }, { "code": "def yield_once(iterator):\n @wraps(iterator)\n def yield_once_generator(*args, **kwargs):\n yielded = set()\n for item in iterator(*args, **kwargs):\n if item not in yielded:\n yielded.add(item)\n yield item\n return yield_once_generator", "docstring": "Decorator to make an iterator returned by a method yield each result only\n once.\n\n >>> @yield_once\n ... def generate_list(foo):\n ... return foo\n >>> list(generate_list([1, 2, 1]))\n [1, 2]\n\n :param iterator: Any method that returns an iterator\n :return: An method returning an iterator\n that yields every result only once at most." }, { "code": "def pretrain(self, train_set, validation_set=None):\n self.do_pretrain = True\n def set_params_func(autoenc, autoencgraph):\n params = autoenc.get_parameters(graph=autoencgraph)\n self.encoding_w_.append(params['enc_w'])\n self.encoding_b_.append(params['enc_b'])\n return SupervisedModel.pretrain_procedure(\n self, self.autoencoders, self.autoencoder_graphs,\n set_params_func=set_params_func, train_set=train_set,\n validation_set=validation_set)", "docstring": "Perform Unsupervised pretraining of the autoencoder." }, { "code": "def get_chain(self, name, table=\"filter\"):\n return [r for r in self.rules if r[\"table\"] == table and r[\"chain\"] == name]", "docstring": "Get the list of rules for a particular chain. Chain order is kept intact.\n\n Args:\n name (str): chain name, e.g. ``\n table (str): table name, defaults to ``filter``\n\n Returns:\n list: rules" }, { "code": "def stream(\n streaming_fn,\n status=200,\n headers=None,\n content_type=\"text/plain; charset=utf-8\",\n):\n return StreamingHTTPResponse(\n streaming_fn, headers=headers, content_type=content_type, status=status\n )", "docstring": "Accepts an coroutine `streaming_fn` which can be used to\n write chunks to a streaming response. Returns a `StreamingHTTPResponse`.\n\n Example usage::\n\n @app.route(\"/\")\n async def index(request):\n async def streaming_fn(response):\n await response.write('foo')\n await response.write('bar')\n\n return stream(streaming_fn, content_type='text/plain')\n\n :param streaming_fn: A coroutine accepts a response and\n writes content to that response.\n :param mime_type: Specific mime_type.\n :param headers: Custom Headers." }, { "code": "def save_metadata_json(self, filename: str, structure: JsonExportable) -> None:\n if self.compress_json:\n filename += '.json.xz'\n else:\n filename += '.json'\n save_structure_to_file(structure, filename)\n if isinstance(structure, (Post, StoryItem)):\n self.context.log('json', end=' ', flush=True)", "docstring": "Saves metadata JSON file of a structure." }, { "code": "def rgb2cmy(self, img, whitebg=False):\n tmp = img*1.0\n if whitebg:\n tmp = (1.0 - (img - img.min())/(img.max() - img.min()))\n out = tmp*0.0\n out[:,:,0] = (tmp[:,:,1] + tmp[:,:,2])/2.0\n out[:,:,1] = (tmp[:,:,0] + tmp[:,:,2])/2.0\n out[:,:,2] = (tmp[:,:,0] + tmp[:,:,1])/2.0\n return out", "docstring": "transforms image from RGB to CMY" }, { "code": "def edit_tab(self, index):\r\n self.setFocus(True)\r\n self.tab_index = index\r\n rect = self.main.tabRect(index)\r\n rect.adjust(1, 1, -2, -1)\r\n self.setFixedSize(rect.size())\r\n self.move(self.main.mapToGlobal(rect.topLeft()))\r\n text = self.main.tabText(index)\r\n text = text.replace(u'&', u'')\r\n if self.split_char:\r\n text = text.split(self.split_char)[self.split_index]\r\n self.setText(text)\r\n self.selectAll()\r\n if not self.isVisible():\r\n self.show()", "docstring": "Activate the edit tab." }, { "code": "def delete(self, database, key, callback=None):\n token = self._get_token()\n self._enqueue(self._PendingItem(token, BlobCommand(token=token, database=database,\n content=DeleteCommand(key=key.bytes)),\n callback))", "docstring": "Delete an item from the given database.\n\n :param database: The database from which to delete the value.\n :type database: .BlobDatabaseID\n :param key: The key to delete.\n :type key: uuid.UUID\n :param callback: A callback to be called on success or failure." }, { "code": "def cartesian_product(arrays, flat=True, copy=False):\n arrays = np.broadcast_arrays(*np.ix_(*arrays))\n if flat:\n return tuple(arr.flatten() if copy else arr.flat for arr in arrays)\n return tuple(arr.copy() if copy else arr for arr in arrays)", "docstring": "Efficient cartesian product of a list of 1D arrays returning the\n expanded array views for each dimensions. By default arrays are\n flattened, which may be controlled with the flat flag. The array\n views can be turned into regular arrays with the copy flag." }, { "code": "def taxon_info(taxid, ncbi, outFH):\n taxid = int(taxid)\n tax_name = ncbi.get_taxid_translator([taxid])[taxid]\n rank = list(ncbi.get_rank([taxid]).values())[0]\n lineage = ncbi.get_taxid_translator(ncbi.get_lineage(taxid))\n lineage = ['{}:{}'.format(k,v) for k,v in lineage.items()]\n lineage = ';'.join(lineage)\n x = [str(x) for x in [tax_name, taxid, rank, lineage]]\n outFH.write('\\t'.join(x) + '\\n')", "docstring": "Write info on taxid" }, { "code": "def undo(self):\n if not self._wasUndo:\n self._qteIndex = len(self._qteStack)\n else:\n self._qteIndex -= 1\n self._wasUndo = True\n if self._qteIndex <= 0:\n return\n undoObj = self._qteStack[self._qteIndex - 1]\n undoObj = QtmacsUndoCommand(undoObj)\n self._push(undoObj)\n if (self._qteIndex - 1) == self._qteLastSavedUndoIndex:\n self.qtesigSavedState.emit(QtmacsMessage())\n self.saveState()", "docstring": "Undo the last command by adding its inverse action to the stack.\n\n This method automatically takes care of applying the correct\n inverse action when it is called consecutively (ie. without a\n calling ``push`` in between).\n\n The ``qtesigSavedState`` signal is triggered whenever enough undo\n operations have been performed to put the document back into the\n last saved state.\n\n ..warning: The ``qtesigSaveState`` is triggered whenever the\n logic of the undo operations **should** have led back to\n that state, but since the ``UndoStack`` only stacks and\n ``QtmacsUndoCommand`` objects it may well be the document is\n **not** in the last saved state, eg. because not all\n modifications were protected by undo objects, or because the\n ``QtmacsUndoCommand`` objects have a bug. It is therefore\n advisable to check in the calling class if the content is\n indeed identical by comparing it with a temporarily stored\n copy.\n\n |Args|\n\n * **None**\n\n |Signals|\n\n * ``qtesigSavedState``: the document is the last saved state.\n\n |Returns|\n\n * **None**\n\n |Raises|\n\n * **None**" }, { "code": "def set_image_path(self, identifier, path):\n f = open(path, 'rb')\n self.set_image_data(identifier, f.read())\n f.close()", "docstring": "Set data for an image mentioned in the template.\n\n @param identifier: Identifier of the image; refer to the image in the\n template by setting \"py3o.[identifier]\" as the name of that image.\n @type identifier: string\n\n @param path: Image path on the file system\n @type path: string" }, { "code": "def _get_lattice_parameters(lattice):\n return np.array(np.sqrt(np.dot(lattice.T, lattice).diagonal()),\n dtype='double')", "docstring": "Return basis vector lengths\n\n Parameters\n ----------\n lattice : array_like\n Basis vectors given as column vectors\n shape=(3, 3), dtype='double'\n\n Returns\n -------\n ndarray, shape=(3,), dtype='double'" }, { "code": "def descendants(self, node, relations=None, reflexive=False):\n if reflexive:\n decs = self.descendants(node, relations, reflexive=False)\n decs.append(node)\n return decs\n g = None\n if relations is None:\n g = self.get_graph()\n else:\n g = self.get_filtered_graph(relations)\n if node in g:\n return list(nx.descendants(g, node))\n else:\n return []", "docstring": "Returns all descendants of specified node.\n\n The default implementation is to use networkx, but some\n implementations of the Ontology class may use a database or\n service backed implementation, for large graphs.\n\n\n Arguments\n ---------\n node : str\n identifier for node in ontology\n reflexive : bool\n if true, return query node in graph\n relations : list\n relation (object property) IDs used to filter\n\n Returns\n -------\n list[str]\n descendant node IDs" }, { "code": "def get_adjustable_form(self, element_dispatch):\n adjustable_form = {}\n for key in element_dispatch.keys():\n adjustable_form[key] = element_dispatch[key]()\n return adjustable_form", "docstring": "Create an adjustable form from an element dispatch table." }, { "code": "def raw_diff(self):\n udiff_copy = self.copy_iterator()\n if self.__format == 'gitdiff':\n udiff_copy = self._parse_gitdiff(udiff_copy)\n return u''.join(udiff_copy)", "docstring": "Returns raw string as udiff" }, { "code": "def get_max_levels_metadata(self):\n metadata = dict(self._max_levels_metadata)\n metadata.update({'existing_cardinal_values': self.my_osid_object_form._my_map['maxLevels']})\n return Metadata(**metadata)", "docstring": "get the metadata for max levels" }, { "code": "def _get_ancestors_path(self, model, levels=None):\n if not issubclass(model, self.model):\n raise ValueError(\n \"%r is not a subclass of %r\" % (model, self.model))\n ancestry = []\n parent_link = model._meta.get_ancestor_link(self.model)\n if levels:\n levels -= 1\n while parent_link is not None:\n related = parent_link.remote_field\n ancestry.insert(0, related.get_accessor_name())\n if levels or levels is None:\n parent_model = related.model\n parent_link = parent_model._meta.get_ancestor_link(\n self.model)\n else:\n parent_link = None\n return LOOKUP_SEP.join(ancestry)", "docstring": "Serves as an opposite to _get_subclasses_recurse, instead walking from\n the Model class up the Model's ancestry and constructing the desired\n select_related string backwards." }, { "code": "def hx2dp(string):\n string = stypes.stringToCharP(string)\n lenout = ctypes.c_int(80)\n errmsg = stypes.stringToCharP(lenout)\n number = ctypes.c_double()\n error = ctypes.c_int()\n libspice.hx2dp_c(string, lenout, ctypes.byref(number), ctypes.byref(error),\n errmsg)\n if not error.value:\n return number.value\n else:\n return stypes.toPythonString(errmsg)", "docstring": "Convert a string representing a double precision number in a\n base 16 scientific notation into its equivalent double\n precision number.\n\n http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/hx2dp_c.html\n\n :param string: Hex form string to convert to double precision.\n :type string: str\n :return: Double precision value to be returned, Or Error Message.\n :rtype: float or str" }, { "code": "def StatFS(self, path=None):\n if platform.system() == \"Windows\":\n raise RuntimeError(\"os.statvfs not available on Windows\")\n local_path = client_utils.CanonicalPathToLocalPath(path or self.path)\n return os.statvfs(local_path)", "docstring": "Call os.statvfs for a given list of rdf_paths.\n\n OS X and Linux only.\n\n Note that a statvfs call for a network filesystem (e.g. NFS) that is\n unavailable, e.g. due to no network, will result in the call blocking.\n\n Args:\n path: a Unicode string containing the path or None. If path is None the\n value in self.path is used.\n\n Returns:\n posix.statvfs_result object\n Raises:\n RuntimeError: if called on windows" }, { "code": "def set_state(self, state, *, index=0):\n return self.set_values({\n ATTR_DEVICE_STATE: int(state)\n }, index=index)", "docstring": "Set state of a light." }, { "code": "def read_file(self, url, location=None):\n response = requests_retry_session().get(url, timeout=10.0)\n response.raise_for_status()\n text = response.text\n if 'tab-width' in self.options:\n text = text.expandtabs(self.options['tab-width'])\n return text.splitlines(True)", "docstring": "Read content from the web by overriding\n `LiteralIncludeReader.read_file`." }, { "code": "def remove_volume(self):\n\t\tlvremove_cmd = ['sudo'] if self.lvm_command().sudo() is True else []\n\t\tlvremove_cmd.extend(['lvremove', '-f', self.volume_path()])\n\t\tsubprocess.check_output(lvremove_cmd, timeout=self.__class__.__lvm_snapshot_remove_cmd_timeout__)", "docstring": "Remove this volume\n\n\t\t:return: None" }, { "code": "def _convert_simple_value_boolean_query_to_and_boolean_queries(tree, keyword):\n def _create_operator_node(value_node):\n base_node = value_node.op if isinstance(value_node, NotOp) else value_node\n updated_base_node = KeywordOp(keyword, base_node) if keyword else ValueOp(base_node)\n return NotOp(updated_base_node) if isinstance(value_node, NotOp) else updated_base_node\n def _get_bool_op_type(bool_op):\n return AndOp if isinstance(bool_op, And) else OrOp\n new_tree_root = _get_bool_op_type(tree.bool_op)(None, None)\n current_tree = new_tree_root\n previous_tree = tree\n while True:\n current_tree.left = _create_operator_node(previous_tree.left)\n if not isinstance(previous_tree.right, SimpleValueBooleanQuery):\n current_tree.right = _create_operator_node(previous_tree.right)\n break\n previous_tree = previous_tree.right\n current_tree.right = _get_bool_op_type(previous_tree.bool_op)(None, None)\n current_tree = current_tree.right\n return new_tree_root", "docstring": "Chain SimpleValueBooleanQuery values into chained AndOp queries with the given current Keyword." }, { "code": "def get_directory_list_doc(self, configs):\n if not isinstance(configs, (tuple, list)):\n configs = [configs]\n util.check_list_type(configs, dict, 'configs', allow_none=False)\n return self.__directory_list_descriptor(configs)", "docstring": "JSON dict description of a protorpc.remote.Service in list format.\n\n Args:\n configs: Either a single dict or a list of dicts containing the service\n configurations to list.\n\n Returns:\n dict, The directory list document as a JSON dict." }, { "code": "def is_url(path):\n try:\n parse_result = urlparse(path)\n return all((parse_result.scheme, parse_result.netloc, parse_result.path))\n except ValueError:\n return False", "docstring": "Test if path represents a valid URL.\n\n :param str path: Path to file.\n :return: True if path is valid url string, False otherwise.\n :rtype: :py:obj:`True` or :py:obj:`False`" }, { "code": "def save_form(self, request, form, change):\n name = form.cleaned_data['name']\n origin_url = form.cleaned_data['origin_url']\n res = ClonedRepo(name=name, origin=origin_url)\n LOG.info(\"New repo form produced %s\" % str(res))\n form.save(commit=False)\n return res", "docstring": "Here we pluck out the data to create a new cloned repo.\n\n Form is an instance of NewRepoForm." }, { "code": "def dumps(columns):\n fp = BytesIO()\n dump(columns, fp)\n fp.seek(0)\n return fp.read()", "docstring": "Serialize ``columns`` to a JSON formatted ``bytes`` object." }, { "code": "def app(environ, start_response):\n try:\n if environ['REQUEST_METHOD'] == 'GET':\n start_response('200 OK', [('content-type', 'text/html')])\n return ['Hellow world!']\n else:\n start_response(\n '405 Method Not Allowed', [('content-type', 'text/html')])\n return ['']\n except Exception as ex:\n start_response(\n '500 Internal Server Error',\n [('content-type', 'text/html')],\n sys.exc_info())\n return _handle_exc(ex)", "docstring": "Simple WSGI application. Returns 200 OK response with 'Hellow world!' in\n the body for GET requests. Returns 405 Method Not Allowed for all other\n methods.\n\n Returns 500 Internal Server Error if an exception is thrown. The response\n body will not include the error or any information about it. The error and\n its stack trace will be reported to FogBugz via BugzScout, though.\n\n :param environ: WSGI environ\n :param start_response: function that accepts status string and headers" }, { "code": "def files_cp(self, source, dest, **kwargs):\n args = (source, dest)\n return self._client.request('/files/cp', args, **kwargs)", "docstring": "Copies files within the MFS.\n\n Due to the nature of IPFS this will not actually involve any of the\n file's content being copied.\n\n .. code-block:: python\n\n >>> c.files_ls(\"/\")\n {'Entries': [\n {'Size': 0, 'Hash': '', 'Name': 'Software', 'Type': 0},\n {'Size': 0, 'Hash': '', 'Name': 'test', 'Type': 0}\n ]}\n >>> c.files_cp(\"/test\", \"/bla\")\n ''\n >>> c.files_ls(\"/\")\n {'Entries': [\n {'Size': 0, 'Hash': '', 'Name': 'Software', 'Type': 0},\n {'Size': 0, 'Hash': '', 'Name': 'bla', 'Type': 0},\n {'Size': 0, 'Hash': '', 'Name': 'test', 'Type': 0}\n ]}\n\n Parameters\n ----------\n source : str\n Filepath within the MFS to copy from\n dest : str\n Destination filepath with the MFS to which the file will be\n copied to" }, { "code": "def part(z, s):\n r\n if sage_included:\n if s == 1: return np.real(z)\n elif s == -1: return np.imag(z)\n elif s == 0:\n return z\n else:\n if s == 1: return z.real\n elif s == -1: return z.imag\n elif s == 0: return z", "docstring": "r\"\"\"Get the real or imaginary part of a complex number." }, { "code": "def _import_parsers():\n global ARCGIS_NODES\n global ARCGIS_ROOTS\n global ArcGISParser\n global FGDC_ROOT\n global FgdcParser\n global ISO_ROOTS\n global IsoParser\n global VALID_ROOTS\n if ARCGIS_NODES is None or ARCGIS_ROOTS is None or ArcGISParser is None:\n from gis_metadata.arcgis_metadata_parser import ARCGIS_NODES\n from gis_metadata.arcgis_metadata_parser import ARCGIS_ROOTS\n from gis_metadata.arcgis_metadata_parser import ArcGISParser\n if FGDC_ROOT is None or FgdcParser is None:\n from gis_metadata.fgdc_metadata_parser import FGDC_ROOT\n from gis_metadata.fgdc_metadata_parser import FgdcParser\n if ISO_ROOTS is None or IsoParser is None:\n from gis_metadata.iso_metadata_parser import ISO_ROOTS\n from gis_metadata.iso_metadata_parser import IsoParser\n if VALID_ROOTS is None:\n VALID_ROOTS = {FGDC_ROOT}.union(ARCGIS_ROOTS + ISO_ROOTS)", "docstring": "Lazy imports to prevent circular dependencies between this module and utils" }, { "code": "def put(self, template_name):\n self.reqparse.add_argument('template', type=str, required=True)\n args = self.reqparse.parse_args()\n template = db.Template.find_one(template_name=template_name)\n if not template:\n return self.make_response('No such template found', HTTP.NOT_FOUND)\n changes = diff(template.template, args['template'])\n template.template = args['template']\n template.is_modified = True\n db.session.add(template)\n db.session.commit()\n auditlog(\n event='template.update',\n actor=session['user'].username,\n data={\n 'template_name': template_name,\n 'template_changes': changes\n }\n )\n return self.make_response('Template {} has been updated'.format(template_name))", "docstring": "Update a template" }, { "code": "def _valid_locales(locales, normalize):\n if normalize:\n normalizer = lambda x: locale.normalize(x.strip())\n else:\n normalizer = lambda x: x.strip()\n return list(filter(can_set_locale, map(normalizer, locales)))", "docstring": "Return a list of normalized locales that do not throw an ``Exception``\n when set.\n\n Parameters\n ----------\n locales : str\n A string where each locale is separated by a newline.\n normalize : bool\n Whether to call ``locale.normalize`` on each locale.\n\n Returns\n -------\n valid_locales : list\n A list of valid locales." }, { "code": "def attr_sep(self, new_sep: str) -> None:\n self._attr_sep = new_sep\n self._filters_tree = self._generate_filters_tree()", "docstring": "Set the new value for the attribute separator.\n \n When the new value is assigned a new tree is generated." }, { "code": "def commit(\n self,\n message: str,\n files_to_add: typing.Optional[typing.Union[typing.List[str], str]] = None,\n allow_empty: bool = False,\n ):\n message = str(message)\n LOGGER.debug('message: %s', message)\n files_to_add = self._sanitize_files_to_add(files_to_add)\n LOGGER.debug('files to add: %s', files_to_add)\n if not message:\n LOGGER.error('empty commit message')\n sys.exit(-1)\n if os.getenv('APPVEYOR'):\n LOGGER.info('committing on AV, adding skip_ci tag')\n message = self.add_skip_ci_to_commit_msg(message)\n if files_to_add is None:\n self.stage_all()\n else:\n self.reset_index()\n self.stage_subset(*files_to_add)\n if self.index_is_empty() and not allow_empty:\n LOGGER.error('empty commit')\n sys.exit(-1)\n self.repo.index.commit(message=message)", "docstring": "Commits changes to the repo\n\n :param message: first line of the message\n :type message: str\n :param files_to_add: files to commit\n :type files_to_add: optional list of str\n :param allow_empty: allow dummy commit\n :type allow_empty: bool" }, { "code": "def clamp(color, min_v, max_v):\n h, s, v = rgb_to_hsv(*map(down_scale, color))\n min_v, max_v = map(down_scale, (min_v, max_v))\n v = min(max(min_v, v), max_v)\n return tuple(map(up_scale, hsv_to_rgb(h, s, v)))", "docstring": "Clamps a color such that the value is between min_v and max_v." }, { "code": "def to_nullable_string(value):\n if value == None:\n return None\n if type(value) == datetime.date:\n return value.isoformat()\n if type(value) == datetime.datetime:\n if value.tzinfo == None:\n return value.isoformat() + \"Z\"\n else:\n return value.isoformat()\n if type(value) == list:\n builder = ''\n for element in value:\n if len(builder) > 0:\n builder = builder + \",\"\n builder = builder + element\n return builder.__str__()\n return str(value)", "docstring": "Converts value into string or returns None when value is None.\n\n :param value: the value to convert.\n\n :return: string value or None when value is None." }, { "code": "def remove_duplicates(self, configs=None):\n if configs is None:\n c = self.configs\n else:\n c = configs\n struct = c.view(c.dtype.descr * 4)\n configs_unique = np.unique(struct).view(c.dtype).reshape(-1, 4)\n if configs is None:\n self.configs = configs_unique\n else:\n return configs_unique", "docstring": "remove duplicate entries from 4-point configurations. If no\n configurations are provided, then use self.configs. Unique\n configurations are only returned if configs is not None.\n\n Parameters\n ----------\n configs: Nx4 numpy.ndarray, optional\n remove duplicates from these configurations instead from\n self.configs.\n\n Returns\n -------\n configs_unique: Kx4 numpy.ndarray\n unique configurations. Only returned if configs is not None" }, { "code": "def download_saved_posts(self, max_count: int = None, fast_update: bool = False,\n post_filter: Optional[Callable[[Post], bool]] = None) -> None:\n self.context.log(\"Retrieving saved posts...\")\n count = 1\n for post in Profile.from_username(self.context, self.context.username).get_saved_posts():\n if max_count is not None and count > max_count:\n break\n if post_filter is not None and not post_filter(post):\n self.context.log(\"<{} skipped>\".format(post), flush=True)\n continue\n self.context.log(\"[{:>3}] \".format(count), end=str(), flush=True)\n count += 1\n with self.context.error_catcher('Download saved posts'):\n downloaded = self.download_post(post, target=':saved')\n if fast_update and not downloaded:\n break", "docstring": "Download user's saved pictures.\n\n :param max_count: Maximum count of pictures to download\n :param fast_update: If true, abort when first already-downloaded picture is encountered\n :param post_filter: function(post), which returns True if given picture should be downloaded" }, { "code": "def look_at(self, x, y, z):\n for camera in self.cameras:\n camera.look_at(x, y, z)", "docstring": "Converges the two cameras to look at the specific point" }, { "code": "def make_basic_table(self, file_type):\n table_data = {sample: items['kv']\n for sample, items\n in self.mod_data[file_type].items()\n }\n table_headers = {}\n for column_header, (description, header_options) in file_types[file_type]['kv_descriptions'].items():\n table_headers[column_header] = {\n 'rid': '{}_{}_bbmstheader'.format(file_type, column_header),\n 'title': column_header,\n 'description': description,\n }\n table_headers[column_header].update(header_options)\n tconfig = {\n 'id': file_type + '_bbm_table',\n 'namespace': 'BBTools'\n }\n for sample in table_data:\n for key, value in table_data[sample].items():\n try:\n table_data[sample][key] = float(value)\n except ValueError:\n pass\n return table.plot(table_data, table_headers, tconfig)", "docstring": "Create table of key-value items in 'file_type'." }, { "code": "def configure(project=LOGGING_PROJECT):\n if not project:\n sys.stderr.write('!! Error: The $LOGGING_PROJECT enviroment '\n 'variable is required in order to set up cloud logging. '\n 'Cloud logging is disabled.\\n')\n return\n try:\n with contextlib.redirect_stderr(io.StringIO()):\n client = glog.Client(project)\n client.setup_logging(logging.INFO)\n except:\n logging.basicConfig(level=logging.INFO)\n sys.stderr.write('!! Cloud logging disabled\\n')", "docstring": "Configures cloud logging\n\n This is called for all main calls. If a $LOGGING_PROJECT is environment\n variable configured, then STDERR and STDOUT are redirected to cloud\n logging." }, { "code": "def _clean_text(self, branch):\r\n if branch.text and self.input_text_formatter:\r\n branch.text = self.input_text_formatter(branch.text)\r\n try:\r\n for child in branch:\r\n self._clean_text(child)\r\n if branch.text and branch.text.find(child.text) >= 0:\r\n branch.text = branch.text.replace(child.text, '', 1)\r\n except TypeError:\n pass", "docstring": "Remove text from node if same text exists in its children.\r\n Apply string formatter if set." }, { "code": "def folder2db(folder_name, debug, energy_limit, skip_folders,\n goto_reaction):\n folder_name = folder_name.rstrip('/')\n skip = []\n for s in skip_folders.split(', '):\n for sk in s.split(','):\n skip.append(sk)\n pub_id = _folder2db.main(folder_name, debug, energy_limit,\n skip, goto_reaction)\n if pub_id:\n print('')\n print('')\n print('Ready to release the data?')\n print(\n \" Send it to the Catalysis-Hub server with 'cathub db2server {folder_name}/{pub_id}.db'.\".format(**locals()))\n print(\" Then log in at www.catalysis-hub.org/upload/ to verify and release. \")", "docstring": "Read folder and collect data in local sqlite3 database" }, { "code": "def get_module_files(src_directory, blacklist, list_all=False):\n files = []\n for directory, dirnames, filenames in os.walk(src_directory):\n if directory in blacklist:\n continue\n _handle_blacklist(blacklist, dirnames, filenames)\n if not list_all and \"__init__.py\" not in filenames:\n dirnames[:] = ()\n continue\n for filename in filenames:\n if _is_python_file(filename):\n src = os.path.join(directory, filename)\n files.append(src)\n return files", "docstring": "given a package directory return a list of all available python\n module's files in the package and its subpackages\n\n :type src_directory: str\n :param src_directory:\n path of the directory corresponding to the package\n\n :type blacklist: list or tuple\n :param blacklist: iterable\n list of files or directories to ignore.\n\n :type list_all: bool\n :param list_all:\n get files from all paths, including ones without __init__.py\n\n :rtype: list\n :return:\n the list of all available python module's files in the package and\n its subpackages" }, { "code": "def validate_pattern(fn):\n directory, pattern = parse_pattern(fn)\n if directory is None:\n print_err(\"Invalid pattern {}.\".format(fn))\n return None, None\n target = resolve_path(directory)\n mode = auto(get_mode, target)\n if not mode_exists(mode):\n print_err(\"cannot access '{}': No such file or directory\".format(fn))\n return None, None\n if not mode_isdir(mode):\n print_err(\"cannot access '{}': Not a directory\".format(fn))\n return None, None\n return target, pattern", "docstring": "On success return an absolute path and a pattern.\n Otherwise print a message and return None, None" }, { "code": "def _get_texture(arr, default, n_items, from_bounds):\n if not hasattr(default, '__len__'):\n default = [default]\n n_cols = len(default)\n if arr is None:\n arr = np.tile(default, (n_items, 1))\n assert arr.shape == (n_items, n_cols)\n arr = arr[np.newaxis, ...].astype(np.float64)\n assert arr.shape == (1, n_items, n_cols)\n assert len(from_bounds) == 2\n m, M = map(float, from_bounds)\n assert np.all(arr >= m)\n assert np.all(arr <= M)\n arr = (arr - m) / (M - m)\n assert np.all(arr >= 0)\n assert np.all(arr <= 1.)\n return arr", "docstring": "Prepare data to be uploaded as a texture.\n\n The from_bounds must be specified." }, { "code": "def expand_models(self, target, data):\n if isinstance(data, dict):\n data = data.values()\n for chunk in data:\n if target in chunk:\n yield self.init_target_object(target, chunk)\n else:\n for key, item in chunk.items():\n yield self.init_single_object(key, item)", "docstring": "Generates all objects from given data." }, { "code": "def int_imf_dm(m1,m2,m,imf,bywhat='bymass',integral='normal'):\n ind_m = (m >= min(m1,m2)) & (m <= max(m1,m2))\n if integral is 'normal':\n int_func = sc.integrate.trapz\n elif integral is 'cum':\n int_func = sc.integrate.cumtrapz\n else:\n print(\"Error in int_imf_dm: don't know how to integrate\")\n return 0\n if bywhat is 'bymass':\n return int_func(m[ind_m]*imf[ind_m],m[ind_m])\n elif bywhat is 'bynumber':\n return int_func(imf[ind_m],m[ind_m])\n else:\n print(\"Error in int_imf_dm: don't know by what to integrate\")\n return 0", "docstring": "Integrate IMF between m1 and m2.\n\n Parameters\n ----------\n m1 : float\n Min mass\n m2 : float\n Max mass\n m : float\n Mass array\n imf : float\n IMF array\n bywhat : string, optional\n 'bymass' integrates the mass that goes into stars of\n that mass interval; or 'bynumber' which integrates the number\n of stars in that mass interval. The default is 'bymass'.\n integrate : string, optional\n 'normal' uses sc.integrate.trapz; 'cum' returns cumulative\n trapezoidal integral. The default is 'normal'." }, { "code": "def finditer_noregex(string, sub, whole_word):\n start = 0\n while True:\n start = string.find(sub, start)\n if start == -1:\n return\n if whole_word:\n if start:\n pchar = string[start - 1]\n else:\n pchar = ' '\n try:\n nchar = string[start + len(sub)]\n except IndexError:\n nchar = ' '\n if nchar in DocumentWordsProvider.separators and \\\n pchar in DocumentWordsProvider.separators:\n yield start\n start += len(sub)\n else:\n yield start\n start += 1", "docstring": "Search occurrences using str.find instead of regular expressions.\n\n :param string: string to parse\n :param sub: search string\n :param whole_word: True to select whole words only" }, { "code": "def get_aligned_collection(self, value=0, data_type=None, unit=None, mutable=None):\n header = self._check_aligned_header(data_type, unit)\n values = self._check_aligned_value(value)\n if mutable is None:\n collection = self.__class__(header, values, self.datetimes)\n else:\n if self._enumeration is None:\n self._get_mutable_enumeration()\n if mutable is False:\n col_obj = self._enumeration['immutable'][self._collection_type]\n else:\n col_obj = self._enumeration['mutable'][self._collection_type]\n collection = col_obj(header, values, self.datetimes)\n collection._validated_a_period = self._validated_a_period\n return collection", "docstring": "Return a Collection aligned with this one composed of one repeated value.\n\n Aligned Data Collections are of the same Data Collection class, have the same\n number of values and have matching datetimes.\n\n Args:\n value: A value to be repeated in the aliged collection values or\n A list of values that has the same length as this collection.\n Default: 0.\n data_type: The data type of the aligned collection. Default is to\n use the data type of this collection.\n unit: The unit of the aligned collection. Default is to\n use the unit of this collection or the base unit of the\n input data_type (if it exists).\n mutable: An optional Boolean to set whether the returned aligned\n collection is mutable (True) or immutable (False). The default is\n None, which will simply set the aligned collection to have the\n same mutability as the starting collection." }, { "code": "def _build_from(baseip):\n from ipaddress import ip_address\n try:\n ip_address(baseip)\n except ValueError:\n if 'http' not in baseip[0:4].lower():\n baseip = urlunsplit(['http', baseip, '', '', ''])\n spl = urlsplit(baseip)\n if '.xml' not in spl.path:\n sep = '' if spl.path.endswith('/') else '/'\n spl = spl._replace(path=spl.path+sep+'description.xml')\n return spl.geturl()\n else:\n return urlunsplit(('http', baseip, '/description.xml', '', ''))", "docstring": "Build URL for description.xml from ip" }, { "code": "def unlink_user_account(self, id, provider, user_id):\n url = self._url('{}/identities/{}/{}'.format(id, provider, user_id))\n return self.client.delete(url)", "docstring": "Unlink a user account\n\n Args:\n id (str): The user_id of the user identity.\n\n provider (str): The type of identity provider (e.g: facebook).\n\n user_id (str): The unique identifier for the user for the identity.\n\n See: https://auth0.com/docs/api/management/v2#!/Users/delete_user_identity_by_user_id" }, { "code": "def switch(scm, to_branch, verbose, fake):\n scm.fake = fake\n scm.verbose = fake or verbose\n scm.repo_check()\n if to_branch is None:\n scm.display_available_branches()\n raise click.BadArgumentUsage('Please specify a branch to switch to')\n scm.stash_log()\n status_log(scm.checkout_branch, 'Switching to {0}.'.format(\n crayons.yellow(to_branch)), to_branch)\n scm.unstash_log()", "docstring": "Switches from one branch to another, safely stashing and restoring local changes." }, { "code": "def perform_request(self, request_type, *args, **kwargs):\n req = api_request(request_type, *args, **kwargs)\n res = self.send_request(req)\n return res", "docstring": "Create and send a request.\n\n `request_type` is the request type (string). This is used to look up a\n plugin, whose request class is instantiated and passed the remaining\n arguments passed to this function." }, { "code": "def worker_edit(worker, lbn, settings, profile='default'):\n settings['cmd'] = 'update'\n settings['mime'] = 'prop'\n settings['w'] = lbn\n settings['sw'] = worker\n return _do_http(settings, profile)['worker.result.type'] == 'OK'", "docstring": "Edit the worker settings\n\n Note: http://tomcat.apache.org/connectors-doc/reference/status.html\n Data Parameters for the standard Update Action\n\n CLI Examples:\n\n .. code-block:: bash\n\n salt '*' modjk.worker_edit node1 loadbalancer1 \"{'vwf': 500, 'vwd': 60}\"\n salt '*' modjk.worker_edit node1 loadbalancer1 \"{'vwf': 500, 'vwd': 60}\" other-profile" }, { "code": "def get_app_names(self):\n app_names = set()\n for name in self.apps:\n app_names.add(name)\n return app_names", "docstring": "Return application names.\n\n Return the list of application names that are available in the\n database.\n\n Returns:\n set of str." }, { "code": "def split_state(self, state):\n if self.state_separator:\n return state.split(self.state_separator)\n return list(state)", "docstring": "Split state string.\n\n Parameters\n ----------\n state : `str`\n\n Returns\n -------\n `list` of `str`" }, { "code": "def _get_dis_func(self, union):\n union_types = union.__args__\n if NoneType in union_types:\n union_types = tuple(\n e for e in union_types if e is not NoneType\n )\n if not all(hasattr(e, \"__attrs_attrs__\") for e in union_types):\n raise ValueError(\n \"Only unions of attr classes supported \"\n \"currently. Register a loads hook manually.\"\n )\n return create_uniq_field_dis_func(*union_types)", "docstring": "Fetch or try creating a disambiguation function for a union." }, { "code": "def set_hostname(hostname=None, deploy=False):\n if not hostname:\n raise CommandExecutionError(\"Hostname option must not be none.\")\n ret = {}\n query = {'type': 'config',\n 'action': 'set',\n 'xpath': '/config/devices/entry[@name=\\'localhost.localdomain\\']/deviceconfig/system',\n 'element': '{0}'.format(hostname)}\n ret.update(__proxy__['panos.call'](query))\n if deploy is True:\n ret.update(commit())\n return ret", "docstring": "Set the hostname of the Palo Alto proxy minion. A commit will be required before this is processed.\n\n CLI Example:\n\n Args:\n hostname (str): The hostname to set\n\n deploy (bool): If true then commit the full candidate configuration, if false only set pending change.\n\n .. code-block:: bash\n\n salt '*' panos.set_hostname newhostname\n salt '*' panos.set_hostname newhostname deploy=True" }, { "code": "def resize(self, w, h):\n self.plane_w = w\n self.plane_h = h\n self.plane_ratio = self.char_ratio * w / h\n if self.crosshairs:\n self.crosshairs_coord = ((w + 2) // 2, (h + 2) // 2)", "docstring": "Used when resizing the plane, resets the plane ratio factor.\n\n :param w: New width of the visible section of the plane.\n :param h: New height of the visible section of the plane." }, { "code": "def _name_with_flags(self, include_restricted, title=None):\n name = \"Special: \" if self.special else \"\"\n name += self.name\n if title:\n name += \" - {}\".format(title)\n if include_restricted and self.restricted:\n name += \" (R)\"\n name += \" (BB)\" if self.both_blocks else \"\"\n name += \" (A)\" if self.administrative else \"\"\n name += \" (S)\" if self.sticky else \"\"\n name += \" (Deleted)\" if self.deleted else \"\"\n return name", "docstring": "Generate the name with flags." }, { "code": "def _write_multiplicons(self, filename):\n mhead = '\\t'.join(['id', 'genome_x', 'list_x', 'parent', 'genome_y',\n 'list_y', 'level', 'number_of_anchorpoints',\n 'profile_length', 'begin_x', 'end_x', 'begin_y',\n 'end_y', 'is_redundant'])\n with open(filename, 'w') as fhandle:\n fhandle.write(mhead + '\\n')\n for mrow in self.multiplicons:\n fhandle.write('\\t'.join([str(e) for e in mrow]) + '\\n')", "docstring": "Write multiplicons to file.\n\n - filename, (str) location of output file" }, { "code": "def _parse_prefix_query(self, query_str):\n sp = smart_parsing.PrefixSmartParser()\n query = sp.parse(query_str)\n return query", "docstring": "Parse a smart search query for prefixes\n\n This is a helper function to smart_search_prefix for easier unit\n testing of the parser." }, { "code": "def get_history(self):\n if hasattr(self, '_history'):\n return self._history\n try:\n self._history = APICallDayHistory.objects.get(\n user=self.user, creation_date=now().date())\n except APICallDayHistory.DoesNotExist:\n self._history = APICallDayHistory(user=self.user)\n self._history.amount_api_calls = 0\n return self._history", "docstring": "Returns the history from cache or DB or a newly created one." }, { "code": "def to_representation(self, value):\n value = apply_subfield_projection(self, value, deep=True)\n return super().to_representation(value)", "docstring": "Project outgoing native value." }, { "code": "def find_one(self, collection, selector={}):\n for _id, doc in self.collection_data.data.get(collection, {}).items():\n doc.update({'_id': _id})\n if selector == {}:\n return doc\n for key, value in selector.items():\n if key in doc and doc[key] == value:\n return doc\n return None", "docstring": "Return one item from a collection\n\n Arguments:\n collection - collection to search\n\n Keyword Arguments:\n selector - the query (default returns first item found)" }, { "code": "def get_leading_spaces(data):\n spaces = ''\n m = re.match(r'^(\\s*)', data)\n if m:\n spaces = m.group(1)\n return spaces", "docstring": "Get the leading space of a string if it is not empty\n\n :type data: str" }, { "code": "def check_link_and_get_info(self, target_id=0xFF):\n for _ in range(0, 5):\n if self._update_info(target_id):\n if self._in_boot_cb:\n self._in_boot_cb.call(True, self.targets[\n target_id].protocol_version)\n if self._info_cb:\n self._info_cb.call(self.targets[target_id])\n return True\n return False", "docstring": "Try to get a connection with the bootloader by requesting info\n 5 times. This let roughly 10 seconds to boot the copter ..." }, { "code": "def get_urls(self):\n urls = super(LayoutAdmin, self).get_urls()\n my_urls = patterns(\n '',\n url(\n r'^placeholder_data/(?P\\d+)/$',\n self.admin_site.admin_view(self.placeholder_data_view),\n name='layout_placeholder_data',\n )\n )\n return my_urls + urls", "docstring": "Add ``layout_placeholder_data`` URL." }, { "code": "def check_for_invalid_columns(\n problems: List, table: str, df: DataFrame\n) -> List:\n r = cs.GTFS_REF\n valid_columns = r.loc[r[\"table\"] == table, \"column\"].values\n for col in df.columns:\n if col not in valid_columns:\n problems.append(\n [\"warning\", f\"Unrecognized column {col}\", table, []]\n )\n return problems", "docstring": "Check for invalid columns in the given GTFS DataFrame.\n\n Parameters\n ----------\n problems : list\n A four-tuple containing\n\n 1. A problem type (string) equal to ``'error'`` or ``'warning'``;\n ``'error'`` means the GTFS is violated;\n ``'warning'`` means there is a problem but it is not a\n GTFS violation\n 2. A message (string) that describes the problem\n 3. A GTFS table name, e.g. ``'routes'``, in which the problem\n occurs\n 4. A list of rows (integers) of the table's DataFrame where the\n problem occurs\n\n table : string\n Name of a GTFS table\n df : DataFrame\n The GTFS table corresponding to ``table``\n\n Returns\n -------\n list\n The ``problems`` list extended as follows.\n Check whether the DataFrame contains extra columns not in the\n GTFS and append to the problems list one warning for each extra\n column." }, { "code": "def ssad(patch, cols, splits):\n sad_results = sad(patch, cols, splits, clean=False)\n for i, sad_result in enumerate(sad_results):\n if i == 0:\n fulldf = sad_result[1]\n fulldf.columns = ['spp', '0']\n else:\n fulldf[str(i)] = sad_result[1]['y']\n result_list = []\n for _, row in fulldf.iterrows():\n row_values_array = np.array(row[1:], dtype=float)\n result_list.append((row[0], pd.DataFrame({'y': row_values_array})))\n return result_list", "docstring": "Calculates an empirical intra-specific spatial abundance distribution\n\n Parameters\n ----------\n {0}\n\n Returns\n -------\n {1} Result has one column giving the individuals of species in each\n subplot.\n\n Notes\n -----\n {2}\n\n {3}\n\n Examples\n --------\n\n {4}\n\n >>> # Get the spatial abundance distribution for all species for each of\n >>> # the cells in the ANBO plot\n >>> all_spp_ssads = meco.empirical.ssad(pat, cols='spp_col:spp; count_col:count', splits='row:4; column:4')\n\n >>> # Convert to dict for easy searching\n >>> all_ssads_dict = dict(all_spp_ssads)\n\n >>> # Look up the spatial abundance distribution for 'grass'\n >>> all_ssads_dict['grass']\n y\n 0 42\n 1 20\n 2 60\n 3 60\n 4 88\n 5 86\n 6 20\n 7 0\n 8 110\n 9 12\n 10 115\n 11 180\n 12 160\n 13 120\n 14 26\n 15 11\n\n >>> # Each value in 'y' gives the abundance of grass in one of the 16 cells\n\n See http://www.macroeco.org/tutorial_macroeco.html for additional\n examples and explanation" }, { "code": "def handle_update(self, options):\n username = options[\"username\"]\n try:\n user = User.objects.get(username=username)\n except User.DoesNotExist:\n raise CommandError(\"User %s does not exist\" % username)\n if options[\"email\"]:\n user.email = options[\"email\"]\n if options[\"active\"] in [True, False]:\n user.is_active = options[\"active\"]\n if options[\"staff\"] in [True, False]:\n user.is_staff = options[\"staff\"]\n if options[\"superuser\"] in [True, False]:\n user.is_superuser = options[\"superuser\"]\n user.save()", "docstring": "Update existing user" }, { "code": "def rpc_stop(server_state):\n rpc_srv = server_state['rpc']\n if rpc_srv is not None:\n log.info(\"Shutting down RPC\")\n rpc_srv.stop_server()\n rpc_srv.join()\n log.info(\"RPC joined\")\n else:\n log.info(\"RPC already joined\")\n server_state['rpc'] = None", "docstring": "Stop the global RPC server thread" }, { "code": "def update_nanopubstore_start_dt(url: str, start_dt: str):\n hostname = urllib.parse.urlsplit(url)[1]\n start_dates_doc = state_mgmt.get(start_dates_doc_key)\n if not start_dates_doc:\n start_dates_doc = {\n \"_key\": start_dates_doc_key,\n \"start_dates\": [{\"nanopubstore\": hostname, \"start_dt\": start_dt}],\n }\n state_mgmt.insert(start_dates_doc)\n else:\n for idx, start_date in enumerate(start_dates_doc[\"start_dates\"]):\n if start_date[\"nanopubstore\"] == hostname:\n start_dates_doc[\"start_dates\"][idx][\"start_dt\"] = start_dt\n break\n else:\n start_dates_doc[\"start_dates\"].append(\n {\"nanopubstore\": hostname, \"start_dt\": start_dt}\n )\n state_mgmt.replace(start_dates_doc)", "docstring": "Add nanopubstore start_dt to belapi.state_mgmt collection\n\n Args:\n url: url of nanopubstore\n start_dt: datetime of last query against nanopubstore for new ID's" }, { "code": "def get_ordered_types(self):\n types = self.get_types()\n types_arr = np.array(types)\n poss = [self.chrPos, self.startPos, self.stopPos]\n if self.strandPos is not None:\n poss.append(self.strandPos)\n if self.otherPos:\n for o in self.otherPos:\n poss.append(o[0])\n idx_sort = np.array(poss).argsort()\n return types_arr[idx_sort].tolist()", "docstring": "Returns the ordered list of data types\n\n :return: list of data types" }, { "code": "def create_simulated_env(\n output_dir, grayscale, resize_width_factor, resize_height_factor,\n frame_stack_size, generative_model, generative_model_params,\n random_starts=True, which_epoch_data=\"last\", **other_hparams\n):\n a_bit_risky_defaults = {\n \"game\": \"pong\",\n \"real_batch_size\": 1,\n \"rl_env_max_episode_steps\": -1,\n \"max_num_noops\": 0\n }\n for key in a_bit_risky_defaults:\n if key not in other_hparams:\n other_hparams[key] = a_bit_risky_defaults[key]\n hparams = hparam.HParams(\n grayscale=grayscale,\n resize_width_factor=resize_width_factor,\n resize_height_factor=resize_height_factor,\n frame_stack_size=frame_stack_size,\n generative_model=generative_model,\n generative_model_params=generative_model_params,\n **other_hparams\n )\n return load_data_and_make_simulated_env(\n output_dir, wm_dir=None, hparams=hparams,\n which_epoch_data=which_epoch_data,\n random_starts=random_starts)", "docstring": "Create SimulatedEnv with minimal subset of hparams." }, { "code": "def check_signature(params):\n if 'id' in params:\n try:\n id_int = int(params['id'][0])\n except:\n my_log_message(args, syslog.LOG_INFO, \"Non-numerical client id (%s) in request.\" % (params['id'][0]))\n return False, None\n key = client_ids.get(id_int)\n if key:\n if 'h' in params:\n sig = params['h'][0]\n good_sig = make_signature(params, key)\n if sig == good_sig:\n return True, key\n else:\n my_log_message(args, syslog.LOG_INFO, \"Bad signature from client id '%i' (%s, expected %s).\" \\\n % (id_int, sig, good_sig))\n else:\n my_log_message(args, syslog.LOG_INFO, \"Client id (%i) but no HMAC in request.\" % (id_int))\n return False, key\n else:\n my_log_message(args, syslog.LOG_INFO, \"Unknown client id '%i'\" % (id_int))\n return False, None\n return True, None", "docstring": "Verify the signature of the parameters in an OTP v2.0 verify request.\n\n Returns ValResultBool, Key" }, { "code": "def remove_all_connections(provider_id):\n provider = get_provider_or_404(provider_id)\n ctx = dict(provider=provider.name, user=current_user)\n deleted = _datastore.delete_connections(user_id=current_user.get_id(),\n provider_id=provider_id)\n if deleted:\n after_this_request(_commit)\n msg = ('All connections to %s removed' % provider.name, 'info')\n connection_removed.send(current_app._get_current_object(),\n user=current_user._get_current_object(),\n provider_id=provider_id)\n else:\n msg = ('Unable to remove connection to %(provider)s' % ctx, 'error')\n do_flash(*msg)\n return redirect(request.referrer)", "docstring": "Remove all connections for the authenticated user to the\n specified provider" }, { "code": "def convert_general(value):\n if isinstance(value, bool):\n return \"true\" if value else \"false\"\n elif isinstance(value, list):\n value = [convert_general(item) for item in value]\n value = convert_to_imgur_list(value)\n elif isinstance(value, Integral):\n return str(value)\n elif 'pyimgur' in str(type(value)):\n return str(getattr(value, 'id', value))\n return value", "docstring": "Take a python object and convert it to the format Imgur expects." }, { "code": "def lifetimes(self):\n r\n return -self._lag / np.log(np.diag(self.transition_matrix))", "docstring": "r\"\"\" Lifetimes of states of the hidden transition matrix\n\n Returns\n -------\n l : ndarray(nstates)\n state lifetimes in units of the input trajectory time step,\n defined by :math:`-tau / ln | p_{ii} |, i = 1,...,nstates`, where\n :math:`p_{ii}` are the diagonal entries of the hidden transition matrix." }, { "code": "def OnLabelSizeIntCtrl(self, event):\n self.attrs[\"labelsize\"] = event.GetValue()\n post_command_event(self, self.DrawChartMsg)", "docstring": "Label size IntCtrl event handler" }, { "code": "def set_cols_align(self, array):\n self._check_row_size(array)\n self._align = array\n return self", "docstring": "Set the desired columns alignment\n\n - the elements of the array should be either \"l\", \"c\" or \"r\":\n\n * \"l\": column flushed left\n * \"c\": column centered\n * \"r\": column flushed right" }, { "code": "def set_permission(permission, value, app):\n script =\n app_url = 'app://' + app\n run_marionette_script(script % (permission, app_url, app_url, value), True)", "docstring": "Set a permission for the specified app\n Value should be 'deny' or 'allow'" }, { "code": "def update_redis(project: str, environment: str, feature: str, state: str) \\\n -> None:\n try:\n hosts = RedisWrapper.connection_string_parser(\n os.environ.get('REDIS_HOSTS'))\n except RuntimeError as ex:\n LOG.error(ex)\n sys.exit(1)\n for host in hosts:\n LOG.info(\"connecting to %s:%s\", host.host, host.port)\n try:\n if valid_state(state):\n new_state = state.lower()\n redis = RedisWrapper(\n host.host,\n host.port,\n project,\n environment\n )\n redis.update_flag_record(new_state, feature)\n create_file(project, environment, feature, new_state)\n LOG.info(\"%s was successfully updated.\", feature)\n else:\n raise Exception('Invalid state: {0}, -s needs \\\n to be either on or off.'.format(state))\n except KeyError as ex:\n LOG.error(\"unable to update %s. Exception: %s\",\n host.host,\n ex)\n sys.exit(1)", "docstring": "Update redis state for a feature flag.\n\n :param project: LaunchDarkly project key.\n :param environment: LaunchDarkly environment key.\n :param feature: LaunchDarkly feature key.\n :param state: State for a feature flag." }, { "code": "def wait_until_stale(self, timeout=None):\n timeout = timeout if timeout is not None else self.driver_wrapper.timeout\n def wait():\n WebDriverWait(self.driver, timeout).until(EC.staleness_of(self.element))\n return self\n return self.execute_and_handle_webelement_exceptions(wait, 'wait for staleness')", "docstring": "Waits for the element to go stale in the DOM\n\n @type timeout: int\n @param timeout: override for default timeout\n\n @rtype: WebElementWrapper\n @return: Self" }, { "code": "def _determine_leftpad(column, point_place):\n ndigits_left = [_find_point(x) for x in column]\n return [max((point_place - 1) - x, 0) for x in ndigits_left]", "docstring": "Find how many spaces to put before a column of numbers\n so that all the decimal points line up\n\n This function takes a column of decimal numbers, and returns a\n vector containing the number of spaces to place before each number\n so that (when possible) the decimal points line up.\n\n\n Parameters\n ----------\n column : list\n Numbers that will be printed as a column\n point_place : int\n Number of the character column to put the decimal point" }, { "code": "def input_file(self, _container):\n p = local.path(_container)\n if set_input_container(p, CFG):\n return\n p = find_hash(CFG[\"container\"][\"known\"].value, container)\n if set_input_container(p, CFG):\n return\n raise ValueError(\"The path '{0}' does not exist.\".format(p))", "docstring": "Find the input path of a uchroot container." }, { "code": "def __get_smtp(self):\n\t\tuse_tls = self.config['shutit.core.alerting.emailer.use_tls']\n\t\tif use_tls:\n\t\t\tsmtp = SMTP(self.config['shutit.core.alerting.emailer.smtp_server'], self.config['shutit.core.alerting.emailer.smtp_port'])\n\t\t\tsmtp.starttls()\n\t\telse:\n\t\t\tsmtp = SMTP_SSL(self.config['shutit.core.alerting.emailer.smtp_server'], self.config['shutit.core.alerting.emailer.smtp_port'])\n\t\treturn smtp", "docstring": "Return the appropraite smtplib depending on wherther we're using TLS" }, { "code": "def doDynamicValidation(self, request: Request):\n self.execute_hook(NodeHooks.PRE_DYNAMIC_VALIDATION, request=request)\n ledger_id, seq_no = self.seqNoDB.get_by_payload_digest(request.payload_digest)\n if ledger_id is not None and seq_no is not None:\n raise SuspiciousPrePrepare('Trying to order already ordered request')\n ledger = self.getLedger(self.ledger_id_for_request(request))\n for txn in ledger.uncommittedTxns:\n if get_payload_digest(txn) == request.payload_digest:\n raise SuspiciousPrePrepare('Trying to order already ordered request')\n operation = request.operation\n req_handler = self.get_req_handler(txn_type=operation[TXN_TYPE])\n req_handler.validate(request)\n self.execute_hook(NodeHooks.POST_DYNAMIC_VALIDATION, request=request)", "docstring": "State based validation" }, { "code": "def parse_http_response(http_response: HttpResponse) -> 'environ.Response':\n try:\n response = environ.Response.deserialize(http_response.json())\n except Exception as error:\n response = environ.Response().fail(\n code='INVALID_REMOTE_RESPONSE',\n error=error,\n message='Invalid HTTP response from remote connection'\n ).console(\n whitespace=1\n ).response\n response.http_response = http_response\n return response", "docstring": "Returns a Cauldron response object parsed from the serialized JSON data\n specified in the http_response argument. If the response doesn't contain\n valid Cauldron response data, an error Cauldron response object is\n returned instead.\n\n :param http_response:\n The response object from an http request that contains a JSON\n serialized Cauldron response object as its body\n :return:\n The Cauldron response object for the given http response" }, { "code": "def sg_sugar_func(func):\n r\n @wraps(func)\n def wrapper(tensor, **kwargs):\n out = func(tensor, tf.sg_opt(kwargs))\n out._sugar = tf.sg_opt(func=func, arg=tf.sg_opt(kwargs)+sg_get_context(), prev=tensor)\n out.sg_reuse = types.MethodType(sg_reuse, out)\n return out\n return wrapper", "docstring": "r\"\"\" Decorates a function `func` so that it can be a sugar function.\n Sugar function can be used in a chainable manner.\n\n Args:\n func: function to decorate\n\n Returns:\n A sugar function." }, { "code": "def get_longest_table(url='https://www.openoffice.org/dev_docs/source/file_extensions.html', header=0):\n dfs = pd.read_html(url, header=header)\n return longest_table(dfs)", "docstring": "Retrieve the HTML tables from a URL and return the longest DataFrame found\n\n >>> get_longest_table('https://en.wikipedia.org/wiki/List_of_sovereign_states').columns\n Index(['Common and formal names', 'Membership within the UN System[a]',\n 'Sovereignty dispute[b]',\n 'Further information on status and recognition of sovereignty[d]'],\n dtype='object')" }, { "code": "def is_visa_electron(n):\n n, length = str(n), len(str(n))\n form = ['026', '508', '844', '913', '917']\n if length == 16:\n if n[0] == '4':\n if ''.join(n[1:4]) in form or ''.join(n[1:6]) == '17500':\n return True\n return False", "docstring": "Checks if credit card number fits the visa electron format." }, { "code": "def dePeriod(arr):\n diff= arr-nu.roll(arr,1,axis=1)\n w= diff < -6.\n addto= nu.cumsum(w.astype(int),axis=1)\n return arr+_TWOPI*addto", "docstring": "make an array of periodic angles increase linearly" }, { "code": "def encode(self, inputs, states=None, valid_length=None):\n return self.encoder(self.src_embed(inputs), states, valid_length)", "docstring": "Encode the input sequence.\n\n Parameters\n ----------\n inputs : NDArray\n states : list of NDArrays or None, default None\n valid_length : NDArray or None, default None\n\n Returns\n -------\n outputs : list\n Outputs of the encoder." }, { "code": "def vi_return_param(self, index):\n if index == 0:\n return self.mu0\n elif index == 1:\n return np.log(self.sigma0)", "docstring": "Wrapper function for selecting appropriate latent variable for variational inference\n\n Parameters\n ----------\n index : int\n 0 or 1 depending on which latent variable\n\n Returns\n ----------\n The appropriate indexed parameter" }, { "code": "def setData(self, type: str, data: str) -> None:\n type = normalize_type(type)\n if type in self.__data:\n del self.__data[type]\n self.__data[type] = data", "docstring": "Set data of type format.\n\n :arg str type: Data format of the data, like 'text/plain'." }, { "code": "def finish(self):\n self.lines.reverse()\n self._content = '\\n'.join(self.lines)\n self.lines = None", "docstring": "Creates block of content with lines\n belonging to fragment." }, { "code": "def _ondim(self, dimension, valuestring):\n try:\n self.dimensions[dimension] = int(valuestring)\n except ValueError:\n self.dimensions[dimension] = 1\n self.textctrls[dimension].SetValue(str(1))\n if self.dimensions[dimension] < 1:\n self.dimensions[dimension] = 1\n self.textctrls[dimension].SetValue(str(1))", "docstring": "Converts valuestring to int and assigns result to self.dim\n\n If there is an error (such as an empty valuestring) or if\n the value is < 1, the value 1 is assigned to self.dim\n\n Parameters\n ----------\n\n dimension: int\n \\tDimension that is to be updated. Must be in [1:4]\n valuestring: string\n \\t A string that can be converted to an int" }, { "code": "def relative(self):\n if not self.is_absolute():\n raise ValueError(\"URL should be absolute\")\n val = self._val._replace(scheme=\"\", netloc=\"\")\n return URL(val, encoded=True)", "docstring": "Return a relative part of the URL.\n\n scheme, user, password, host and port are removed." }, { "code": "def xrb_address_to_public_key(address):\n address = bytearray(address, 'ascii')\n if not address.startswith(b'xrb_'):\n raise ValueError('address does not start with xrb_: %s' % address)\n if len(address) != 64:\n raise ValueError('address must be 64 chars long: %s' % address)\n address = bytes(address)\n key_b32xrb = b'1111' + address[4:56]\n key_bytes = b32xrb_decode(key_b32xrb)[3:]\n checksum = address[56:]\n if b32xrb_encode(address_checksum(key_bytes)) != checksum:\n raise ValueError('invalid address, invalid checksum: %s' % address)\n return key_bytes", "docstring": "Convert an xrb address to public key in bytes\n\n >>> xrb_address_to_public_key('xrb_1e3i81r51e3i81r51e3i81r51e3i'\\\n '81r51e3i81r51e3i81r51e3imxssakuq')\n b'00000000000000000000000000000000'\n\n :param address: xrb address\n :type address: bytes\n\n :return: public key in bytes\n :rtype: bytes\n\n :raises ValueError:" }, { "code": "def check_espeak(cls):\n try:\n from aeneas.textfile import TextFile\n from aeneas.textfile import TextFragment\n from aeneas.ttswrappers.espeakttswrapper import ESPEAKTTSWrapper\n text = u\"From fairest creatures we desire increase,\"\n text_file = TextFile()\n text_file.add_fragment(TextFragment(language=u\"eng\", lines=[text], filtered_lines=[text]))\n handler, output_file_path = gf.tmp_file(suffix=u\".wav\")\n ESPEAKTTSWrapper().synthesize_multiple(text_file, output_file_path)\n gf.delete_file(handler, output_file_path)\n gf.print_success(u\"espeak OK\")\n return False\n except:\n pass\n gf.print_error(u\"espeak ERROR\")\n gf.print_info(u\" Please make sure you have espeak installed correctly\")\n gf.print_info(u\" and that its path is in your PATH environment variable\")\n gf.print_info(u\" You might also want to check that the espeak-data directory\")\n gf.print_info(u\" is set up correctly, for example, it has the correct permissions\")\n return True", "docstring": "Check whether ``espeak`` can be called.\n\n Return ``True`` on failure and ``False`` on success.\n\n :rtype: bool" }, { "code": "def surrounding_nodes(self, position):\n n_node_index, n_node_position, n_node_error = self.nearest_node(position)\n if n_node_error == 0.0:\n index_mod = []\n for i in range(len(n_node_index)):\n new_point = np.asarray(n_node_position)\n new_point[i] += 1.e-5*np.abs(new_point[i])\n try:\n self.nearest_node(tuple(new_point))\n index_mod.append(-1)\n except ValueError:\n index_mod.append(1)\n else:\n index_mod = []\n for i in range(len(n_node_index)):\n if n_node_position[i] > position[i]:\n index_mod.append(-1)\n else:\n index_mod.append(1)\n return tuple(n_node_index), tuple(index_mod)", "docstring": "Returns nearest node indices and direction of opposite node.\n\n :param position: Position inside the mesh to search nearest node for as (x,y,z)\n :return: Nearest node indices and direction of opposite node." }, { "code": "def excluded_length(self):\n return sum([shot.length for shot in self.shots if Exclude.LENGTH in shot.flags or Exclude.TOTAL in shot.flags])", "docstring": "Surveyed length which does not count toward the included total" }, { "code": "def validate(self, cmd, messages=None):\n valid = True\n args = [ arg for arg in cmd.args if arg is not None ]\n if self.nargs != len(args):\n valid = False\n if messages is not None:\n msg = 'Expected %d arguments, but received %d.'\n messages.append(msg % (self.nargs, len(args)))\n for defn, value in zip(self.args, cmd.args):\n if value is None:\n valid = False\n if messages is not None:\n messages.append('Argument \"%s\" is missing.' % defn.name)\n elif defn.validate(value, messages) is False:\n valid = False\n if len(cmd._unrecognized) > 0:\n valid = False\n if messages is not None:\n for name in cmd.unrecognized:\n messages.append('Argument \"%s\" is unrecognized.' % name)\n return valid", "docstring": "Returns True if the given Command is valid, False otherwise.\n Validation error messages are appended to an optional messages\n array." }, { "code": "def reread(self):\n logger.debug(\"Loading credentials from %s\",\n os.path.abspath(self.creds_filename))\n creds = {}\n try:\n with self.open_creds() as fp:\n creds = yaml.safe_load(fp)\n except IOError:\n logger.info(\"No credentials file found at %s\",\n os.path.abspath(self.creds_filename))\n except:\n logger.exception(\"Error loading credentials file\")\n if creds != self.creds:\n self.creds = creds\n return True\n return False", "docstring": "Read and parse credentials file.\n If something goes wrong, log exception and continue." }, { "code": "def _generate_feed(self, feed_data):\n atom_feed = self._render_html('atom.xml', feed_data)\n feed_path = os.path.join(os.getcwd(), 'public', 'atom.xml')\n with codecs.open(feed_path, 'wb', 'utf-8') as f:\n f.write(atom_feed)", "docstring": "render feed file with data" }, { "code": "def run(self, gates, n_qubits, *args, **kwargs):\n return self._run(gates, n_qubits, args, kwargs)", "docstring": "Run the backend." }, { "code": "def ones_comp_sum16(num1: int, num2: int) -> int:\n carry = 1 << 16\n result = num1 + num2\n return result if result < carry else result + 1 - carry", "docstring": "Calculates the 1's complement sum for 16-bit numbers.\n\n Args:\n num1: 16-bit number.\n num2: 16-bit number.\n\n Returns:\n The calculated result." }, { "code": "def to_struct(self, value):\n if self.str_format:\n return value.strftime(self.str_format)\n return value.strftime(self.default_format)", "docstring": "Cast `date` object to string." }, { "code": "def disable_component(self, component):\n if not isinstance(component, type):\n component = component.__class__\n self.enabled[component] = False\n self.components[component] = None", "docstring": "Force a component to be disabled.\n\n :param component: can be a class or an instance." }, { "code": "def _process_thread(self, client):\n file_list = self.files\n if not file_list:\n return\n print('Filefinder to collect {0:d} items'.format(len(file_list)))\n flow_action = flows_pb2.FileFinderAction(\n action_type=flows_pb2.FileFinderAction.DOWNLOAD)\n flow_args = flows_pb2.FileFinderArgs(\n paths=file_list,\n action=flow_action,)\n flow_id = self._launch_flow(client, 'FileFinder', flow_args)\n self._await_flow(client, flow_id)\n collected_flow_data = self._download_files(client, flow_id)\n if collected_flow_data:\n print('{0!s}: Downloaded: {1:s}'.format(flow_id, collected_flow_data))\n fqdn = client.data.os_info.fqdn.lower()\n self.state.output.append((fqdn, collected_flow_data))", "docstring": "Process a single client.\n\n Args:\n client: GRR client object to act on." }, { "code": "def AddExtraShapes(extra_shapes_txt, graph):\n print(\"Adding extra shapes from %s\" % extra_shapes_txt)\n try:\n tmpdir = tempfile.mkdtemp()\n shutil.copy(extra_shapes_txt, os.path.join(tmpdir, 'shapes.txt'))\n loader = transitfeed.ShapeLoader(tmpdir)\n schedule = loader.Load()\n for shape in schedule.GetShapeList():\n print(\"Adding extra shape: %s\" % shape.shape_id)\n graph.AddPoly(ShapeToPoly(shape))\n finally:\n if tmpdir:\n shutil.rmtree(tmpdir)", "docstring": "Add extra shapes into our input set by parsing them out of a GTFS-formatted\n shapes.txt file. Useful for manually adding lines to a shape file, since it's\n a pain to edit .shp files." }, { "code": "def extract_zip(self, suffix, path='.'):\n zip_fd, zip_fn = tempfile.mkstemp(prefix='fuzzfetch-', suffix='.zip')\n os.close(zip_fd)\n try:\n _download_url(self.artifact_url(suffix), zip_fn)\n LOG.info('.. extracting')\n with zipfile.ZipFile(zip_fn) as zip_fp:\n for info in zip_fp.infolist():\n _extract_file(zip_fp, info, path)\n finally:\n os.unlink(zip_fn)", "docstring": "Download and extract a zip artifact\n\n @type suffix:\n @param suffix:\n\n @type path:\n @param path:" }, { "code": "def append(self, row_or_table):\n if not row_or_table:\n return\n if isinstance(row_or_table, Table):\n t = row_or_table\n columns = list(t.select(self.labels)._columns.values())\n n = t.num_rows\n else:\n if (len(list(row_or_table)) != self.num_columns):\n raise Exception('Row should have '+ str(self.num_columns) + \" columns\")\n columns, n = [[value] for value in row_or_table], 1\n for i, column in enumerate(self._columns):\n if self.num_rows:\n self._columns[column] = np.append(self[column], columns[i])\n else:\n self._columns[column] = np.array(columns[i])\n self._num_rows += n\n return self", "docstring": "Append a row or all rows of a table. An appended table must have all\n columns of self." }, { "code": "async def capability_check(self, optional=None, required=None):\n self._check_receive_loop()\n await self.query(\n \"version\", {\"optional\": optional or [], \"required\": required or []}\n )", "docstring": "Perform a server capability check." }, { "code": "def alpha(self, theta_x, theta_y, kwargs_lens, k=None):\n beta_x, beta_y = self.ray_shooting(theta_x, theta_y, kwargs_lens)\n alpha_x = theta_x - beta_x\n alpha_y = theta_y - beta_y\n return alpha_x, alpha_y", "docstring": "reduced deflection angle\n\n :param theta_x: angle in x-direction\n :param theta_y: angle in y-direction\n :param kwargs_lens: lens model kwargs\n :return:" }, { "code": "def normalize_text(self, text):\n if not self.editor.free_format:\n text = ' ' * 6 + text[6:]\n return text.upper()", "docstring": "Normalize text, when fixed format is ON, replace the first 6 chars by a space." }, { "code": "def reverse_file(infile, outfile):\n with open(infile, 'rb') as inf:\n with open(outfile, 'wb') as outf:\n reverse_fd(inf, outf)", "docstring": "Reverse the content of infile, write to outfile.\n Both infile and outfile are filenames or filepaths." }, { "code": "def get_session(self, account_id):\n if account_id not in self.account_sessions:\n if account_id not in self.config['accounts']:\n raise AccountNotFound(\"account:%s is unknown\" % account_id)\n self.account_sessions[account_id] = s = assumed_session(\n self.config['accounts'][account_id]['role'], \"Sphere11\")\n s._session.user_agent_name = \"Sphere11\"\n s._session.user_agent_version = \"0.07\"\n return self.account_sessions[account_id]", "docstring": "Get an active session in the target account." }, { "code": "def add_marker_to_qtl(qtl, map_list):\n closest = ''\n diff = None\n for marker in map_list:\n if qtl[1] == marker[1]:\n tmp_diff = float(qtl[2]) - float(marker[2])\n if diff is None or abs(diff) > abs(tmp_diff):\n diff = tmp_diff\n closest = marker\n if closest != '':\n closest = closest[0]\n return closest", "docstring": "Add the closest marker to the given QTL.\n\n :arg qtl: a row of the QTL list.\n :arg map_list: the genetic map containing the list of markers." }, { "code": "def readDivPressure(fileName):\n try:\n df = pandas.read_csv(fileName, sep=None, engine='python')\n pandasformat = True\n except ValueError:\n pandasformat = False\n df.columns = ['site', 'divPressureValue']\n scaleFactor = max(df[\"divPressureValue\"].abs())\n if scaleFactor > 0:\n df[\"divPressureValue\"] = [x / scaleFactor for x in df[\"divPressureValue\"]]\n assert len(df['site'].tolist()) == len(set(df['site'].tolist())),\"There is at least one non-unique site in {0}\".format(fileName)\n assert max(df[\"divPressureValue\"].abs()) <= 1, \"The scaling produced a diversifying pressure value with an absolute value greater than one.\"\n sites = df['site'].tolist()\n divPressure = {}\n for r in sites:\n divPressure[r] = df[df['site'] == r][\"divPressureValue\"].tolist()[0]\n return divPressure", "docstring": "Reads in diversifying pressures from some file.\n\n Scale diversifying pressure values so absolute value of the max value is 1,\n unless all values are zero.\n\n Args:\n `fileName` (string or readable file-like object)\n File holding diversifying pressure values. Can be\n comma-, space-, or tab-separated file. The first column\n is the site (consecutively numbered, sites starting\n with one) and the second column is the diversifying pressure values.\n\n Returns:\n `divPressure` (dict keyed by ints)\n `divPressure[r][v]` is the diversifying pressure value of site `r`." }, { "code": "def _mirror_groups_from_stormpath(self):\n APPLICATION = get_application()\n sp_groups = [g.name for g in APPLICATION.groups]\n missing_from_db, missing_from_sp = self._get_group_difference(sp_groups)\n if missing_from_db:\n groups_to_create = []\n for g_name in missing_from_db:\n groups_to_create.append(Group(name=g_name))\n Group.objects.bulk_create(groups_to_create)", "docstring": "Helper method for saving to the local db groups\n that are missing but are on Stormpath" }, { "code": "def _load_greedy(self, module_name, dependencies, recursive):\n found = module_name in self.modules\n allmodules = list(self._pathfiles.keys())\n i = 0\n while not found and i < len(allmodules):\n current = allmodules[i]\n if not current in self._modulefiles:\n self.parse(self._pathfiles[current], dependencies and recursive) \n found = module_name in self.modules\n i += 1", "docstring": "Keeps loading modules in the filepaths dictionary until all have\n been loaded or the module is found." }, { "code": "def _message_callback(self, msg):\n if msg.type == 'polytouch':\n button = button_from_press(msg.note)\n if button:\n self.on_button(button, msg.value != 0)\n elif msg.note == 127:\n self.on_fader_touch(msg.value != 0)\n elif msg.type == 'control_change' and msg.control == 0:\n self._msb = msg.value\n elif msg.type == 'control_change' and msg.control == 32:\n self._fader = (self._msb << 7 | msg.value) >> 4\n self.on_fader(self._fader)\n elif msg.type == 'pitchwheel':\n self.on_rotary(1 if msg.pitch < 0 else -1)\n else:\n print('Unhandled:', msg)", "docstring": "Callback function to handle incoming MIDI messages." }, { "code": "def derivatives_factory(cls, coef, domain, kind, **kwargs):\n basis_polynomial = cls._basis_polynomial_factory(kind)\n return basis_polynomial(coef, domain).deriv()", "docstring": "Given some coefficients, return a the derivative of a certain kind of\n orthogonal polynomial defined over a specific domain." }, { "code": "def merge_periods(data):\n newdata = sorted(data, key=lambda drange: drange[0])\n end = 0\n for period in newdata:\n if period[0] != end and period[0] != (end - 1):\n end = period[1]\n dat = newdata\n new_intervals = []\n cur_start = None\n cur_end = None\n for (dt_start, dt_end) in dat:\n if cur_end is None:\n cur_start = dt_start\n cur_end = dt_end\n continue\n else:\n if cur_end >= dt_start:\n cur_end = dt_end\n else:\n new_intervals.append((cur_start, cur_end))\n cur_start = dt_start\n cur_end = dt_end\n new_intervals.append((cur_start, cur_end))\n return new_intervals", "docstring": "Merge periods to have better continous periods.\n Like 350-450, 400-600 => 350-600\n\n :param data: list of periods\n :type data: list\n :return: better continous periods\n :rtype: list" }, { "code": "def create_header_from_telpars(telpars):\n pars = [val.strip() for val in (';').join(telpars).split(';')\n if val.strip() != '']\n with warnings.catch_warnings():\n warnings.simplefilter('ignore', fits.verify.VerifyWarning)\n hdr = fits.Header(map(parse_hstring, pars))\n return hdr", "docstring": "Create a list of fits header items from GTC telescope pars.\n\n The GTC telescope server gives a list of string describing\n FITS header items such as RA, DEC, etc.\n\n Arguments\n ---------\n telpars : list\n list returned by server call to getTelescopeParams" }, { "code": "def get_client_calls_for_app(source_code):\n parsed = parse_code(source_code)\n parsed.parsed_ast = AppViewTransformer().visit(parsed.parsed_ast)\n ast.fix_missing_locations(parsed.parsed_ast)\n t = SymbolTableTypeInfer(parsed)\n binder = t.bind_types()\n collector = APICallCollector(binder)\n api_calls = collector.collect_api_calls(parsed.parsed_ast)\n return api_calls", "docstring": "Return client calls for a chalice app.\n\n This is similar to ``get_client_calls`` except it will\n automatically traverse into chalice views with the assumption\n that they will be called." }, { "code": "def mag_yaw(RAW_IMU, inclination, declination):\n m = mag_rotation(RAW_IMU, inclination, declination)\n (r, p, y) = m.to_euler()\n y = degrees(y)\n if y < 0:\n y += 360\n return y", "docstring": "estimate yaw from mag" }, { "code": "def put_encryption_materials(self, cache_key, encryption_materials, plaintext_length, entry_hints=None):\n return CryptoMaterialsCacheEntry(cache_key=cache_key, value=encryption_materials)", "docstring": "Does not add encryption materials to the cache since there is no cache to which to add them.\n\n :param bytes cache_key: Identifier for entries in cache\n :param encryption_materials: Encryption materials to add to cache\n :type encryption_materials: aws_encryption_sdk.materials_managers.EncryptionMaterials\n :param int plaintext_length: Length of plaintext associated with this request to the cache\n :param entry_hints: Metadata to associate with entry (optional)\n :type entry_hints: aws_encryption_sdk.caches.CryptoCacheEntryHints\n :rtype: aws_encryption_sdk.caches.CryptoMaterialsCacheEntry" }, { "code": "def find_pore_to_pore_distance(network, pores1=None, pores2=None):\n r\n from scipy.spatial.distance import cdist\n p1 = sp.array(pores1, ndmin=1)\n p2 = sp.array(pores2, ndmin=1)\n coords = network['pore.coords']\n return cdist(coords[p1], coords[p2])", "docstring": "r'''\n Find the distance between all pores on set one to each pore in set 2\n\n Parameters\n ----------\n network : OpenPNM Network Object\n The network object containing the pore coordinates\n\n pores1 : array_like\n The pore indices of the first set\n\n pores2 : array_Like\n The pore indices of the second set. It's OK if these indices are\n partially or completely duplicating ``pores``.\n\n Returns\n -------\n A distance matrix with ``len(pores1)`` rows and ``len(pores2)`` columns.\n The distance between pore *i* in ``pores1`` and *j* in ``pores2`` is\n located at *(i, j)* and *(j, i)* in the distance matrix." }, { "code": "def _getModelData(self, modelData, parentItem=None):\n if parentItem is None:\n parentItem = self.rootItem\n for item in parentItem.getChildren():\n key = item.getItemData(0)\n if item.childCount():\n modelData[key] = odict()\n self._getModelData(modelData[key], item)\n else:\n if isinstance(item.getItemData(2), float):\n modelData[key] = [item.getItemData(1), item.getItemData(2)]\n else:\n modelData[key] = item.getItemData(1)", "docstring": "Return the data contained in the model." }, { "code": "def association(self, group_xid):\n association = {'groupXid': group_xid}\n self._indicator_data.setdefault('associatedGroups', []).append(association)", "docstring": "Add association using xid value.\n\n Args:\n group_xid (str): The external id of the Group to associate." }, { "code": "def camel_to_snake_case(string):\n s = _1.sub(r'\\1_\\2', string)\n return _2.sub(r'\\1_\\2', s).lower()", "docstring": "Converts 'string' presented in camel case to snake case.\n\n e.g.: CamelCase => snake_case" }, { "code": "def write(filename, groupname, items, times, features, properties=None,\n dformat='dense', chunk_size='auto', sparsity=0.1, mode='a'):\n sparsity = sparsity if dformat == 'sparse' else None\n data = Data(items, times, features, properties=properties,\n sparsity=sparsity, check=True)\n Writer(filename, chunk_size=chunk_size).write(data, groupname, append=True)", "docstring": "Write h5features data in a HDF5 file.\n\n This function is a wrapper to the Writer class. It has three purposes:\n\n * Check parameters for errors (see details below),\n * Create Items, Times and Features objects\n * Send them to the Writer.\n\n :param str filename: HDF5 file to be writted, potentially serving\n as a container for many small files. If the file does not\n exist, it is created. If the file is already a valid HDF5\n file, try to append the data in it.\n\n :param str groupname: Name of the group to write the data in, or\n to append the data to if the group already exists in the file.\n\n :param items: List of files from which the features where\n extracted. Items must not contain duplicates.\n :type items: list of str\n\n :param times: Time value for the features array. Elements of\n a 1D array are considered as the center of the time window\n associated with the features. A 2D array must have 2 columns\n corresponding to the begin and end timestamps of the features\n time window.\n :type times: list of 1D or 2D numpy arrays\n\n :param features: Features should have\n time along the lines and features along the columns\n (accomodating row-major storage in hdf5 files).\n :type features: list of 2D numpy arrays\n\n :param properties: Optional. Properties associated with each\n item. Properties describe the features associated with each\n item in a dictionnary. It can store parameters or fields\n recorded by the user.\n :type properties: list of dictionnaries\n\n :param str dformat: Optional. Which format to store the features\n into (sparse or dense). Default is dense.\n\n :param float chunk_size: Optional. In Mo, tuning parameter\n corresponding to the size of a chunk in the h5file. By default\n the chunk size is guessed automatically. Tis parameter is\n ignored if the file already exists.\n\n :param float sparsity: Optional. Tuning parameter corresponding to\n the expected proportion (in [0, 1]) of non-zeros elements on\n average in a single frame.\n\n :param char mode: Optional. The mode for overwriting an existing\n file, 'a' to append data to the file, 'w' to overwrite it\n\n :raise IOError: if the filename is not valid or parameters are\n inconsistent.\n\n :raise NotImplementedError: if dformat == 'sparse'" }, { "code": "def download_file(self, url, filename):\n self.print_message(\"Downloading to file '%s' from URL '%s'\" % (filename, url))\n try:\n db_file = urllib2.urlopen(url)\n with open(filename, 'wb') as output:\n output.write(db_file.read())\n db_file.close()\n except Exception as e:\n self.error(str(e))\n self.print_message(\"File downloaded\")", "docstring": "Download file from url to filename." }, { "code": "def save_hdf_metadata(filename, metadata, groupname=\"data\", mode=\"a\"):\n with _h5py.File(filename, mode) as f:\n for key, val in metadata.items():\n f[groupname].attrs[key] = val", "docstring": "Save a dictionary of metadata to a group's attrs." }, { "code": "def _compose(self, *args, **kwargs):\n name = kwargs.pop('name', None)\n if name:\n name = c_str(name)\n if len(args) != 0 and len(kwargs) != 0:\n raise TypeError('compose only accept input Symbols \\\n either as positional or keyword arguments, not both')\n for arg in args:\n if not isinstance(arg, SymbolBase):\n raise TypeError('Compose expect `Symbol` as arguments')\n for val in kwargs.values():\n if not isinstance(val, SymbolBase):\n raise TypeError('Compose expect `Symbol` as arguments')\n num_args = len(args) + len(kwargs)\n if len(kwargs) != 0:\n keys = c_str_array(kwargs.keys())\n args = c_handle_array(kwargs.values())\n else:\n keys = None\n args = c_handle_array(kwargs.values())\n check_call(_LIB.NNSymbolCompose(\n self.handle, name, num_args, keys, args))", "docstring": "Compose symbol on inputs.\n\n This call mutates the current symbol.\n\n Parameters\n ----------\n args:\n provide positional arguments\n\n kwargs:\n provide keyword arguments\n\n Returns\n -------\n the resulting symbol" }, { "code": "def create(*context, **kwargs):\n items = context\n context = ContextStack()\n for item in items:\n if item is None:\n continue\n if isinstance(item, ContextStack):\n context._stack.extend(item._stack)\n else:\n context.push(item)\n if kwargs:\n context.push(kwargs)\n return context", "docstring": "Build a ContextStack instance from a sequence of context-like items.\n\n This factory-style method is more general than the ContextStack class's\n constructor in that, unlike the constructor, the argument list\n can itself contain ContextStack instances.\n\n Here is an example illustrating various aspects of this method:\n\n >>> obj1 = {'animal': 'cat', 'vegetable': 'carrot', 'mineral': 'copper'}\n >>> obj2 = ContextStack({'vegetable': 'spinach', 'mineral': 'silver'})\n >>>\n >>> context = ContextStack.create(obj1, None, obj2, mineral='gold')\n >>>\n >>> context.get('animal')\n 'cat'\n >>> context.get('vegetable')\n 'spinach'\n >>> context.get('mineral')\n 'gold'\n\n Arguments:\n\n *context: zero or more dictionaries, ContextStack instances, or objects\n with which to populate the initial context stack. None\n arguments will be skipped. Items in the *context list are\n added to the stack in order so that later items in the argument\n list take precedence over earlier items. This behavior is the\n same as the constructor's.\n\n **kwargs: additional key-value data to add to the context stack.\n As these arguments appear after all items in the *context list,\n in the case of key conflicts these values take precedence over\n all items in the *context list. This behavior is the same as\n the constructor's." }, { "code": "def ids_sharing_same_pgn(id_x, pgn_x, id_y, pgn_y):\n for id_a, pgn_a in zip(id_x, pgn_x):\n for id_b, pgn_b in zip(id_y, pgn_y):\n if pgn_a == pgn_b:\n yield (id_a, id_b)", "docstring": "Yield arbitration ids which has the same pgn." }, { "code": "def get_connection(db_type, db_pth, user=None, password=None, name=None):\n if db_type == 'sqlite':\n print(db_pth)\n conn = sqlite3.connect(db_pth)\n elif db_type == 'mysql':\n import mysql.connector\n conn = mysql.connector.connect(user=user, password=password, database=name)\n elif db_type == 'django_mysql':\n from django.db import connection as conn\n else:\n print('unsupported database type: {}, choices are \"sqlite\", \"mysql\" or \"django_mysql\"'.format(db_type))\n return conn", "docstring": "Get a connection to a SQL database. Can be used for SQLite, MySQL or Django MySQL database\n\n Example:\n >>> from msp2db.db import get_connection\n >>> conn = get_connection('sqlite', 'library.db')\n\n If using \"mysql\" mysql.connector needs to be installed.\n\n If using \"django_mysql\" Django needs to be installed.\n\n Args:\n db_type (str): Type of database can either be \"sqlite\", \"mysql\" or \"django_mysql\"\n\n\n Returns:\n sql connection object" }, { "code": "def create_argparser(self):\n if self.desc:\n if self.title:\n fulldesc = '%s\\n\\n%s' % (self.title, self.desc)\n else:\n fulldesc = self.desc\n else:\n fulldesc = self.title\n return self.ArgumentParser(command=self, prog=self.name,\n description=fulldesc)", "docstring": "Factory for arg parser. Can be overridden as long as it returns\n an ArgParser compatible instance." }, { "code": "def shellinput(initialtext='>> ', splitpart=' '):\n shelluserinput = input(str(initialtext))\n return shelluserinput if splitpart in (\n '', None) else shelluserinput.split(splitpart)", "docstring": "Give the user a shell-like interface to enter commands which\n are returned as a multi-part list containing the command\n and each of the arguments.\n\n :type initialtext: string\n :param initialtext: Set the text to be displayed as the prompt.\n\n :type splitpart: string\n :param splitpart: The character to split when generating the list item.\n\n :return: A string of the user's input or a list of the user's input split by the split character.\n :rtype: string or list" }, { "code": "def parse_value_instancewithpath(self, tup_tree):\n self.check_node(tup_tree, 'VALUE.INSTANCEWITHPATH')\n k = kids(tup_tree)\n if len(k) != 2:\n raise CIMXMLParseError(\n _format(\"Element {0!A} has invalid number of child elements \"\n \"{1!A} (expecting two child elements \"\n \"(INSTANCEPATH, INSTANCE))\",\n name(tup_tree), k),\n conn_id=self.conn_id)\n inst_path = self.parse_instancepath(k[0])\n instance = self.parse_instance(k[1])\n instance.path = inst_path\n return instance", "docstring": "The VALUE.INSTANCEWITHPATH is used to define a value that comprises\n a single CIMInstance with additional information that defines the\n absolute path to that object.\n\n ::\n\n " }, { "code": "def currency_to_protocol(amount):\n if type(amount) in [float, int]:\n amount = \"%.8f\" % amount\n return int(amount.replace(\".\", ''))", "docstring": "Convert a string of 'currency units' to 'protocol units'. For instance\n converts 19.1 bitcoin to 1910000000 satoshis.\n\n Input is a float, output is an integer that is 1e8 times larger.\n\n It is hard to do this conversion because multiplying\n floats causes rounding nubers which will mess up the transactions creation\n process.\n\n examples:\n\n 19.1 -> 1910000000\n 0.001 -> 100000" }, { "code": "def ensure_float(arr):\n if issubclass(arr.dtype.type, (np.integer, np.bool_)):\n arr = arr.astype(float)\n return arr", "docstring": "Ensure that an array object has a float dtype if possible.\n\n Parameters\n ----------\n arr : array-like\n The array whose data type we want to enforce as float.\n\n Returns\n -------\n float_arr : The original array cast to the float dtype if\n possible. Otherwise, the original array is returned." }, { "code": "def listSites(self, block_name=\"\", site_name=\"\"):\n try:\n conn = self.dbi.connection()\n if block_name:\n result = self.blksitelist.execute(conn, block_name)\n else:\n result = self.sitelist.execute(conn, site_name)\n return result\n finally:\n if conn:\n conn.close()", "docstring": "Returns sites." }, { "code": "def put_log_events(awsclient, log_group_name, log_stream_name, log_events,\n sequence_token=None):\n client_logs = awsclient.get_client('logs')\n request = {\n 'logGroupName': log_group_name,\n 'logStreamName': log_stream_name,\n 'logEvents': log_events\n }\n if sequence_token:\n request['sequenceToken'] = sequence_token\n response = client_logs.put_log_events(**request)\n if 'rejectedLogEventsInfo' in response:\n log.warn(response['rejectedLogEventsInfo'])\n if 'nextSequenceToken' in response:\n return response['nextSequenceToken']", "docstring": "Put log events for the specified log group and stream.\n\n :param log_group_name: log group name\n :param log_stream_name: log stream name\n :param log_events: [{'timestamp': 123, 'message': 'string'}, ...]\n :param sequence_token: the sequence token\n :return: next_token" }, { "code": "def process_batches(self):\n for key, batch in iteritems(self._batches):\n self._current_tups = batch\n self._current_key = key\n self.process_batch(key, batch)\n if self.auto_ack:\n for tup in batch:\n self.ack(tup)\n self._current_key = None\n self._batches[key] = []\n self._batches = defaultdict(list)", "docstring": "Iterate through all batches, call process_batch on them, and ack.\n\n Separated out for the rare instances when we want to subclass\n BatchingBolt and customize what mechanism causes batches to be\n processed." }, { "code": "def get_label_names(ctx):\n labels = [\n label\n for label in ctx.__dict__\n if not label.startswith(\"_\")\n and label\n not in [\n \"children\",\n \"exception\",\n \"invokingState\",\n \"parentCtx\",\n \"parser\",\n \"start\",\n \"stop\",\n ]\n ]\n return labels", "docstring": "Get labels defined in an ANTLR context for a parser rule" }, { "code": "def StaticAdd(cls, queue_urn, rdf_value, mutation_pool=None):\n if not isinstance(rdf_value, cls.rdf_type):\n raise ValueError(\"This collection only accepts values of type %s.\" %\n cls.rdf_type.__name__)\n if mutation_pool is None:\n raise ValueError(\"Mutation pool can't be none.\")\n timestamp = rdfvalue.RDFDatetime.Now().AsMicrosecondsSinceEpoch()\n if not isinstance(queue_urn, rdfvalue.RDFURN):\n queue_urn = rdfvalue.RDFURN(queue_urn)\n mutation_pool.QueueAddItem(queue_urn, rdf_value, timestamp)", "docstring": "Adds an rdf value the queue.\n\n Adds an rdf value to a queue. Does not require that the queue be locked, or\n even open. NOTE: The caller is responsible for ensuring that the queue\n exists and is of the correct type.\n\n Args:\n queue_urn: The urn of the queue to add to.\n\n rdf_value: The rdf value to add to the queue.\n\n mutation_pool: A MutationPool object to write to.\n\n Raises:\n ValueError: rdf_value has unexpected type." }, { "code": "def ApprovalUrnBuilder(subject, user, approval_id):\n return aff4.ROOT_URN.Add(\"ACL\").Add(subject).Add(user).Add(approval_id)", "docstring": "Encode an approval URN." }, { "code": "async def exist(self, key, param=None):\n identity = self._gen_identity(key, param)\n return await self.client.exists(identity)", "docstring": "see if specific identity exists" }, { "code": "def get(self, sid):\n return QueueContext(self._version, account_sid=self._solution['account_sid'], sid=sid, )", "docstring": "Constructs a QueueContext\n\n :param sid: The unique string that identifies this resource\n\n :returns: twilio.rest.api.v2010.account.queue.QueueContext\n :rtype: twilio.rest.api.v2010.account.queue.QueueContext" }, { "code": "def createPenWidthCti(nodeName, defaultData=1.0, zeroValueText=None):\n return FloatCti(nodeName, defaultData=defaultData, specialValueText=zeroValueText,\n minValue=0.1 if zeroValueText is None else 0.0,\n maxValue=100, stepSize=0.1, decimals=1)", "docstring": "Creates a FloatCti with defaults for configuring a QPen width.\n\n If specialValueZero is set, this string will be displayed when 0.0 is selected.\n If specialValueZero is None, the minValue will be 0.1" }, { "code": "def make_relative(base, obj):\n uri = obj.get(\"location\", obj.get(\"path\"))\n if \":\" in uri.split(\"/\")[0] and not uri.startswith(\"file://\"):\n pass\n else:\n if uri.startswith(\"file://\"):\n uri = uri_file_path(uri)\n obj[\"location\"] = os.path.relpath(uri, base)", "docstring": "Relativize the location URI of a File or Directory object." }, { "code": "def prune_feed_map(meta_graph, feed_map):\n node_names = [x.name + \":0\" for x in meta_graph.graph_def.node]\n keys_to_delete = []\n for k, _ in feed_map.items():\n if k not in node_names:\n keys_to_delete.append(k)\n for k in keys_to_delete:\n del feed_map[k]", "docstring": "Function to prune the feedmap of nodes which no longer exist." }, { "code": "def open_xmldoc(fobj, **kwargs):\n from ligo.lw.ligolw import (Document, LIGOLWContentHandler)\n from ligo.lw.lsctables import use_in\n from ligo.lw.utils import (load_filename, load_fileobj)\n use_in(kwargs.setdefault('contenthandler', LIGOLWContentHandler))\n try:\n if isinstance(fobj, string_types):\n return load_filename(fobj, **kwargs)\n if isinstance(fobj, FILE_LIKE):\n return load_fileobj(fobj, **kwargs)[0]\n except (OSError, IOError):\n return Document()\n except LigolwElementError as exc:\n if LIGO_LW_COMPAT_ERROR.search(str(exc)):\n try:\n return open_xmldoc(fobj, ilwdchar_compat=True, **kwargs)\n except Exception:\n pass\n raise", "docstring": "Try and open an existing LIGO_LW-format file, or create a new Document\n\n Parameters\n ----------\n fobj : `str`, `file`\n file path or open file object to read\n\n **kwargs\n other keyword arguments to pass to\n :func:`~ligo.lw.utils.load_filename`, or\n :func:`~ligo.lw.utils.load_fileobj` as appropriate\n\n Returns\n --------\n xmldoc : :class:`~ligo.lw.ligolw.Document`\n either the `Document` as parsed from an existing file, or a new, empty\n `Document`" }, { "code": "def set_interface(interface, name=''):\n global interfaces\n if not interface: raise ValueError('interface is empty')\n if name in interfaces:\n interfaces[name].close()\n interfaces[name] = interface", "docstring": "don't want to bother with a dsn? Use this method to make an interface available" }, { "code": "def use_mutation(module_path, operator, occurrence):\n original_code, mutated_code = apply_mutation(module_path, operator,\n occurrence)\n try:\n yield original_code, mutated_code\n finally:\n with module_path.open(mode='wt', encoding='utf-8') as handle:\n handle.write(original_code)\n handle.flush()", "docstring": "A context manager that applies a mutation for the duration of a with-block.\n\n This applies a mutation to a file on disk, and after the with-block it put the unmutated code\n back in place.\n\n Args:\n module_path: The path to the module to mutate.\n operator: The `Operator` instance to use.\n occurrence: The occurrence of the operator to apply.\n\n Yields: A `(unmutated-code, mutated-code)` tuple to the with-block. If there was\n no mutation performed, the `mutated-code` is `None`." }, { "code": "def getDebt(self):\n debt = float(self['principalBalance']) + float(self['interestBalance'])\n debt += float(self['feesBalance']) + float(self['penaltyBalance'])\n return debt", "docstring": "Sums up all the balances of the account and returns them." }, { "code": "def overlap(ival0, ival1):\n min0, max0 = ival0\n min1, max1 = ival1\n return max(0, min(max0, max1) - max(min0, min1)) > 0", "docstring": "Determine if two interval tuples have overlap.\n\n Args:\n iv0 ((int,int)): An interval tuple\n iv1 ((int,int)); An interval tuple\n\n Returns:\n (bool): True if the intervals overlap, otherwise False" }, { "code": "async def publish(self, message):\r\n try:\r\n self.write('data: {}\\n\\n'.format(message))\r\n await self.flush()\r\n except StreamClosedError:\r\n self.finished = True", "docstring": "Pushes data to a listener." }, { "code": "def removeClassBreak(self, label):\n for v in self._classBreakInfos:\n if v['label'] == label:\n self._classBreakInfos.remove(v)\n return True\n del v\n return False", "docstring": "removes a classification break value to the renderer" }, { "code": "def load_z_meso(self,z_meso_path):\n self.z_meso = []\n z_meso_file_path = os.path.join(z_meso_path, self.Z_MESO_FILE_NAME)\n if not os.path.exists(z_meso_file_path):\n raise Exception(\"z_meso.txt file: '{}' does not exist.\".format(uwg_param_file))\n f = open(z_meso_file_path,'r')\n for txtline in f:\n z_ = float(\"\".join(txtline.split()))\n self.z_meso.append(z_)\n f.close()", "docstring": "Open the z_meso.txt file and return heights as list" }, { "code": "def log_url (self, url_data):\n self.check_active_loggers()\n do_print = self.do_print(url_data)\n for log in self.loggers:\n log.log_filter_url(url_data, do_print)", "docstring": "Send new url to all configured loggers." }, { "code": "def phase_by(val: Any, phase_turns: float, qubit_index: int,\n default: TDefault = RaiseTypeErrorIfNotProvided):\n getter = getattr(val, '_phase_by_', None)\n result = NotImplemented if getter is None else getter(\n phase_turns, qubit_index)\n if result is not NotImplemented:\n return result\n if default is not RaiseTypeErrorIfNotProvided:\n return default\n if getter is None:\n raise TypeError(\"object of type '{}' \"\n \"has no _phase_by_ method.\".format(type(val)))\n raise TypeError(\"object of type '{}' does have a _phase_by_ method, \"\n \"but it returned NotImplemented.\".format(type(val)))", "docstring": "Returns a phased version of the effect.\n\n For example, an X gate phased by 90 degrees would be a Y gate.\n This works by calling `val`'s _phase_by_ method and returning\n the result.\n\n Args:\n val: The value to describe with a unitary matrix.\n phase_turns: The amount to phase the gate, in fractions of a whole\n turn. Divide by 2pi to get radians.\n qubit_index: The index of the target qubit the phasing applies to. For\n operations this is the index of the qubit within the operation's\n qubit list. For gates it's the index of the qubit within the tuple\n of qubits taken by the gate's `on` method.\n default: The default value to return if `val` can't be phased. If not\n specified, an error is raised when `val` can't be phased.\n\n Returns:\n If `val` has a _phase_by_ method and its result is not NotImplemented,\n that result is returned. Otherwise, the function will return the\n default value provided or raise a TypeError if none was provided.\n\n Raises:\n TypeError:\n `val` doesn't have a _phase_by_ method (or that method returned\n NotImplemented) and no `default` was specified." }, { "code": "def contains_is_html(cls, data):\n for key, val in data.items():\n if isinstance(key, str) and key.endswith(\"IsHTML\"):\n return True\n if isinstance(val, (OrderedDict, dict)) and cls.contains_is_html(val):\n return True\n return False", "docstring": "Detect if the problem has at least one \"xyzIsHTML\" key" }, { "code": "def pause(self, queue_name, kw_in=None, kw_out=None, kw_all=None,\n kw_none=None, kw_state=None, kw_bcast=None):\n command = [\"PAUSE\", queue_name]\n if kw_in:\n command += [\"in\"]\n if kw_out:\n command += [\"out\"]\n if kw_all:\n command += [\"all\"]\n if kw_none:\n command += [\"none\"]\n if kw_state:\n command += [\"state\"]\n if kw_bcast:\n command += [\"bcast\"]\n return self.execute_command(*command)", "docstring": "Pause a queue.\n\n Unfortunately, the PAUSE keywords are mostly reserved words in Python,\n so I've been a little creative in the function variable names. Open\n to suggestions to change it (canardleteer)\n\n :param queue_name: The job queue we are modifying.\n :param kw_in: pause the queue in input.\n :param kw_out: pause the queue in output.\n :param kw_all: pause the queue in input and output (same as specifying\n both the in and out options).\n :param kw_none: clear the paused state in input and output.\n :param kw_state: just report the current queue state.\n :param kw_bcast: send a PAUSE command to all the reachable nodes of\n the cluster to set the same queue in the other nodes\n to the same state." }, { "code": "def bogoliubov_trans(p, q, theta):\n r\n expo = -4 * theta / np.pi\n yield cirq.X(p)\n yield cirq.S(p)\n yield cirq.ISWAP(p, q)**expo\n yield cirq.S(p) ** 1.5\n yield cirq.X(p)", "docstring": "r\"\"\"The 2-mode Bogoliubov transformation is mapped to two-qubit operations.\n We use the identity X S^\\dag X S X = Y X S^\\dag Y S X = X to transform\n the Hamiltonian XY+YX to XX+YY type. The time evolution of the XX + YY\n Hamiltonian can be expressed as a power of the iSWAP gate.\n\n Args:\n p: the first qubit\n q: the second qubit\n theta: The rotational angle that specifies the Bogoliubov\n transformation, which is a function of the kinetic energy and\n the superconducting gap." }, { "code": "def decodeRPCErrorMsg(e):\n found = re.search(\n (\n \"(10 assert_exception: Assert Exception\\n|\"\n \"3030000 tx_missing_posting_auth)\"\n \".*: (.*)\\n\"\n ),\n str(e),\n flags=re.M,\n )\n if found:\n return found.group(2).strip()\n else:\n return str(e)", "docstring": "Helper function to decode the raised Exception and give it a\n python Exception class" }, { "code": "def start(self):\n if self.run is True:\n self.job = multiprocessing.Process(target=self.indicator)\n self.job.start()\n return self.job", "docstring": "Indicate that we are performing work in a thread.\n\n :returns: multiprocessing job object" }, { "code": "def simulate(radius=5e-6, sphere_index=1.339, medium_index=1.333,\n wavelength=550e-9, grid_size=(80, 80), model=\"projection\",\n pixel_size=None, center=None):\n if isinstance(grid_size, numbers.Integral):\n grid_size = (grid_size, grid_size)\n if pixel_size is None:\n rl = radius / wavelength\n if rl < 5:\n fact = 4\n elif rl >= 5 and rl <= 10:\n fact = 4 - (rl - 5) / 5\n else:\n fact = 3\n pixel_size = fact * radius / np.min(grid_size)\n if center is None:\n center = (np.array(grid_size) - 1) / 2\n model = model_dict[model]\n qpi = model(radius=radius,\n sphere_index=sphere_index,\n medium_index=medium_index,\n wavelength=wavelength,\n pixel_size=pixel_size,\n grid_size=grid_size,\n center=center)\n return qpi", "docstring": "Simulate scattering at a sphere\n\n Parameters\n ----------\n radius: float\n Radius of the sphere [m]\n sphere_index: float\n Refractive index of the object\n medium_index: float\n Refractive index of the surrounding medium\n wavelength: float\n Vacuum wavelength of the imaging light [m]\n grid_size: tuple of ints or int\n Resulting image size in x and y [px]\n model: str\n Sphere model to use (see :const:`available`)\n pixel_size: float or None\n Pixel size [m]; if set to `None` the pixel size is\n chosen such that the radius fits at least three to\n four times into the grid.\n center: tuple of floats or None\n Center position in image coordinates [px]; if set to\n None, the center of the image (grid_size - 1)/2 is\n used.\n\n Returns\n -------\n qpi: qpimage.QPImage\n Quantitative phase data set" }, { "code": "def assert_estimator_equal(left, right, exclude=None, **kwargs):\n left_attrs = [x for x in dir(left) if x.endswith(\"_\") and not x.startswith(\"_\")]\n right_attrs = [x for x in dir(right) if x.endswith(\"_\") and not x.startswith(\"_\")]\n if exclude is None:\n exclude = set()\n elif isinstance(exclude, str):\n exclude = {exclude}\n else:\n exclude = set(exclude)\n assert (set(left_attrs) - exclude) == set(right_attrs) - exclude\n for attr in set(left_attrs) - exclude:\n l = getattr(left, attr)\n r = getattr(right, attr)\n _assert_eq(l, r, **kwargs)", "docstring": "Check that two Estimators are equal\n\n Parameters\n ----------\n left, right : Estimators\n exclude : str or sequence of str\n attributes to skip in the check\n kwargs : dict\n Passed through to the dask `assert_eq` method." }, { "code": "def state_cpfs(self) -> List[CPF]:\n _, cpfs = self.cpfs\n state_cpfs = []\n for cpf in cpfs:\n name = utils.rename_next_state_fluent(cpf.name)\n if name in self.state_fluents:\n state_cpfs.append(cpf)\n state_cpfs = sorted(state_cpfs, key=lambda cpf: cpf.name)\n return state_cpfs", "docstring": "Returns list of state-fluent CPFs." }, { "code": "def get_rng(obj=None):\n seed = (id(obj) + os.getpid() +\n int(datetime.now().strftime(\"%Y%m%d%H%M%S%f\"))) % 4294967295\n if _RNG_SEED is not None:\n seed = _RNG_SEED\n return np.random.RandomState(seed)", "docstring": "Get a good RNG seeded with time, pid and the object.\n\n Args:\n obj: some object to use to generate random seed.\n Returns:\n np.random.RandomState: the RNG." }, { "code": "def get_cas_client(self, request, provider, renew=False):\n service_url = utils.get_current_url(request, {\"ticket\", \"provider\"})\n self.service_url = service_url\n return CASFederateValidateUser(provider, service_url, renew=renew)", "docstring": "return a CAS client object matching provider\n\n :param django.http.HttpRequest request: The current request object\n :param cas_server.models.FederatedIendityProvider provider: the user identity provider\n :return: The user CAS client object\n :rtype: :class:`federate.CASFederateValidateUser\n `" }, { "code": "def offset(self, offset):\n self.log(u\"Applying offset to all fragments...\")\n self.log([u\" Offset %.3f\", offset])\n for fragment in self.fragments:\n fragment.interval.offset(\n offset=offset,\n allow_negative=False,\n min_begin_value=self.begin,\n max_end_value=self.end\n )\n self.log(u\"Applying offset to all fragments... done\")", "docstring": "Move all the intervals in the list by the given ``offset``.\n\n :param offset: the shift to be applied\n :type offset: :class:`~aeneas.exacttiming.TimeValue`\n :raises TypeError: if ``offset`` is not an instance of ``TimeValue``" }, { "code": "def query_source(self, source):\n return self._get_repo_filter(Layer.objects).filter(url=source)", "docstring": "Query by source" }, { "code": "def on_before_transform_template(self, template_dict):\n template = SamTemplate(template_dict)\n self.existing_implicit_api_resource = copy.deepcopy(template.get(self.implicit_api_logical_id))\n template.set(self.implicit_api_logical_id, ImplicitApiResource().to_dict())\n errors = []\n for logicalId, function in template.iterate(SamResourceType.Function.value):\n api_events = self._get_api_events(function)\n condition = function.condition\n if len(api_events) == 0:\n continue\n try:\n self._process_api_events(function, api_events, template, condition)\n except InvalidEventException as ex:\n errors.append(InvalidResourceException(logicalId, ex.message))\n self._maybe_add_condition_to_implicit_api(template_dict)\n self._maybe_add_conditions_to_implicit_api_paths(template)\n self._maybe_remove_implicit_api(template)\n if len(errors) > 0:\n raise InvalidDocumentException(errors)", "docstring": "Hook method that gets called before the SAM template is processed.\n The template has pass the validation and is guaranteed to contain a non-empty \"Resources\" section.\n\n :param dict template_dict: Dictionary of the SAM template\n :return: Nothing" }, { "code": "def app_start(name, profile, **kwargs):\n ctx = Context(**kwargs)\n ctx.execute_action('app:start', **{\n 'node': ctx.repo.create_secure_service('node'),\n 'name': name,\n 'profile': profile\n })", "docstring": "Start an application with specified profile.\n\n Does nothing if application is already running." }, { "code": "def list_supported_categories():\n categories = get_supported_categories(api)\n category_names = [category.name for category in categories]\n print (\"Supported account categories by name: {0}\".format(\n COMMA_WITH_SPACE.join(map(str, category_names))))", "docstring": "Prints a list of supported external account category names.\n For example, \"AWS\" is a supported external account category name." }, { "code": "def remove_suffix(text, suffix):\n\trest, suffix, null = text.partition(suffix)\n\treturn rest", "docstring": "Remove the suffix from the text if it exists.\n\n\t>>> remove_suffix('name.git', '.git')\n\t'name'\n\n\t>>> remove_suffix('something special', 'sample')\n\t'something special'" }, { "code": "def update(self, resource, timeout=-1):\n return self._client.update(resource, timeout=timeout, default_values=self.DEFAULT_VALUES, uri=self.URI)", "docstring": "Updates a User.\n\n Args:\n resource (dict): Object to update.\n timeout:\n Timeout in seconds. Wait for task completion by default. The timeout does not abort the operation\n in OneView, just stop waiting for its completion.\n\n Returns:\n dict: Updated resource." }, { "code": "def search(self, **kwargs):\n return super(ApiV4As, self).get(self.prepare_url(\n 'api/v4/as/', kwargs))", "docstring": "Method to search asns based on extends search.\n\n :param search: Dict containing QuerySets to find asns.\n :param include: Array containing fields to include on response.\n :param exclude: Array containing fields to exclude on response.\n :param fields: Array containing fields to override default fields.\n :param kind: Determine if result will be detailed ('detail') or basic ('basic').\n :return: Dict containing asns" }, { "code": "def download_log(currentfile=None):\n if currentfile == None:\n return\n if not currentfile.endswith(\".err.log\"):\n currentfile=currentfile + \".err.log\"\n list = get_base_ev3dev_cmd() + ['download','--force']\n list.append(currentfile)\n env = os.environ.copy()\n env[\"PYTHONUSERBASE\"] = THONNY_USER_BASE\n proc = subprocess.Popen(list, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,\n universal_newlines=True, env=env)\n dlg = MySubprocessDialog(get_workbench(), proc, \"Downloading log of program from EV3\", autoclose=True)\n dlg.wait_window()\n if dlg.returncode == 0:\n from pathlib import Path\n home = str(Path.home())\n open_file(currentfile,home,True)", "docstring": "downloads log of given .py file from EV3." }, { "code": "def save_graph(cn_topo, filename, showintfs=False, showaddrs=False):\n __do_draw(cn_topo, showintfs=showintfs, showaddrs=showaddrs)\n pyp.savefig(filename)", "docstring": "Save the topology to an image file" }, { "code": "def format_content_type_object(repo, content_type, uuid):\n try:\n storage_manager = StorageManager(repo)\n model_class = load_model_class(repo, content_type)\n return dict(storage_manager.get(model_class, uuid))\n except GitCommandError:\n raise NotFound('Object does not exist.')", "docstring": "Return a content object from a repository for a given content_type\n and uuid\n\n :param Repo repo:\n The git repository.\n :param str content_type:\n The content type to list\n :returns: dict" }, { "code": "def enable(self, key_id, **kwargs):\n path = '%s/%s/enable' % (self.path, key_id)\n self.gitlab.http_post(path, **kwargs)", "docstring": "Enable a deploy key for a project.\n\n Args:\n key_id (int): The ID of the key to enable\n **kwargs: Extra options to send to the server (e.g. sudo)\n\n Raises:\n GitlabAuthenticationError: If authentication is not correct\n GitlabProjectDeployKeyError: If the key could not be enabled" }, { "code": "def change_name(self, username):\r\n self.release_name()\r\n try:\r\n self.server.register_name(username)\r\n except UsernameInUseException:\r\n logging.log(', '.join(self.server.registered_names))\r\n self.server.register_name(self.name)\r\n raise\r\n self.name = username", "docstring": "changes the username to given username, throws exception if username used" }, { "code": "def task2ics():\n from argparse import ArgumentParser, FileType\n from sys import stdout\n parser = ArgumentParser(description='Converter from Taskwarrior to iCalendar syntax.')\n parser.add_argument('indir', nargs='?', help='Input Taskwarrior directory (default to ~/.task)', default=expanduser('~/.task'))\n parser.add_argument('outfile', nargs='?', type=FileType('w'), default=stdout,\n help='Output iCalendar file (default: stdout)')\n args = parser.parse_args()\n task = IcsTask(args.indir)\n args.outfile.write(task.to_vobject().serialize())", "docstring": "Command line tool to convert from Taskwarrior to iCalendar" }, { "code": "def precompile_python_code(context: Context):\n from compileall import compile_dir\n kwargs = {}\n if context.verbosity < 2:\n kwargs['quiet'] = True\n compile_dir(context.app.django_app_name, **kwargs)", "docstring": "Pre-compiles python modules" }, { "code": "def layerize(begin_update=None, predict=None, *args, **kwargs):\n if begin_update is not None:\n return FunctionLayer(begin_update, predict=predict, *args, **kwargs)\n def wrapper(begin_update):\n return FunctionLayer(begin_update, *args, **kwargs)\n return wrapper", "docstring": "Wrap a function into a layer" }, { "code": "def set_as_error(self, color=Qt.red):\n self.format.setUnderlineStyle(\n QTextCharFormat.WaveUnderline)\n self.format.setUnderlineColor(color)", "docstring": "Highlights text as a syntax error.\n\n :param color: Underline color\n :type color: QtGui.QColor" }, { "code": "def _parse(cls, data, key=None):\n parse = cls.parse if cls.parse is not None else cls.get_endpoint()\n if callable(parse):\n data = parse(data)\n elif isinstance(parse, str):\n data = data[key]\n else:\n raise Exception('\"parse\" should be a callable or string got, {0}'\n .format(parse))\n return data", "docstring": "Parse a set of data to extract entity-only data.\n\n Use classmethod `parse` if available, otherwise use the `endpoint`\n class variable to extract data from a data blob." }, { "code": "def set_category(self, category):\n if isinstance(category, Category):\n name = category.name\n else:\n name = category\n self.find(\"category\").text = name", "docstring": "Set package category\n\n Args:\n category: String of an existing category's name, or a\n Category object." }, { "code": "def capture(returns, factor_returns, period=DAILY):\n return (annual_return(returns, period=period) /\n annual_return(factor_returns, period=period))", "docstring": "Compute capture ratio.\n\n Parameters\n ----------\n returns : pd.Series or np.ndarray\n Returns of the strategy, noncumulative.\n - See full explanation in :func:`~empyrical.stats.cum_returns`.\n factor_returns : pd.Series or np.ndarray\n Noncumulative returns of the factor to which beta is\n computed. Usually a benchmark such as the market.\n - This is in the same style as returns.\n period : str, optional\n Defines the periodicity of the 'returns' data for purposes of\n annualizing. Value ignored if `annualization` parameter is specified.\n Defaults are::\n\n 'monthly':12\n 'weekly': 52\n 'daily': 252\n\n Returns\n -------\n capture_ratio : float\n\n Note\n ----\n See http://www.investopedia.com/terms/u/up-market-capture-ratio.asp for\n details." }, { "code": "def load_extra_data(cls, data):\n try:\n cls._extra_config.update(json.loads(data))\n except ValueError as exception:\n sys.stderr.write('Could convert to JSON. {0:s}'.format(exception))\n exit(-1)", "docstring": "Loads extra JSON configuration parameters from a data buffer.\n\n The data buffer must represent a JSON object.\n\n Args:\n data: str, the buffer to load the JSON data from." }, { "code": "def _ensure_slack(self, connector: Any, retries: int,\n backoff: Callable[[int], float]) -> None:\n connector = self._env_var if connector is None else connector\n slack: SlackClient = _create_slack(connector)\n self._slack = _SlackClientWrapper(\n slack=slack,\n retries=retries,\n backoff=backoff\n )", "docstring": "Ensure we have a SlackClient." }, { "code": "def twofilter_smoothing(self, t, info, phi, loggamma, linear_cost=False,\n return_ess=False, modif_forward=None,\n modif_info=None):\n ti = self.T - 2 - t\n if t < 0 or t >= self.T - 1:\n raise ValueError(\n 'two-filter smoothing: t must be in range 0,...,T-2')\n lwinfo = info.hist.wgt[ti].lw - loggamma(info.hist.X[ti])\n if linear_cost:\n return self._twofilter_smoothing_ON(t, ti, info, phi, lwinfo,\n return_ess,\n modif_forward, modif_info)\n else:\n return self._twofilter_smoothing_ON2(t, ti, info, phi, lwinfo)", "docstring": "Two-filter smoothing.\n\n Parameters\n ----------\n t: time, in range 0 <= t < T-1\n info: SMC object \n the information filter\n phi: function\n test function, a function of (X_t,X_{t+1})\n loggamma: function\n a function of (X_{t+1})\n linear_cost: bool\n if True, use the O(N) variant (basic version is O(N^2))\n\n Returns\n -------\n Two-filter estimate of the smoothing expectation of phi(X_t,x_{t+1})" }, { "code": "def _send(self, email_message):\n pre_send.send(self.__class__, message=email_message)\n if not email_message.recipients():\n return False\n from_email = sanitize_address(email_message.from_email,\n email_message.encoding)\n recipients = [sanitize_address(addr, email_message.encoding)\n for addr in email_message.recipients()]\n message = email_message.message().as_bytes(linesep='\\r\\n')\n try:\n result = self.conn.send_raw_email(\n Source=from_email,\n Destinations=recipients,\n RawMessage={\n 'Data': message\n }\n )\n message_id = result['MessageId']\n post_send.send(\n self.__class__,\n message=email_message,\n message_id=message_id\n )\n except ClientError:\n if not self.fail_silently:\n raise\n return False\n return True", "docstring": "Sends an individual message via the Amazon SES HTTP API.\n\n Args:\n email_message: A single Django EmailMessage object.\n Returns:\n True if the EmailMessage was sent successfully, otherwise False.\n Raises:\n ClientError: An interaction with the Amazon SES HTTP API\n failed." }, { "code": "def post_build_time_coverage(self):\n from ambry.util.datestimes import expand_to_years\n years = set()\n if self.metadata.about.time:\n for year in expand_to_years(self.metadata.about.time):\n years.add(year)\n if self.identity.btime:\n for year in expand_to_years(self.identity.btime):\n years.add(year)\n for p in self.partitions:\n years |= set(p.time_coverage)", "docstring": "Collect all of the time coverage for the bundle." }, { "code": "def _get_gradient_log_pdf(self):\n sub_vec = self.variable_assignments - self.model.mean.flatten()\n grad = - np.dot(self.model.precision_matrix, sub_vec)\n log_pdf = 0.5 * np.dot(sub_vec, grad)\n return grad, log_pdf", "docstring": "Method that finds gradient and its log at position" }, { "code": "def value(dtype, arg):\n if not isinstance(arg, ir.Expr):\n arg = ir.literal(arg)\n if not isinstance(arg, ir.AnyValue):\n raise com.IbisTypeError(\n 'Given argument with type {} is not a value '\n 'expression'.format(type(arg))\n )\n value = getattr(arg.op(), 'value', None)\n if isinstance(dtype, type) and isinstance(arg.type(), dtype):\n return arg\n elif dt.castable(arg.type(), dt.dtype(dtype), value=value):\n return arg\n else:\n raise com.IbisTypeError(\n 'Given argument with datatype {} is not '\n 'subtype of {} nor implicitly castable to '\n 'it'.format(arg.type(), dtype)\n )", "docstring": "Validates that the given argument is a Value with a particular datatype\n\n Parameters\n ----------\n dtype : DataType subclass or DataType instance\n arg : python literal or an ibis expression\n If a python literal is given the validator tries to coerce it to an ibis\n literal.\n\n Returns\n -------\n arg : AnyValue\n An ibis value expression with the specified datatype" }, { "code": "def login(session, user, password, database=None, server=None):\n if not user:\n user = click.prompt(\"Username\", type=str)\n if not password:\n password = click.prompt(\"Password\", hide_input=True, type=str)\n try:\n with click.progressbar(length=1, label=\"Logging in...\") as progressbar:\n session.login(user, password, database, server)\n progressbar.update(1)\n if session.credentials:\n click.echo('Logged in as: %s' % session.credentials)\n session.load(database)\n return session.get_api()\n except mygeotab.AuthenticationException:\n click.echo('Incorrect credentials. Please try again.')\n sys.exit(0)", "docstring": "Logs into a MyGeotab server and stores the returned credentials.\n\n :param session: The current Session object.\n :param user: The username used for MyGeotab servers. Usually an email address.\n :param password: The password associated with the username. Optional if `session_id` is provided.\n :param database: The database or company name. Optional as this usually gets resolved upon authentication.\n :param server: The server ie. my23.geotab.com. Optional as this usually gets resolved upon authentication." }, { "code": "def internal_writer(self, outputs, stdout):\n for output in outputs:\n print(\"\\t\".join(map(self.internal_serialize, output)), file=stdout)", "docstring": "Writer which outputs the python repr for each item." }, { "code": "def start_event(self):\n if self.with_outframe_pool:\n self.update_config()\n for name in self.outputs:\n self.outframe_pool[name] = ObjectPool(\n Frame, self.new_frame, self.config['outframe_pool_len'])\n try:\n self.on_start()\n except Exception as ex:\n self.logger.exception(ex)\n raise StopIteration()", "docstring": "Called by the event loop when it is started.\n\n Creates the output frame pools (if used) then calls\n :py:meth:`on_start`. Creating the output frame pools now allows\n their size to be configured before starting the component." }, { "code": "def filter(configs, settings):\n if isinstance(configs, pd.DataFrame):\n configs = configs[['a', 'b', 'm', 'n']].values\n filter_funcs = {\n 'dd': _filter_dipole_dipole,\n 'schlumberger': _filter_schlumberger,\n }\n keys = ['dd', 'schlumberger', ]\n allowed_keys = settings.get('only_types', filter_funcs.keys())\n results = {}\n configs_filtered = configs.copy().astype(float)\n for key in keys:\n if key in allowed_keys:\n configs_filtered, indices_filtered = filter_funcs[key](\n configs_filtered,\n )\n if len(indices_filtered) > 0:\n results[key] = indices_filtered\n results['not_sorted'] = np.where(\n ~np.all(np.isnan(configs_filtered), axis=1)\n )[0]\n return results", "docstring": "Main entry function to filtering configuration types\n\n Parameters\n ----------\n configs: Nx4 array\n array containing A-B-M-N configurations\n settings: dict\n 'only_types': ['dd', 'other'], # filter only for those types\n\n Returns\n -------\n dict\n results dict containing filter results (indices) for all registered\n filter functions. All remaining configs are stored under the keywords\n 'remaining'" }, { "code": "def _get_json(self,\n path,\n params=None,\n base=JIRA_BASE_URL,\n ):\n url = self._get_url(path, base)\n r = self._session.get(url, params=params)\n try:\n r_json = json_loads(r)\n except ValueError as e:\n logging.error(\"%s\\n%s\" % (e, r.text))\n raise e\n return r_json", "docstring": "Get the json for a given path and params.\n\n :param path: The subpath required\n :type path: str\n :param params: Parameters to filter the json query.\n :type params: Optional[Dict[str, Any]]\n :param base: The Base JIRA URL, defaults to the instance base.\n :type base: Optional[str]\n\n :rtype: Union[Dict[str, Any], List[Dict[str, str]]]" }, { "code": "def add_pagination_meta(self, params, meta):\n meta['page_size'] = params['page_size']\n meta['page'] = params['page']\n meta['prev'] = \"page={0}&page_size={1}\".format(\n params['page'] - 1, params['page_size']\n ) if meta['page'] > 0 else None\n meta['next'] = \"page={0}&page_size={1}\".format(\n params['page'] + 1, params['page_size']\n ) if meta.get('has_more', True) else None", "docstring": "Extend default meta dictionary value with pagination hints.\n\n Note:\n This method handler attaches values to ``meta`` dictionary without\n changing it's reference. This means that you should never replace\n ``meta`` dictionary with any other dict instance but simply modify\n its content.\n\n Args:\n params (dict): dictionary of decoded parameter values\n meta (dict): dictionary of meta values attached to response" }, { "code": "def __undo_filter_average(self, scanline):\n ai = -self.fu\n previous = self.prev\n for i in range(len(scanline)):\n x = scanline[i]\n if ai < 0:\n a = 0\n else:\n a = scanline[ai]\n b = previous[i]\n scanline[i] = (x + ((a + b) >> 1)) & 0xff\n ai += 1", "docstring": "Undo average filter." }, { "code": "def _compute_mean(self, C, g, mag, hypo_depth, rrup, vs30, pga_rock, imt):\n if hypo_depth > 100:\n hypo_depth = 100\n delta = 0.00724 * 10 ** (0.507 * mag)\n R = np.sqrt(rrup ** 2 + delta ** 2)\n s_amp = self._compute_soil_amplification(C, vs30, pga_rock, imt)\n mean = (\n C['c1'] + C['c2'] * mag +\n C['c3'] * hypo_depth +\n C['c4'] * R -\n g * np.log10(R) +\n s_amp\n )\n return mean", "docstring": "Compute mean according to equation 1, page 1706." }, { "code": "def connect(self):\n future = concurrent.Future()\n if self.connected:\n raise exceptions.ConnectError('already connected')\n LOGGER.debug('%s connecting', self.name)\n self.io_loop.add_future(\n self._client.connect(self.host, self.port),\n lambda f: self._on_connected(f, future))\n return future", "docstring": "Connect to the Redis server if necessary.\n\n :rtype: :class:`~tornado.concurrent.Future`\n :raises: :class:`~tredis.exceptions.ConnectError`\n :class:`~tredis.exceptinos.RedisError`" }, { "code": "def post(self, request, format=None):\n serializer_class = self.get_serializer_class()\n serializer = serializer_class(data=request.data, instance=request.user)\n if serializer.is_valid():\n serializer.save()\n return Response({'detail': _(u'Password successfully changed')})\n return Response(serializer.errors, status=400)", "docstring": "validate password change operation and return result" }, { "code": "def hildatree2dgparentedtree(self):\n def transform(hilda_tree):\n if isinstance(hilda_tree, basestring) or not hasattr(hilda_tree, 'label'):\n return hilda_tree\n assert len(hilda_tree) == 2, \"We can only handle binary trees.\"\n match = HILDA_REL_RE.match(hilda_tree.label())\n assert match, \"Relation '{}' does not match regex '{}'\".format(hilda_tree.label(), HILDA_REL_RE)\n relname, left_child_nuc, right_child_nuc = match.groups()\n hilda_tree._label = relname\n for i, child_nuclearity in enumerate([left_child_nuc, right_child_nuc]):\n child = hilda_tree[i]\n hilda_tree[i] = Tree(child_nuclearity, [transform(child)])\n return hilda_tree\n tree = transform(self.hildafile_tree)\n return DGParentedTree.convert(tree)", "docstring": "Convert the tree from HILDA's format into a conventional binary tree,\n which can be easily converted into output formats like RS3." }, { "code": "def config_as_dict(cfg):\n ret = cfg.__dict__.copy()\n del ret['rand_crop_samplers']\n assert isinstance(cfg.rand_crop_samplers, list)\n ret = merge_dict(ret, zip_namedtuple(cfg.rand_crop_samplers))\n num_crop_sampler = len(cfg.rand_crop_samplers)\n ret['num_crop_sampler'] = num_crop_sampler\n ret['rand_crop_prob'] = 1.0 / (num_crop_sampler + 1) * num_crop_sampler\n del ret['rand_pad']\n ret = merge_dict(ret, cfg.rand_pad._asdict())\n del ret['color_jitter']\n ret = merge_dict(ret, cfg.color_jitter._asdict())\n return ret", "docstring": "convert raw configuration to unified dictionary" }, { "code": "def speed_difference(points):\n data = [0]\n for before, after in pairwise(points):\n data.append(before.vel - after.vel)\n return data", "docstring": "Computes the speed difference between each adjacent point\n\n Args:\n points (:obj:`Point`)\n Returns:\n :obj:`list` of int: Indexes of changepoints" }, { "code": "def factorize_groupby_cols(self, groupby_cols):\n factor_list = []\n values_list = []\n for col in groupby_cols:\n if self.auto_cache or self.cache_valid(col):\n if not self.cache_valid(col):\n self.cache_factor([col])\n col_rootdir = self[col].rootdir\n col_factor_rootdir = col_rootdir + '.factor'\n col_values_rootdir = col_rootdir + '.values'\n col_carray_factor = \\\n bcolz.carray(rootdir=col_factor_rootdir, mode='r')\n col_carray_values = \\\n bcolz.carray(rootdir=col_values_rootdir, mode='r')\n else:\n col_carray_factor, values = ctable_ext.factorize(self[col])\n col_carray_values = \\\n bcolz.carray(np.fromiter(values.values(), dtype=self[col].dtype))\n factor_list.append(col_carray_factor)\n values_list.append(col_carray_values)\n return factor_list, values_list", "docstring": "factorizes all columns that are used in the groupby\n it will use cache carrays if available\n if not yet auto_cache is valid, it will create cache carrays" }, { "code": "def ls(path, pattern='*'):\n path_iter = glob(path, pattern, recursive=False)\n return sorted(list(path_iter))", "docstring": "like unix ls - lists all files and dirs in path" }, { "code": "def _assert_has_data_for_time(da, start_date, end_date):\n if isinstance(start_date, str) and isinstance(end_date, str):\n logging.warning(\n 'When using strings to specify start and end dates, the check '\n 'to determine if data exists for the full extent of the desired '\n 'interval is not implemented. Therefore it is possible that '\n 'you are doing a calculation for a lesser interval than you '\n 'specified. If you would like this check to occur, use explicit '\n 'datetime-like objects for bounds instead.')\n return\n if RAW_START_DATE_STR in da.coords:\n with warnings.catch_warnings(record=True):\n da_start = da[RAW_START_DATE_STR].values\n da_end = da[RAW_END_DATE_STR].values\n else:\n times = da.time.isel(**{TIME_STR: [0, -1]})\n da_start, da_end = times.values\n message = ('Data does not exist for requested time range: {0} to {1};'\n ' found data from time range: {2} to {3}.')\n tol = datetime.timedelta(seconds=1)\n if isinstance(da_start, np.datetime64):\n tol = np.timedelta64(tol, 'ns')\n range_exists = ((da_start - tol) <= start_date and\n (da_end + tol) >= end_date)\n assert (range_exists), message.format(start_date, end_date,\n da_start, da_end)", "docstring": "Check to make sure data is in Dataset for the given time range.\n\n Parameters\n ----------\n da : DataArray\n DataArray with a time variable\n start_date : datetime-like object or str\n start date\n end_date : datetime-like object or str\n end date\n\n Raises\n ------\n AssertionError\n If the time range is not within the time range of the DataArray" }, { "code": "def write(self, output):\n w = c_int32()\n self.WriteAnalogF64(self.bufsize, 0, 10.0, DAQmx_Val_GroupByChannel,\n output, w, None);", "docstring": "Writes the data to be output to the device buffer, output will be looped when the data runs out\n\n :param output: data to output\n :type output: numpy.ndarray" }, { "code": "def long2ip(l):\n if MAX_IP < l or l < MIN_IP:\n raise TypeError(\n \"expected int between %d and %d inclusive\" % (MIN_IP, MAX_IP))\n return '%d.%d.%d.%d' % (\n l >> 24 & 255, l >> 16 & 255, l >> 8 & 255, l & 255)", "docstring": "Convert a network byte order 32-bit integer to a dotted quad ip\n address.\n\n\n >>> long2ip(2130706433)\n '127.0.0.1'\n >>> long2ip(MIN_IP)\n '0.0.0.0'\n >>> long2ip(MAX_IP)\n '255.255.255.255'\n >>> long2ip(None) #doctest: +IGNORE_EXCEPTION_DETAIL\n Traceback (most recent call last):\n ...\n TypeError: unsupported operand type(s) for >>: 'NoneType' and 'int'\n >>> long2ip(-1) #doctest: +IGNORE_EXCEPTION_DETAIL\n Traceback (most recent call last):\n ...\n TypeError: expected int between 0 and 4294967295 inclusive\n >>> long2ip(374297346592387463875) #doctest: +IGNORE_EXCEPTION_DETAIL\n Traceback (most recent call last):\n ...\n TypeError: expected int between 0 and 4294967295 inclusive\n >>> long2ip(MAX_IP + 1) #doctest: +IGNORE_EXCEPTION_DETAIL\n Traceback (most recent call last):\n ...\n TypeError: expected int between 0 and 4294967295 inclusive\n\n\n :param l: Network byte order 32-bit integer.\n :type l: int\n :returns: Dotted-quad ip address (eg. '127.0.0.1').\n :raises: TypeError" }, { "code": "def query(self, *args, **kwargs):\n if not issubclass(kwargs.get('itercls', None), AsyncViewBase):\n raise ArgumentError.pyexc(\"itercls must be defined \"\n \"and must be derived from AsyncViewBase\")\n return super(AsyncBucket, self).query(*args, **kwargs)", "docstring": "Reimplemented from base class.\n\n This method does not add additional functionality of the\n base class' :meth:`~couchbase.bucket.Bucket.query` method (all the\n functionality is encapsulated in the view class anyway). However it\n does require one additional keyword argument\n\n :param class itercls: A class used for instantiating the view\n object. This should be a subclass of\n :class:`~couchbase.asynchronous.view.AsyncViewBase`." }, { "code": "def get_code(node, coder=Coder()):\n return cgi.escape(str(coder.code(node)), quote=True)", "docstring": "Return a node's code" }, { "code": "def spin_z(particles, index):\n mat = np.zeros((2**particles, 2**particles))\n for i in range(2**particles):\n ispin = btest(i, index)\n if ispin == 1:\n mat[i, i] = 1\n else:\n mat[i, i] = -1\n return 1/2.*mat", "docstring": "Generates the spin_z projection operator for a system of\n N=particles and for the selected spin index name. where index=0..N-1" }, { "code": "def auth_list(**kwargs):\n ctx = Context(**kwargs)\n ctx.execute_action('auth:group:list', **{\n 'storage': ctx.repo.create_secure_service('storage'),\n })", "docstring": "Shows available authorization groups." }, { "code": "def get(self):\n self.set_status(401)\n self.set_header('WWW-Authenticate', 'Session')\n ret = {'status': '401 Unauthorized',\n 'return': 'Please log in'}\n self.write(self.serialize(ret))", "docstring": "All logins are done over post, this is a parked endpoint\n\n .. http:get:: /login\n\n :status 401: |401|\n :status 406: |406|\n\n **Example request:**\n\n .. code-block:: bash\n\n curl -i localhost:8000/login\n\n .. code-block:: text\n\n GET /login HTTP/1.1\n Host: localhost:8000\n Accept: application/json\n\n **Example response:**\n\n .. code-block:: text\n\n HTTP/1.1 401 Unauthorized\n Content-Type: application/json\n Content-Length: 58\n\n {\"status\": \"401 Unauthorized\", \"return\": \"Please log in\"}" }, { "code": "def launch_shell(username, hostname, password, port=22):\n if not username or not hostname or not password:\n return False\n with tempfile.NamedTemporaryFile() as tmpFile:\n os.system(sshCmdLine.format(password, tmpFile.name, username, hostname,\n port))\n return True", "docstring": "Launches an ssh shell" }, { "code": "def get_data(self, datatype, data):\n result = {}\n params = StopforumspamClient._set_payload(datatype, data)\n response = self.client.get(\n 'https://api.stopforumspam.org/api',\n params=params, proxies=self.proxies)\n response.raise_for_status()\n report = response.json()\n if report['success']:\n data = report[StopforumspamClient._type_conversion[datatype]]\n result = self._data_conversion(data)\n else:\n pass\n return result", "docstring": "Look for an IP address or an email address in the spammer database.\n\n :param datatype: Which type of data is to be looked up.\n Allowed values are 'ip' or 'mail'.\n :param data: The value to be looked up through the API.\n :type datatype: str\n :type data: str\n :return: Data relative to the looked up artifact.\n :rtype: dict" }, { "code": "def delete(self):\n r = self._client._request('DELETE', self._client._build_url('property', property_id=self.id))\n if r.status_code != requests.codes.no_content:\n raise APIError(\"Could not delete property: {} with id {}\".format(self.name, self.id))", "docstring": "Delete this property.\n\n :return: None\n :raises APIError: if delete was not successful" }, { "code": "def get_version(self, dependency):\n logger.debug(\"getting installed version for %s\", dependency)\n stdout = helpers.logged_exec([self.pip_exe, \"show\", str(dependency)])\n version = [line for line in stdout if line.startswith('Version:')]\n if len(version) == 1:\n version = version[0].strip().split()[1]\n logger.debug(\"Installed version of %s is: %s\", dependency, version)\n return version\n else:\n logger.error('Fades is having problems getting the installed version. '\n 'Run with -v or check the logs for details')\n return ''", "docstring": "Return the installed version parsing the output of 'pip show'." }, { "code": "def format_to_json(data):\n if sys.stdout.isatty():\n return json.dumps(data, indent=4, separators=(',', ': '))\n else:\n return json.dumps(data)", "docstring": "Converts `data` into json\n If stdout is a tty it performs a pretty print." }, { "code": "def _format_options_usage(options):\n options_usage = \"\"\n for op in options:\n short, long = op.get_flags()\n if op.arg:\n flag = \"{short} {arg} {long}={arg}\".format(\n short=short, long=long, arg=op.arg)\n else:\n flag = \"{short} {long}\".format(short=short, long=long)\n wrapped_description = textwrap.wrap(inspect.cleandoc(op.__doc__),\n width=79,\n initial_indent=' ' * 32,\n subsequent_indent=' ' * 32)\n wrapped_description = \"\\n\".join(wrapped_description).strip()\n options_usage += \" {0:28} {1}\\n\".format(flag, wrapped_description)\n return options_usage", "docstring": "Format the Options-part of the usage text.\n\n Parameters\n ----------\n options : list[sacred.commandline_options.CommandLineOption]\n A list of all supported commandline options.\n\n Returns\n -------\n str\n Text formatted as a description for the commandline options" }, { "code": "def unique_prefixes(context):\n res = {}\n for m in context.modules.values():\n if m.keyword == \"submodule\": continue\n prf = new = m.i_prefix\n suff = 0\n while new in res.values():\n suff += 1\n new = \"%s%x\" % (prf, suff)\n res[m] = new\n return res", "docstring": "Return a dictionary with unique prefixes for modules in `context`.\n\n Keys are 'module' statements and values are prefixes,\n disambiguated where necessary." }, { "code": "def prepare_image_data(extracted_image_data, output_directory,\n image_mapping):\n img_list = {}\n for image, caption, label in extracted_image_data:\n if not image or image == 'ERROR':\n continue\n image_location = get_image_location(\n image,\n output_directory,\n image_mapping.keys()\n )\n if not image_location or not os.path.exists(image_location) or \\\n len(image_location) < 3:\n continue\n image_location = os.path.normpath(image_location)\n if image_location in img_list:\n if caption not in img_list[image_location]['captions']:\n img_list[image_location]['captions'].append(caption)\n else:\n img_list[image_location] = dict(\n url=image_location,\n original_url=image_mapping[image_location],\n captions=[caption],\n label=label,\n name=get_name_from_path(image_location, output_directory)\n )\n return img_list.values()", "docstring": "Prepare and clean image-data from duplicates and other garbage.\n\n :param: extracted_image_data ([(string, string, list, list) ...],\n ...])): the images and their captions + contexts, ordered\n :param: tex_file (string): the location of the TeX (used for finding the\n associated images; the TeX is assumed to be in the same directory\n as the converted images)\n :param: image_list ([string, string, ...]): a list of the converted\n image file names\n :return extracted_image_data ([(string, string, list, list) ...],\n ...])) again the list of image data cleaned for output" }, { "code": "def _total_counts(seqs, seqL, aligned=False):\n total = Counter()\n if isinstance(seqs, list):\n if not aligned:\n l = len([total.update(seqL[s].freq) for s in seqs])\n else:\n l = len([total.update(seqL[s].freq) for s in seqs if seqL[s].align > 0])\n elif isinstance(seqs, dict):\n [total.update(seqs[s].get_freq(seqL)) for s in seqs]\n l = sum(len(seqs[s].idmembers) for s in seqs)\n return total, l", "docstring": "Counts total seqs after each step" }, { "code": "def _next_sample_index(self):\n idx = self.active_index_\n self.active_index_ += 1\n if self.active_index_ >= len(self.streams_):\n self.active_index_ = 0\n while self.streams_[idx] is None:\n idx = self.active_index_\n self.active_index_ += 1\n if self.active_index_ >= len(self.streams_):\n self.active_index_ = 0\n return idx", "docstring": "Rotates through each active sampler by incrementing the index" }, { "code": "def array(self):\n if self._ind < self.shape:\n return self._values[:self._ind]\n if not self._cached:\n ind = int(self._ind % self.shape)\n self._cache[:self.shape - ind] = self._values[ind:]\n self._cache[self.shape - ind:] = self._values[:ind]\n self._cached = True\n return self._cache", "docstring": "Returns a numpy array containing the last stored values." }, { "code": "def socket(self, blocking=True):\n if self._socket_lock.acquire(blocking):\n try:\n yield self._socket\n finally:\n self._socket_lock.release()", "docstring": "Blockingly yield the socket" }, { "code": "def run(self, format=None, reduce=False, *args, **kwargs):\n plan = self._generate_plan()\n if reduce:\n plan.graph.transitive_reduction()\n fn = FORMATTERS[format]\n fn(sys.stdout, plan.graph)\n sys.stdout.flush()", "docstring": "Generates the underlying graph and prints it." }, { "code": "def __telnet_event_listener(self, ip, callback):\n tn = telnetlib.Telnet(ip, 2708)\n self._last_event = \"\"\n self._telnet_running = True\n while self._telnet_running:\n try:\n raw_string = tn.read_until(b'.\\n', 5)\n if len(raw_string) >= 2 and raw_string[-2:] == b'.\\n':\n json_string = raw_string.decode('ascii')[0:-2]\n if json_string != self._last_event:\n callback(json.loads(json_string))\n self._last_event = json_string\n except:\n pass\n tn.close()", "docstring": "creates a telnet connection to the lightpad" }, { "code": "def mkdir(dir, enter):\n if not os.path.exists(dir):\n os.makedirs(dir)", "docstring": "Create directory with template for topic of the current environment" }, { "code": "def alg2keytype(alg):\n if not alg or alg.lower() == \"none\":\n return \"none\"\n elif alg.startswith(\"RS\") or alg.startswith(\"PS\"):\n return \"RSA\"\n elif alg.startswith(\"HS\") or alg.startswith(\"A\"):\n return \"oct\"\n elif alg.startswith(\"ES\") or alg.startswith(\"ECDH-ES\"):\n return \"EC\"\n else:\n return None", "docstring": "Go from algorithm name to key type.\n\n :param alg: The algorithm name\n :return: The key type" }, { "code": "def get(self):\n if self.arch.startswith(\"i\") and self.arch.endswith(\"86\"):\n self.arch = self.x86\n elif self.meta.arch.startswith(\"arm\"):\n self.arch = self.arm\n return self.arch", "docstring": "Return sbo arch" }, { "code": "def source_sum(self):\n if self._is_completely_masked:\n return np.nan * self._data_unit\n else:\n return np.sum(self.values)", "docstring": "The sum of the unmasked ``data`` values within the source segment.\n\n .. math:: F = \\\\sum_{i \\\\in S} (I_i - B_i)\n\n where :math:`F` is ``source_sum``, :math:`(I_i - B_i)` is the\n ``data``, and :math:`S` are the unmasked pixels in the source\n segment.\n\n Non-finite pixel values (e.g. NaN, infs) are excluded\n (automatically masked)." }, { "code": "def compose(*funcs):\n\tdef compose_two(f1, f2):\n\t\treturn lambda *args, **kwargs: f1(f2(*args, **kwargs))\n\treturn functools.reduce(compose_two, funcs)", "docstring": "Compose any number of unary functions into a single unary function.\n\n\t>>> import textwrap\n\t>>> from six import text_type\n\t>>> stripped = text_type.strip(textwrap.dedent(compose.__doc__))\n\t>>> compose(text_type.strip, textwrap.dedent)(compose.__doc__) == stripped\n\tTrue\n\n\tCompose also allows the innermost function to take arbitrary arguments.\n\n\t>>> round_three = lambda x: round(x, ndigits=3)\n\t>>> f = compose(round_three, int.__truediv__)\n\t>>> [f(3*x, x+1) for x in range(1,10)]\n\t[1.5, 2.0, 2.25, 2.4, 2.5, 2.571, 2.625, 2.667, 2.7]" }, { "code": "def get_crimes_area(self, points, date=None, category=None):\n if isinstance(category, CrimeCategory):\n category = category.id\n method = 'crimes-street/%s' % (category or 'all-crime')\n kwargs = {\n 'poly': encode_polygon(points),\n }\n crimes = []\n if date is not None:\n kwargs['date'] = date\n for c in self.service.request('POST', method, **kwargs):\n crimes.append(Crime(self, data=c))\n return crimes", "docstring": "Get crimes within a custom area. Uses the crime-street_ API call.\n\n .. _crime-street: https//data.police.uk/docs/method/crime-street/\n\n :rtype: list\n :param list points: A ``list`` of ``(lat, lng)`` tuples.\n :param date: The month in which the crimes were reported in the format\n ``YYYY-MM`` (the latest date is used if ``None``).\n :type date: str or None\n :param category: The category of the crimes to filter by (either by ID\n or CrimeCategory object)\n :type category: str or CrimeCategory\n :return: A ``list`` of crimes which were reported within the specified\n boundary, in the given month (optionally filtered by\n category)." }, { "code": "def _table_set_column(table, name, expr):\n expr = table._ensure_expr(expr)\n if expr._name != name:\n expr = expr.name(name)\n if name not in table:\n raise KeyError('{0} is not in the table'.format(name))\n proj_exprs = []\n for key in table.columns:\n if key == name:\n proj_exprs.append(expr)\n else:\n proj_exprs.append(table[key])\n return table.projection(proj_exprs)", "docstring": "Replace an existing column with a new expression\n\n Parameters\n ----------\n name : string\n Column name to replace\n expr : value expression\n New data for column\n\n Returns\n -------\n set_table : TableExpr\n New table expression" }, { "code": "def set_location(self, uri, size, checksum, storage_class=None):\n self.file = FileInstance()\n self.file.set_uri(\n uri, size, checksum, storage_class=storage_class\n )\n db.session.add(self.file)\n return self", "docstring": "Set only URI location of for object.\n\n Useful to link files on externally controlled storage. If a file\n instance has already been set, this methods raises an\n ``FileInstanceAlreadySetError`` exception.\n\n :param uri: Full URI to object (which can be interpreted by the storage\n interface).\n :param size: Size of file.\n :param checksum: Checksum of file.\n :param storage_class: Storage class where file is stored ()" }, { "code": "def get_smart_storage_config(self, smart_storage_config_url):\n return (smart_storage_config.\n HPESmartStorageConfig(self._conn, smart_storage_config_url,\n redfish_version=self.redfish_version))", "docstring": "Returns a SmartStorageConfig Instance for each controller." }, { "code": "def get_file(fn):\n fn = os.path.join(os.path.dirname(__file__), 'data', fn)\n f = open(fn, 'rb')\n lines = [line.decode('utf-8').strip() for line in f.readlines()]\n return lines", "docstring": "Returns file contents in unicode as list." }, { "code": "def keytype_path_to(args, keytype):\n if keytype == \"admin\":\n return '{cluster}.client.admin.keyring'.format(\n cluster=args.cluster)\n if keytype == \"mon\":\n return '{cluster}.mon.keyring'.format(\n cluster=args.cluster)\n return '{cluster}.bootstrap-{what}.keyring'.format(\n cluster=args.cluster,\n what=keytype)", "docstring": "Get the local filename for a keyring type" }, { "code": "def findlast(*args, **kwargs):\n list_, idx = _index(*args, start=sys.maxsize, step=-1, **kwargs)\n if idx < 0:\n raise IndexError(\"element not found\")\n return list_[idx]", "docstring": "Find the last matching element in a list and return it.\n\n Usage::\n\n findlast(element, list_)\n findlast(of=element, in_=list_)\n findlast(where=predicate, in_=list_)\n\n :param element, of: Element to search for (by equality comparison)\n :param where: Predicate defining an element to search for.\n This should be a callable taking a single argument\n and returning a boolean result.\n :param list_, in_: List to search in\n\n :return: Last matching element\n :raise IndexError: If no matching elements were found\n\n .. versionadded:: 0.0.4" }, { "code": "def _validate_namespaces(self, input_namespaces):\n output_namespaces = []\n if input_namespaces == []:\n return output_namespaces\n elif '*' in input_namespaces:\n if len(input_namespaces) > 1:\n warning = 'Warning: Multiple namespaces are '\n warning += 'ignored when one namespace is \"*\"\\n'\n sys.stderr.write(warning)\n return output_namespaces\n else:\n for namespace in input_namespaces:\n if not isinstance(namespace, unicode):\n namespace = unicode(namespace)\n namespace_tuple = self._tuplefy_namespace(namespace)\n if namespace_tuple is None:\n warning = 'Warning: Invalid namespace ' + namespace\n warning += ' will be ignored\\n'\n sys.stderr.write(warning)\n else:\n if namespace_tuple not in output_namespaces:\n output_namespaces.append(namespace_tuple)\n else:\n warning = 'Warning: Duplicate namespace ' + namespace\n warning += ' will be ignored\\n'\n sys.stderr.write(warning)\n return output_namespaces", "docstring": "Converts a list of db namespaces to a list of namespace tuples,\n supporting basic commandline wildcards" }, { "code": "def string(self, units: typing.Optional[str] = None) -> str:\n if not units:\n _units: str = self._units\n else:\n if not units.upper() in CustomPressure.legal_units:\n raise UnitsError(\"unrecognized pressure unit: '\" + units + \"'\")\n _units = units.upper()\n val = self.value(units)\n if _units == \"MB\":\n return \"%.0f mb\" % val\n if _units == \"HPA\":\n return \"%.0f hPa\" % val\n if _units == \"IN\":\n return \"%.2f inches\" % val\n if _units == \"MM\":\n return \"%.0f mmHg\" % val\n raise ValueError(_units)", "docstring": "Return a string representation of the pressure, using the given units." }, { "code": "def set(self, field, value):\n if field == 'uuid':\n raise ValueError('uuid cannot be set')\n elif field == 'key':\n raise ValueError(\n 'key cannot be set. Use \\'reset_key\\' method')\n else:\n self.data[field] = value", "docstring": "Sets the value of an app field.\n\n :param str field:\n The name of the app field. Trying to set immutable fields\n ``uuid`` or ``key`` will raise a ValueError.\n :param value:\n The new value of the app field.\n :raises: ValueError" }, { "code": "def set(self, section, option, value=''):\n self._string_check(value)\n super(GitConfigParser, self).set(section, option, value)", "docstring": "This is overridden from the RawConfigParser merely to change the\n default value for the 'value' argument." }, { "code": "def render_source(self, source, variables=None):\n if variables is None:\n variables = {}\n template = self._engine.from_string(source)\n return template.render(**variables)", "docstring": "Render a source with the passed variables." }, { "code": "def translate(self, exc):\n from boto.exception import StorageResponseError\n if isinstance(exc, StorageResponseError):\n if exc.status == 404:\n return self.error_cls(str(exc))\n return None", "docstring": "Return whether or not to do translation." }, { "code": "def ekf1_pos(EKF1):\n global ekf_home\n from . import mavutil\n self = mavutil.mavfile_global\n if ekf_home is None:\n if not 'GPS' in self.messages or self.messages['GPS'].Status != 3:\n return None\n ekf_home = self.messages['GPS']\n (ekf_home.Lat, ekf_home.Lng) = gps_offset(ekf_home.Lat, ekf_home.Lng, -EKF1.PE, -EKF1.PN)\n (lat,lon) = gps_offset(ekf_home.Lat, ekf_home.Lng, EKF1.PE, EKF1.PN)\n return (lat, lon)", "docstring": "calculate EKF position when EKF disabled" }, { "code": "def _tag_ebs(self, conn, role):\n tags = {'Name': 'spilo_' + self.cluster_name, 'Role': role, 'Instance': self.instance_id}\n volumes = conn.get_all_volumes(filters={'attachment.instance-id': self.instance_id})\n conn.create_tags([v.id for v in volumes], tags)", "docstring": "set tags, carrying the cluster name, instance role and instance id for the EBS storage" }, { "code": "def upload_mission(aFileName):\n missionlist = readmission(aFileName)\n print(\"\\nUpload mission from a file: %s\" % aFileName)\n print(' Clear mission')\n cmds = vehicle.commands\n cmds.clear()\n for command in missionlist:\n cmds.add(command)\n print(' Upload mission')\n vehicle.commands.upload()", "docstring": "Upload a mission from a file." }, { "code": "def integral(self, bandname):\n intg = {}\n for det in self.rsr[bandname].keys():\n wvl = self.rsr[bandname][det]['wavelength']\n resp = self.rsr[bandname][det]['response']\n intg[det] = np.trapz(resp, wvl)\n return intg", "docstring": "Calculate the integral of the spectral response function for each\n detector." }, { "code": "def _CheckPythonVersionAndDisableWarnings(self):\n if self._checked_for_old_python_version:\n return\n if sys.version_info[0:3] < (2, 7, 9):\n logger.warning(\n 'You are running a version of Python prior to 2.7.9. Your version '\n 'of Python has multiple weaknesses in its SSL implementation that '\n 'can allow an attacker to read or modify SSL encrypted data. '\n 'Please update. Further SSL warnings will be suppressed. See '\n 'https://www.python.org/dev/peps/pep-0466/ for more information.')\n urllib3_module = urllib3\n if not urllib3_module:\n if hasattr(requests, 'packages'):\n urllib3_module = getattr(requests.packages, 'urllib3')\n if urllib3_module and hasattr(urllib3_module, 'disable_warnings'):\n urllib3_module.disable_warnings()\n self._checked_for_old_python_version = True", "docstring": "Checks python version, and disables SSL warnings.\n\n urllib3 will warn on each HTTPS request made by older versions of Python.\n Rather than spamming the user, we print one warning message, then disable\n warnings in urllib3." }, { "code": "def libvlc_media_library_media_list(p_mlib):\n f = _Cfunctions.get('libvlc_media_library_media_list', None) or \\\n _Cfunction('libvlc_media_library_media_list', ((1,),), class_result(MediaList),\n ctypes.c_void_p, MediaLibrary)\n return f(p_mlib)", "docstring": "Get media library subitems.\n @param p_mlib: media library object.\n @return: media list subitems." }, { "code": "def _makeTimingAbsolute(relativeDataList, startTime, endTime):\n timingSeq = [row[0] for row in relativeDataList]\n valueSeq = [list(row[1:]) for row in relativeDataList]\n absTimingSeq = makeSequenceAbsolute(timingSeq, startTime, endTime)\n absDataList = [tuple([time, ] + row) for time, row\n in zip(absTimingSeq, valueSeq)]\n return absDataList", "docstring": "Maps values from 0 to 1 to the provided start and end time\n\n Input is a list of tuples of the form\n ([(time1, pitch1), (time2, pitch2),...]" }, { "code": "def clear(self):\n self._index = defaultdict(list)\n self._reverse_index = defaultdict(list)\n self._undefined_keys = {}", "docstring": "Clear index." }, { "code": "def pong(self, payload):\n if isinstance(payload, six.text_type):\n payload = payload.encode(\"utf-8\")\n self.send(payload, ABNF.OPCODE_PONG)", "docstring": "send pong data.\n\n payload: data payload to send server." }, { "code": "def _cleanup_tempdir(tempdir):\n try:\n shutil.rmtree(tempdir)\n except OSError as err:\n if err.errno != errno.ENOENT:\n raise", "docstring": "Clean up temp directory ignoring ENOENT errors." }, { "code": "def keys(self):\n keys = []\n for app_name, __ in self.items():\n keys.append(app_name)\n return keys", "docstring": "return a list of all app_names" }, { "code": "def getNumDownloads(self, fileInfo):\n\t\tdownloads = fileInfo[fileInfo.find(\"FILE INFORMATION\"):]\n\t\tif -1 != fileInfo.find(\"not included in ranking\"):\n\t\t\treturn \"0\"\n\t\tdownloads = downloads[:downloads.find(\".
\")]\n\t\tdownloads = downloads[downloads.find(\" with \") + len(\" with \"):]\n\t\treturn downloads", "docstring": "Function to get the number of times a file has been downloaded" }, { "code": "def create_form(self, label_columns=None, inc_columns=None,\n description_columns=None, validators_columns=None,\n extra_fields=None, filter_rel_fields=None):\n label_columns = label_columns or {}\n inc_columns = inc_columns or []\n description_columns = description_columns or {}\n validators_columns = validators_columns or {}\n extra_fields = extra_fields or {}\n form_props = {}\n for col_name in inc_columns:\n if col_name in extra_fields:\n form_props[col_name] = extra_fields.get(col_name)\n else:\n self._convert_col(col_name, self._get_label(col_name, label_columns),\n self._get_description(col_name, description_columns),\n self._get_validators(col_name, validators_columns),\n filter_rel_fields, form_props)\n return type('DynamicForm', (DynamicForm,), form_props)", "docstring": "Converts a model to a form given\n\n :param label_columns:\n A dictionary with the column's labels.\n :param inc_columns:\n A list with the columns to include\n :param description_columns:\n A dictionary with a description for cols.\n :param validators_columns:\n A dictionary with WTForms validators ex::\n\n validators={'personal_email':EmailValidator}\n\n :param extra_fields:\n A dictionary containing column names and a WTForm\n Form fields to be added to the form, these fields do not\n exist on the model itself ex::\n\n extra_fields={'some_col':BooleanField('Some Col', default=False)}\n\n :param filter_rel_fields:\n A filter to be applied on relationships" }, { "code": "def attach(self, stdout=True, stderr=True, stream=True, logs=False):\n try:\n data = parse_stream(self.client.attach(self.id, stdout, stderr, stream, logs))\n except KeyboardInterrupt:\n logger.warning(\n \"service container: {0} has been interrupted. \"\n \"The container will be stopped but will not be deleted.\".format(self.name)\n )\n data = None\n self.stop()\n return data", "docstring": "Keeping this simple until we need to extend later." }, { "code": "def on_breakpoints_changed(self, removed=False):\n if not self.ready_to_run:\n return\n self.mtime += 1\n if not removed:\n self.set_tracing_for_untraced_contexts()", "docstring": "When breakpoints change, we have to re-evaluate all the assumptions we've made so far." }, { "code": "def _print_config_text(tree, indentation=0):\n config = ''\n for key, value in six.iteritems(tree):\n config += '{indent}{line}\\n'.format(indent=' '*indentation, line=key)\n if value:\n config += _print_config_text(value, indentation=indentation+1)\n return config", "docstring": "Return the config as text from a config tree." }, { "code": "def validate(request: Union[Dict, List], schema: dict) -> Union[Dict, List]:\n jsonschema_validate(request, schema)\n return request", "docstring": "Wraps jsonschema.validate, returning the same object passed in.\n\n Args:\n request: The deserialized-from-json request.\n schema: The jsonschema schema to validate against.\n\n Raises:\n jsonschema.ValidationError" }, { "code": "def _integrate_fixed_trajectory(self, h, T, step, relax):\n solution = np.hstack((self.t, self.y))\n while self.successful():\n self.integrate(self.t + h, step, relax)\n current_step = np.hstack((self.t, self.y))\n solution = np.vstack((solution, current_step))\n if (h > 0) and (self.t >= T):\n break\n elif (h < 0) and (self.t <= T):\n break\n else:\n continue\n return solution", "docstring": "Generates a solution trajectory of fixed length." }, { "code": "def helper_add(access_token, ck_id, path, body):\n full_path = ''.join([path, \"('\", ck_id, \"')\"])\n full_path_encoded = urllib.parse.quote(full_path, safe='')\n endpoint = ''.join([ams_rest_endpoint, full_path_encoded])\n return do_ams_put(endpoint, full_path_encoded, body, access_token, \"json_only\", \"1.0;NetFx\")", "docstring": "Helper Function to add strings to a URL path.\n\n Args:\n access_token (str): A valid Azure authentication token.\n ck_id (str): A CK ID.\n path (str): A URL Path.\n body (str): A Body.\n\n Returns:\n HTTP response. JSON body." }, { "code": "def get_singularity_version():\n version = os.environ.get('SPYTHON_SINGULARITY_VERSION', \"\")\n if version == \"\":\n try:\n version = run_command([\"singularity\", '--version'], quiet=True)\n except:\n return version\n if version['return_code'] == 0:\n if len(version['message']) > 0:\n version = version['message'][0].strip('\\n')\n return version", "docstring": "get the singularity client version. Useful in the case that functionality\n has changed, etc. Can be \"hacked\" if needed by exporting \n SPYTHON_SINGULARITY_VERSION, which is checked before checking on the\n command line." }, { "code": "def release(self, message_id, reservation_id, delay=0):\n url = \"queues/%s/messages/%s/release\" % (self.name, message_id)\n body = {'reservation_id': reservation_id}\n if delay > 0:\n body['delay'] = delay\n body = json.dumps(body)\n response = self.client.post(url, body=body,\n headers={'Content-Type': 'application/json'})\n return response['body']", "docstring": "Release locked message after specified time. If there is no message with such id on the queue.\n\n Arguments:\n message_id -- The ID of the message.\n reservation_id -- Reservation Id of the message.\n delay -- The time after which the message will be released." }, { "code": "def unique_authors(self, limit):\n seen = set()\n if limit == 0:\n limit = None\n seen_add = seen.add\n return [x.author for x in self.sorted_commits[:limit]\n if not (x.author in seen or seen_add(x.author))]", "docstring": "Unique list of authors, but preserving order." }, { "code": "def cross_v2(vec1, vec2):\n return vec1.y * vec2.x - vec1.x * vec2.y", "docstring": "Return the crossproduct of the two vectors as a Vec2.\n Cross product doesn't really make sense in 2D, but return the Z component\n of the 3d result." }, { "code": "def serverDirectories(self):\n directs = []\n url = self._url + \"/directories\"\n params = {\n \"f\" : \"json\"\n }\n res = self._get(url=url,\n param_dict=params,\n securityHandler=self._securityHandler,\n proxy_url=self._proxy_url,\n proxy_port=self._proxy_port)\n for direct in res['directories']:\n directs.append(\n ServerDirectory(url=url + \"/%s\" % direct[\"name\"],\n securityHandler=self._securityHandler,\n proxy_url=self._proxy_url,\n proxy_port=self._proxy_port,\n initialize=True))\n return directs", "docstring": "returns the server directory object in a list" }, { "code": "def _merge_maps(m1, m2):\n return type(m1)(chain(m1.items(), m2.items()))", "docstring": "merge two Mapping objects, keeping the type of the first mapping" }, { "code": "def get(self, blocking=True):\n if self.closed:\n raise PoolAlreadyClosedError(\"Connection pool is already closed.\")\n if not self.limiter.acquire(blocking=blocking):\n return None\n c = None\n try:\n c = self.idle_conns.pop()\n except IndexError:\n try:\n c = self.connect_func()\n except Exception:\n self.limiter.release()\n raise\n return _ConnectionProxy(self, c)", "docstring": "Gets a connection.\n\n Args:\n blocking: Whether to block when max_size connections are already in use.\n If false, may return None.\n\n Returns:\n A connection to the database.\n\n Raises:\n PoolAlreadyClosedError: if close() method was already called on\n this pool." }, { "code": "def timestamp_file():\n config_dir = os.path.join(\n os.path.expanduser(\"~\"), BaseGlobalConfig.config_local_dir\n )\n if not os.path.exists(config_dir):\n os.mkdir(config_dir)\n timestamp_file = os.path.join(config_dir, \"cumulus_timestamp\")\n try:\n with open(timestamp_file, \"r+\") as f:\n yield f\n except IOError:\n with open(timestamp_file, \"w+\") as f:\n yield f", "docstring": "Opens a file for tracking the time of the last version check" }, { "code": "def crypto_core_ed25519_add(p, q):\n ensure(isinstance(p, bytes) and isinstance(q, bytes) and\n len(p) == crypto_core_ed25519_BYTES and\n len(q) == crypto_core_ed25519_BYTES,\n 'Each point must be a {} long bytes sequence'.format(\n 'crypto_core_ed25519_BYTES'),\n raising=exc.TypeError)\n r = ffi.new(\"unsigned char[]\", crypto_core_ed25519_BYTES)\n rc = lib.crypto_core_ed25519_add(r, p, q)\n ensure(rc == 0,\n 'Unexpected library error',\n raising=exc.RuntimeError)\n return ffi.buffer(r, crypto_core_ed25519_BYTES)[:]", "docstring": "Add two points on the edwards25519 curve.\n\n :param p: a :py:data:`.crypto_core_ed25519_BYTES` long bytes sequence\n representing a point on the edwards25519 curve\n :type p: bytes\n :param q: a :py:data:`.crypto_core_ed25519_BYTES` long bytes sequence\n representing a point on the edwards25519 curve\n :type q: bytes\n :return: a point on the edwards25519 curve represented as\n a :py:data:`.crypto_core_ed25519_BYTES` long bytes sequence\n :rtype: bytes" }, { "code": "def run_all(self):\n logger.debug(\"Creating batch session\")\n session = Session()\n for section_id in self.parser.sections():\n self.run_job(section_id, session=session)", "docstring": "Run all the jobs specified in the configuration file." }, { "code": "def is_mastercard(n):\n n, length = str(n), len(str(n))\n if length >= 16 and length <= 19:\n if ''.join(n[:2]) in strings_between(51, 56):\n return True\n return False", "docstring": "Checks if credit card number fits the mastercard format." }, { "code": "def choice(anon, obj, field, val):\n return anon.faker.choice(field=field)", "docstring": "Randomly chooses one of the choices set on the field." }, { "code": "def _param_fields(kwargs, fields):\n if fields is None:\n return\n if type(fields) in [list, set, frozenset, tuple]:\n fields = {x: True for x in fields}\n if type(fields) == dict:\n fields.setdefault(\"_id\", False)\n kwargs[\"projection\"] = fields", "docstring": "Normalize the \"fields\" argument to most find methods" }, { "code": "def partial_normalize(self, axis: AxisIdentifier = 0, inplace: bool = False):\n axis = self._get_axis(axis)\n if not inplace:\n copy = self.copy()\n copy.partial_normalize(axis, inplace=True)\n return copy\n else:\n self._coerce_dtype(float)\n if axis == 0:\n divisor = self._frequencies.sum(axis=0)\n else:\n divisor = self._frequencies.sum(axis=1)[:, np.newaxis]\n divisor[divisor == 0] = 1\n self._frequencies /= divisor\n self._errors2 /= (divisor * divisor)\n return self", "docstring": "Normalize in rows or columns.\n\n Parameters\n ----------\n axis: int or str\n Along which axis to sum (numpy-sense)\n inplace: bool\n Update the object itself\n\n Returns\n -------\n hist : Histogram2D" }, { "code": "def is_element_visible(driver, selector, by=By.CSS_SELECTOR):\n try:\n element = driver.find_element(by=by, value=selector)\n return element.is_displayed()\n except Exception:\n return False", "docstring": "Returns whether the specified element selector is visible on the page.\n @Params\n driver - the webdriver object (required)\n selector - the locator that is used (required)\n by - the method to search for the locator (Default: By.CSS_SELECTOR)\n @Returns\n Boolean (is element visible)" }, { "code": "def unpickler(zone, utcoffset=None, dstoffset=None, tzname=None):\n tz = pytz.timezone(zone)\n if utcoffset is None:\n return tz\n utcoffset = memorized_timedelta(utcoffset)\n dstoffset = memorized_timedelta(dstoffset)\n try:\n return tz._tzinfos[(utcoffset, dstoffset, tzname)]\n except KeyError:\n pass\n for localized_tz in tz._tzinfos.values():\n if (localized_tz._utcoffset == utcoffset\n and localized_tz._dst == dstoffset):\n return localized_tz\n inf = (utcoffset, dstoffset, tzname)\n tz._tzinfos[inf] = tz.__class__(inf, tz._tzinfos)\n return tz._tzinfos[inf]", "docstring": "Factory function for unpickling pytz tzinfo instances.\n\n This is shared for both StaticTzInfo and DstTzInfo instances, because\n database changes could cause a zones implementation to switch between\n these two base classes and we can't break pickles on a pytz version\n upgrade." }, { "code": "def create(self, url):\n bucket, obj_key = _parse_url(url)\n if not bucket:\n raise InvalidURL(url,\n \"You must specify a bucket and (optional) path\")\n if obj_key:\n target = \"/\".join((bucket, obj_key))\n else:\n target = bucket\n return self.call(\"CreateBucket\", bucket=target)", "docstring": "Create a bucket, directory, or empty file." }, { "code": "def _normalize_properties(self, definition):\n args = definition.get('Properties', {}).copy()\n if 'Condition' in definition:\n args.update({'Condition': definition['Condition']})\n if 'UpdatePolicy' in definition:\n args.update({'UpdatePolicy': self._create_instance(\n UpdatePolicy, definition['UpdatePolicy'])})\n if 'CreationPolicy' in definition:\n args.update({'CreationPolicy': self._create_instance(\n CreationPolicy, definition['CreationPolicy'])})\n if 'DeletionPolicy' in definition:\n args.update(\n {'DeletionPolicy': self._convert_definition(\n definition['DeletionPolicy'])})\n if 'Metadata' in definition:\n args.update(\n {'Metadata': self._convert_definition(\n definition['Metadata'])})\n if 'DependsOn' in definition:\n args.update(\n {'DependsOn': self._convert_definition(\n definition['DependsOn'])})\n return args", "docstring": "Inspects the definition and returns a copy of it that is updated\n with any special property such as Condition, UpdatePolicy and the\n like." }, { "code": "def _checksum(self, packet):\n xorsum = 0\n for s in packet:\n xorsum ^= ord(s)\n return xorsum", "docstring": "calculate the XOR checksum of a packet in string format" }, { "code": "def fullversion():\n cmd = 'dnsmasq -v'\n out = __salt__['cmd.run'](cmd).splitlines()\n comps = out[0].split()\n version_num = comps[2]\n comps = out[1].split()\n return {'version': version_num,\n 'compile options': comps[3:]}", "docstring": "Shows installed version of dnsmasq and compile options.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' dnsmasq.fullversion" }, { "code": "def build_sort():\n sorts = request.args.getlist('sort')\n sorts = [sorts] if isinstance(sorts, basestring) else sorts\n sorts = [s.split(' ') for s in sorts]\n return [{SORTS[s]: d} for s, d in sorts if s in SORTS]", "docstring": "Build sort query paramter from kwargs" }, { "code": "def on_idle(self, event):\n self.checkReszie()\n if self.resized:\n self.rescaleX()\n self.calcFontScaling()\n self.calcHorizonPoints()\n self.updateRPYLocations()\n self.updateAARLocations()\n self.adjustPitchmarkers()\n self.adjustHeadingPointer()\n self.adjustNorthPointer()\n self.updateBatteryBar()\n self.updateStateText()\n self.updateWPText()\n self.adjustWPPointer()\n self.updateAltHistory()\n self.canvas.draw()\n self.canvas.Refresh()\n self.resized = False\n time.sleep(0.05)", "docstring": "To adjust text and positions on rescaling the window when resized." }, { "code": "def send_exception_to_sentry(self, exc_info):\n if not self.sentry_client:\n LOGGER.debug('No sentry_client, aborting')\n return\n message = dict(self.active_message)\n try:\n duration = math.ceil(time.time() - self.delivery_time) * 1000\n except TypeError:\n duration = 0\n kwargs = {'extra': {\n 'consumer_name': self.consumer_name,\n 'env': dict(os.environ),\n 'message': message},\n 'time_spent': duration}\n LOGGER.debug('Sending exception to sentry: %r', kwargs)\n self.sentry_client.captureException(exc_info, **kwargs)", "docstring": "Send an exception to Sentry if enabled.\n\n :param tuple exc_info: exception information as returned from\n :func:`sys.exc_info`" }, { "code": "def get_version():\n sys.modules[\"setup_helpers\"] = object()\n sys.modules[\"setup_helpers_macos\"] = object()\n sys.modules[\"setup_helpers_windows\"] = object()\n filename = os.path.join(_ROOT_DIR, \"setup.py\")\n loader = importlib.machinery.SourceFileLoader(\"setup\", filename)\n setup_mod = loader.load_module()\n return setup_mod.VERSION", "docstring": "Get the current version from ``setup.py``.\n\n Assumes that importing ``setup.py`` will have no side-effects (i.e.\n assumes the behavior is guarded by ``if __name__ == \"__main__\"``).\n\n Returns:\n str: The current version in ``setup.py``." }, { "code": "def get_roots(self):\n if self.__directionless:\n sys.stderr.write(\"ERROR: can't get roots of an undirected graph\\n\")\n sys.exit()\n outputids = self.__nodes.keys()\n rootset = set(outputids) - set(self.__child_to_parent.keys())\n return [self.__nodes[x] for x in rootset]", "docstring": "get the roots of a graph. must be a directed graph\n\n :returns: root list of nodes\n :rtype: Node[]" }, { "code": "def _add_q(self, q_object):\n self._criteria = self._criteria._combine(q_object, q_object.connector)", "docstring": "Add a Q-object to the current filter." }, { "code": "def create(cls, name, datacenter, subnet=None, gateway=None,\n background=False):\n if not background and not cls.intty():\n background = True\n datacenter_id_ = int(Datacenter.usable_id(datacenter))\n vlan_params = {\n 'name': name,\n 'datacenter_id': datacenter_id_,\n }\n if subnet:\n vlan_params['subnet'] = subnet\n if gateway:\n vlan_params['gateway'] = gateway\n result = cls.call('hosting.vlan.create', vlan_params)\n if not background:\n cls.echo('Creating your vlan.')\n cls.display_progress(result)\n cls.echo('Your vlan %s has been created.' % name)\n return result", "docstring": "Create a new vlan." }, { "code": "def params(self, dict):\n self._configuration.update(dict)\n self._measurements.update()", "docstring": "Set configuration variables for an OnShape part." }, { "code": "def encode(self, obj):\n try:\n result = json.dumps(obj, sort_keys=True, indent=None,\n separators=(',', ':'), ensure_ascii=False)\n if isinstance(result, six.text_type):\n return result.encode(\"utf-8\")\n else:\n return result\n except (UnicodeEncodeError, TypeError) as error:\n raise exceptions.EncodingError('json', error)", "docstring": "Returns ``obj`` serialized as JSON formatted bytes.\n\n Raises\n ------\n ~ipfsapi.exceptions.EncodingError\n\n Parameters\n ----------\n obj : str | list | dict | int\n JSON serializable Python object\n\n Returns\n -------\n bytes" }, { "code": "def streamDefByThreshold(self,\n stream_raster_grid,\n threshold,\n contributing_area_grid,\n mask_grid=None,\n ):\n log(\"PROCESS: StreamDefByThreshold\")\n self.stream_raster_grid = stream_raster_grid\n cmd = [os.path.join(self.taudem_exe_path, 'threshold'),\n '-ssa', contributing_area_grid,\n '-src', self.stream_raster_grid,\n '-thresh', str(threshold),\n ]\n if mask_grid:\n cmd += ['-mask', mask_grid]\n self._run_mpi_cmd(cmd)\n self._add_prj_file(contributing_area_grid,\n self.stream_raster_grid)", "docstring": "Calculates the stream definition by threshold." }, { "code": "def run(self):\n context = zmq.Context()\n socket = context.socket(zmq.PUB)\n socket.setsockopt(zmq.LINGER, 100)\n socket.bind('ipc://' + self.timer_sock)\n count = 0\n log.debug('ConCache-Timer started')\n while not self.stopped.wait(1):\n socket.send(self.serial.dumps(count))\n count += 1\n if count >= 60:\n count = 0", "docstring": "main loop that fires the event every second" }, { "code": "def api_post(self, action, data, binary_data_param=None):\n binary_data_param = binary_data_param or []\n if binary_data_param:\n return self.api_post_multipart(action, data, binary_data_param)\n else:\n return self._api_request(action, data, 'POST')", "docstring": "Perform an HTTP POST request, using the shared-secret auth hash.\n @param action: API action call\n @param data: dictionary values" }, { "code": "def remove_token(self, token_stack, token):\n token_stack.reverse()\n try:\n token_stack.remove(token)\n retval = True\n except ValueError:\n retval = False\n token_stack.reverse()\n return retval", "docstring": "Remove last occurance of token from stack" }, { "code": "def select_sample(in_file, sample, out_file, config, filters=None):\n if not utils.file_exists(out_file):\n with file_transaction(config, out_file) as tx_out_file:\n if len(get_samples(in_file)) == 1:\n shutil.copy(in_file, tx_out_file)\n else:\n if in_file.endswith(\".gz\"):\n bgzip_and_index(in_file, config)\n bcftools = config_utils.get_program(\"bcftools\", config)\n output_type = \"z\" if out_file.endswith(\".gz\") else \"v\"\n filter_str = \"-f %s\" % filters if filters is not None else \"\"\n cmd = \"{bcftools} view -O {output_type} {filter_str} {in_file} -s {sample} > {tx_out_file}\"\n do.run(cmd.format(**locals()), \"Select sample: %s\" % sample)\n if out_file.endswith(\".gz\"):\n bgzip_and_index(out_file, config)\n return out_file", "docstring": "Select a single sample from the supplied multisample VCF file." }, { "code": "def set_pixel(framebuf, x, y, color):\n index = (y >> 3) * framebuf.stride + x\n offset = y & 0x07\n framebuf.buf[index] = (framebuf.buf[index] & ~(0x01 << offset)) | ((color != 0) << offset)", "docstring": "Set a given pixel to a color." }, { "code": "def get_client(host, userid, password, port=443, auth_method='basic',\n client_timeout=60, **kwargs):\n return functools.partial(scci_cmd, host, userid, password,\n port=port, auth_method=auth_method,\n client_timeout=client_timeout, **kwargs)", "docstring": "get SCCI command partial function\n\n This function returns SCCI command partial function\n :param host: hostname or IP of iRMC\n :param userid: userid for iRMC with administrator privileges\n :param password: password for userid\n :param port: port number of iRMC\n :param auth_method: irmc_username\n :param client_timeout: timeout for SCCI operations\n :returns: scci_cmd partial function which takes a SCCI command param" }, { "code": "def compile_file(self, filename, encoding=\"utf-8\", bare=False):\n if isinstance(filename, _BaseString):\n filename = [filename]\n scripts = []\n for f in filename:\n with io.open(f, encoding=encoding) as fp:\n scripts.append(fp.read())\n return self.compile('\\n\\n'.join(scripts), bare=bare)", "docstring": "compile a CoffeeScript script file to a JavaScript code.\n\n filename can be a list or tuple of filenames,\n then contents of files are concatenated with line feeds.\n\n if bare is True, then compile the JavaScript without the top-level\n function safety wrapper (like the coffee command)." }, { "code": "def meet(self, featuresets):\n concepts = (f.concept for f in featuresets)\n meet = self.lattice.meet(concepts)\n return self._featuresets[meet.index]", "docstring": "Return the nearest featureset that implies all given ones." }, { "code": "async def handle_request(self, request):\n service_name = request.rel_url.query['servicename']\n received_code = request.rel_url.query['pairingcode'].lower()\n _LOGGER.info('Got pairing request from %s with code %s',\n service_name, received_code)\n if self._verify_pin(received_code):\n cmpg = tags.uint64_tag('cmpg', int(self._pairing_guid, 16))\n cmnm = tags.string_tag('cmnm', self._name)\n cmty = tags.string_tag('cmty', 'iPhone')\n response = tags.container_tag('cmpa', cmpg + cmnm + cmty)\n self._has_paired = True\n return web.Response(body=response)\n return web.Response(status=500)", "docstring": "Respond to request if PIN is correct." }, { "code": "def from_file(cls, file_path: Path, w3: Web3) -> \"Package\":\n if isinstance(file_path, Path):\n raw_manifest = file_path.read_text()\n validate_raw_manifest_format(raw_manifest)\n manifest = json.loads(raw_manifest)\n else:\n raise TypeError(\n \"The Package.from_file method expects a pathlib.Path instance.\"\n f\"Got {type(file_path)} instead.\"\n )\n return cls(manifest, w3, file_path.as_uri())", "docstring": "Returns a ``Package`` instantiated by a manifest located at the provided Path.\n ``file_path`` arg must be a ``pathlib.Path`` instance.\n A valid ``Web3`` instance is required to instantiate a ``Package``." }, { "code": "def _parse_path_table(self, ptr_size, extent):\n self._seek_to_extent(extent)\n data = self._cdfp.read(ptr_size)\n offset = 0\n out = []\n extent_to_ptr = {}\n while offset < ptr_size:\n ptr = path_table_record.PathTableRecord()\n len_di_byte = bytearray([data[offset]])[0]\n read_len = path_table_record.PathTableRecord.record_length(len_di_byte)\n ptr.parse(data[offset:offset + read_len])\n out.append(ptr)\n extent_to_ptr[ptr.extent_location] = ptr\n offset += read_len\n return out, extent_to_ptr", "docstring": "An internal method to parse a path table on an ISO. For each path\n table entry found, a Path Table Record object is created, and the\n callback is called.\n\n Parameters:\n vd - The volume descriptor that these path table records correspond to.\n extent - The extent at which this path table record starts.\n callback - The callback to call for each path table record.\n Returns:\n A tuple consisting of the list of path table record entries and a\n dictionary of the extent locations to the path table record entries." }, { "code": "def _get_whitelist_licenses(config_path):\n whitelist_licenses = []\n try:\n print('config path', config_path)\n with open(config_path) as config:\n whitelist_licenses = [line.rstrip() for line in config]\n except IOError:\n print('Warning: No {} file was found.'.format(LICENSE_CHECKER_CONFIG_NAME))\n return whitelist_licenses", "docstring": "Get whitelist license names from config file.\n\n :param config_path: str\n :return: list" }, { "code": "def _get_type_hints(func, args = None, res = None, infer_defaults = None):\n if args is None or res is None:\n args2, res2 = _get_types(func, util.is_classmethod(func),\n util.is_method(func), unspecified_type = type(NotImplemented),\n infer_defaults = infer_defaults)\n if args is None:\n args = args2\n if res is None:\n res = res2\n slf = 1 if util.is_method(func) else 0\n argNames = util.getargnames(util.getargspecs(util._actualfunc(func)))\n result = {}\n if not args is Any:\n prms = get_Tuple_params(args)\n for i in range(slf, len(argNames)):\n if not prms[i-slf] is type(NotImplemented):\n result[argNames[i]] = prms[i-slf]\n result['return'] = res\n return result", "docstring": "Helper for get_type_hints." }, { "code": "def add_fs(self, name, fs, write=False, priority=0):\n if isinstance(fs, text_type):\n fs = open_fs(fs)\n if not isinstance(fs, FS):\n raise TypeError(\"fs argument should be an FS object or FS URL\")\n self._filesystems[name] = _PrioritizedFS(\n priority=(priority, self._sort_index), fs=fs\n )\n self._sort_index += 1\n self._resort()\n if write:\n self.write_fs = fs\n self._write_fs_name = name", "docstring": "Add a filesystem to the MultiFS.\n\n Arguments:\n name (str): A unique name to refer to the filesystem being\n added.\n fs (FS or str): The filesystem (instance or URL) to add.\n write (bool): If this value is True, then the ``fs`` will\n be used as the writeable FS (defaults to False).\n priority (int): An integer that denotes the priority of the\n filesystem being added. Filesystems will be searched in\n descending priority order and then by the reverse order\n they were added. So by default, the most recently added\n filesystem will be looked at first." }, { "code": "def add_time(self, extra_time):\n window_start = self.parent.value('window_start') + extra_time\n self.parent.overview.update_position(window_start)", "docstring": "Go to the predefined time forward." }, { "code": "def update_workspace_acl(namespace, workspace, acl_updates, invite_users_not_found=False):\n uri = \"{0}workspaces/{1}/{2}/acl?inviteUsersNotFound={3}\".format(fcconfig.root_url,\n namespace, workspace, str(invite_users_not_found).lower())\n headers = _fiss_agent_header({\"Content-type\": \"application/json\"})\n return __SESSION.patch(uri, headers=headers, data=json.dumps(acl_updates))", "docstring": "Update workspace access control list.\n\n Args:\n namespace (str): project to which workspace belongs\n workspace (str): Workspace name\n acl_updates (list(dict)): Acl updates as dicts with two keys:\n \"email\" - Firecloud user email\n \"accessLevel\" - one of \"OWNER\", \"READER\", \"WRITER\", \"NO ACCESS\"\n Example: {\"email\":\"user1@mail.com\", \"accessLevel\":\"WRITER\"}\n invite_users_not_found (bool): true to invite unregistered users, false to ignore\n\n Swagger:\n https://api.firecloud.org/#!/Workspaces/updateWorkspaceACL" }, { "code": "def check_file(self, fs, info):\n if self.exclude is not None and fs.match(self.exclude, info.name):\n return False\n return fs.match(self.filter, info.name)", "docstring": "Check if a filename should be included.\n\n Override to exclude files from the walk.\n\n Arguments:\n fs (FS): A filesystem instance.\n info (Info): A resource info object.\n\n Returns:\n bool: `True` if the file should be included." }, { "code": "def evaluator(evaluate):\n @functools.wraps(evaluate)\n def inspyred_evaluator(candidates, args):\n fitness = []\n for candidate in candidates:\n fitness.append(evaluate(candidate, args))\n return fitness\n inspyred_evaluator.single_evaluation = evaluate\n return inspyred_evaluator", "docstring": "Return an inspyred evaluator function based on the given function.\n \n This function generator takes a function that evaluates only one\n candidate. The generator handles the iteration over each candidate \n to be evaluated.\n\n The given function ``evaluate`` must have the following signature::\n \n fitness = evaluate(candidate, args)\n \n This function is most commonly used as a function decorator with\n the following usage::\n \n @evaluator\n def evaluate(candidate, args):\n # Implementation of evaluation\n pass\n \n The generated function also contains an attribute named\n ``single_evaluation`` which holds the original evaluation function.\n In this way, the original single-candidate function can be\n retrieved if necessary." }, { "code": "def _tm(self, theta, phi, psi, dx, dy, dz):\n matrix = self.get_matrix(theta, phi, psi, dx, dy, dz)\n coord = matrix.dot(self.coord2)\n dist = coord - self.coord1\n d_i2 = (dist * dist).sum(axis=0)\n tm = -(1 / (1 + (d_i2 / self.d02)))\n return tm", "docstring": "Compute the minimisation target, not normalised." }, { "code": "def download(cls, url, filename=None):\n return utility.download(url, cls.directory(), filename)", "docstring": "Download a file into the correct cache directory." }, { "code": "def encrypt_data(self, name, plaintext, context=\"\", key_version=0, nonce=None, batch_input=None, type=\"aes256-gcm96\",\n convergent_encryption=\"\", mount_point=DEFAULT_MOUNT_POINT):\n params = {\n 'plaintext': plaintext,\n 'context': context,\n 'key_version': key_version,\n 'nonce': nonce,\n 'batch_input': batch_input,\n 'type': type,\n 'convergent_encryption': convergent_encryption,\n }\n api_path = '/v1/{mount_point}/encrypt/{name}'.format(\n mount_point=mount_point,\n name=name,\n )\n response = self._adapter.post(\n url=api_path,\n json=params,\n )\n return response.json()", "docstring": "Encrypt the provided plaintext using the named key.\n\n This path supports the create and update policy capabilities as follows: if the user has the create capability\n for this endpoint in their policies, and the key does not exist, it will be upserted with default values\n (whether the key requires derivation depends on whether the context parameter is empty or not). If the user only\n has update capability and the key does not exist, an error will be returned.\n\n Supported methods:\n POST: /{mount_point}/encrypt/{name}. Produces: 200 application/json\n\n :param name: Specifies the name of the encryption key to encrypt against. This is specified as part of the URL.\n :type name: str | unicode\n :param plaintext: Specifies base64 encoded plaintext to be encoded.\n :type plaintext: str | unicode\n :param context: Specifies the base64 encoded context for key derivation. This is required if key derivation is\n enabled for this key.\n :type context: str | unicode\n :param key_version: Specifies the version of the key to use for encryption. If not set, uses the latest version.\n Must be greater than or equal to the key's min_encryption_version, if set.\n :type key_version: int\n :param nonce: Specifies the base64 encoded nonce value. This must be provided if convergent encryption is\n enabled for this key and the key was generated with Vault 0.6.1. Not required for keys created in 0.6.2+.\n The value must be exactly 96 bits (12 bytes) long and the user must ensure that for any given context (and\n thus, any given encryption key) this nonce value is never reused.\n :type nonce: str | unicode\n :param batch_input: Specifies a list of items to be encrypted in a single batch. When this parameter is set, if\n the parameters 'plaintext', 'context' and 'nonce' are also set, they will be ignored. The format for the\n input is: [dict(context=\"b64_context\", plaintext=\"b64_plaintext\"), ...]\n :type batch_input: List[dict]\n :param type: This parameter is required when encryption key is expected to be created. When performing an\n upsert operation, the type of key to create.\n :type type: str | unicode\n :param convergent_encryption: This parameter will only be used when a key is expected to be created. Whether to\n support convergent encryption. This is only supported when using a key with key derivation enabled and will\n require all requests to carry both a context and 96-bit (12-byte) nonce. The given nonce will be used in\n place of a randomly generated nonce. As a result, when the same context and nonce are supplied, the same\n ciphertext is generated. It is very important when using this mode that you ensure that all nonces are\n unique for a given context. Failing to do so will severely impact the ciphertext's security.\n :type convergent_encryption: str | unicode\n :param mount_point: The \"path\" the method/backend was mounted on.\n :type mount_point: str | unicode\n :return: The JSON response of the request.\n :rtype: requests.Response" }, { "code": "def create_response(request, body=None, status=None, headers=None):\n if body is None:\n return HttpResponse(None, status or HTTPStatus.NO_CONTENT, headers)\n else:\n body = request.response_codec.dumps(body)\n response = HttpResponse(body, status or HTTPStatus.OK, headers)\n response.set_content_type(request.response_codec.CONTENT_TYPE)\n return response", "docstring": "Generate a HttpResponse.\n\n :param request: Request object\n :param body: Body of the response\n :param status: HTTP status code\n :param headers: Any headers." }, { "code": "def zremrangebyscore(self, key, min_score, max_score):\n return self._execute([b'ZREMRANGEBYSCORE', key, min_score, max_score])", "docstring": "Removes all elements in the sorted set stored at key with a score\n between min and max.\n\n Intervals are described in :meth:`~tredis.RedisClient.zrangebyscore`.\n\n Returns the number of elements removed.\n\n .. note::\n\n **Time complexity**: ``O(log(N)+M)`` with ``N`` being the number of\n elements in the sorted set and M the number of elements removed by\n the operation.\n\n :param key: The key of the sorted set\n :type key: :class:`str`, :class:`bytes`\n :param min_score: Lowest score definition\n :type min_score: :class:`str`, :class:`bytes`\n :param max_score: Highest score definition\n :type max_score: :class:`str`, :class:`bytes`\n :rtype: int\n :raises: :exc:`~tredis.exceptions.RedisError`" }, { "code": "def add_tag_for_component(user, c_id):\n v1_utils.verify_existence_and_get(c_id, _TABLE)\n values = {\n 'component_id': c_id\n }\n component_tagged = tags.add_tag_to_resource(values,\n models.JOIN_COMPONENTS_TAGS)\n return flask.Response(json.dumps(component_tagged), 201,\n content_type='application/json')", "docstring": "Add a tag on a specific component." }, { "code": "def triangle_center(tri, uv=False):\n if uv:\n data = [t.uv for t in tri]\n mid = [0.0, 0.0]\n else:\n data = tri.vertices\n mid = [0.0, 0.0, 0.0]\n for vert in data:\n mid = [m + v for m, v in zip(mid, vert)]\n mid = [float(m) / 3.0 for m in mid]\n return tuple(mid)", "docstring": "Computes the center of mass of the input triangle.\n\n :param tri: triangle object\n :type tri: elements.Triangle\n :param uv: if True, then finds parametric position of the center of mass\n :type uv: bool\n :return: center of mass of the triangle\n :rtype: tuple" }, { "code": "def writeinfo(self, linelist, colour = None):\n self.checkforpilimage()\n colour = self.defaultcolour(colour)\n self.changecolourmode(colour)\n self.makedraw()\n self.loadinfofont()\n for i, line in enumerate(linelist):\n topspacing = 5 + (12 + 5)*i\n self.draw.text((10, topspacing), line, fill = colour, font = self.infofont)\n if self.verbose :\n print \"I've written some info on the image.\"", "docstring": "We add a longer chunk of text on the upper left corner of the image.\n Provide linelist, a list of strings that will be written one below the other." }, { "code": "def __connect(self, wsURL, symbol):\n self.logger.debug(\"Starting thread\")\n self.ws = websocket.WebSocketApp(wsURL,\n on_message=self.__on_message,\n on_close=self.__on_close,\n on_open=self.__on_open,\n on_error=self.__on_error,\n header=self.__get_auth())\n self.wst = threading.Thread(target=lambda: self.ws.run_forever())\n self.wst.daemon = True\n self.wst.start()\n self.logger.debug(\"Started thread\")\n conn_timeout = 5\n while not self.ws.sock or not self.ws.sock.connected and conn_timeout:\n sleep(1)\n conn_timeout -= 1\n if not conn_timeout:\n self.logger.error(\"Couldn't connect to WS! Exiting.\")\n self.exit()\n sys.exit(1)", "docstring": "Connect to the websocket in a thread." }, { "code": "def pipes(stream, *transformers):\n for transformer in transformers:\n stream = stream.pipe(transformer)\n return stream", "docstring": "Pipe several transformers end to end." }, { "code": "def mongo_retry(f):\n log_all_exceptions = 'arctic' in f.__module__ if f.__module__ else False\n @wraps(f)\n def f_retry(*args, **kwargs):\n global _retry_count, _in_retry\n top_level = not _in_retry\n _in_retry = True\n try:\n while True:\n try:\n return f(*args, **kwargs)\n except (DuplicateKeyError, ServerSelectionTimeoutError) as e:\n _handle_error(f, e, _retry_count, **_get_host(args))\n raise\n except (OperationFailure, AutoReconnect) as e:\n _retry_count += 1\n _handle_error(f, e, _retry_count, **_get_host(args))\n except Exception as e:\n if log_all_exceptions:\n _log_exception(f.__name__, e, _retry_count, **_get_host(args))\n raise\n finally:\n if top_level:\n _in_retry = False\n _retry_count = 0\n return f_retry", "docstring": "Catch-all decorator that handles AutoReconnect and OperationFailure\n errors from PyMongo" }, { "code": "def cmd_create(args):\n if args.type == SQLITE:\n if args.output is not None and path.exists(args.output):\n remove(args.output)\n storage = SqliteStorage(db=args.output, settings=args.settings)\n else:\n storage = JsonStorage(settings=args.settings)\n markov = MarkovText.from_storage(storage)\n read(args.input, markov, args.progress)\n save(markov, args.output, args)", "docstring": "Create a generator.\n\n Parameters\n ----------\n args : `argparse.Namespace`\n Command arguments." }, { "code": "def create_policy(policyName, policyDocument,\n region=None, key=None, keyid=None, profile=None):\n try:\n conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)\n if not isinstance(policyDocument, string_types):\n policyDocument = salt.utils.json.dumps(policyDocument)\n policy = conn.create_policy(policyName=policyName,\n policyDocument=policyDocument)\n if policy:\n log.info('The newly created policy version is %s', policy['policyVersionId'])\n return {'created': True, 'versionId': policy['policyVersionId']}\n else:\n log.warning('Policy was not created')\n return {'created': False}\n except ClientError as e:\n return {'created': False, 'error': __utils__['boto3.get_error'](e)}", "docstring": "Given a valid config, create a policy.\n\n Returns {created: true} if the policy was created and returns\n {created: False} if the policy was not created.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt myminion boto_iot.create_policy my_policy \\\\\n '{\"Version\":\"2015-12-12\",\\\\\n \"Statement\":[{\"Effect\":\"Allow\",\\\\\n \"Action\":[\"iot:Publish\"],\\\\\n \"Resource\":[\"arn:::::topic/foo/bar\"]}]}'" }, { "code": "def get_bounds(pts):\n pts_t = np.asarray(pts).T\n return np.asarray(([np.min(_pts) for _pts in pts_t],\n [np.max(_pts) for _pts in pts_t]))", "docstring": "Return the minimum point and maximum point bounding a\n set of points." }, { "code": "def http_get(url, filename=None):\n try:\n ret = requests.get(url)\n except requests.exceptions.SSLError as error:\n _LOGGER.error(error)\n return False\n if ret.status_code != 200:\n return False\n if filename is None:\n return ret.content\n with open(filename, 'wb') as data:\n data.write(ret.content)\n return True", "docstring": "Download HTTP data." }, { "code": "def job_started_message(self, job, queue):\n return '[%s|%s|%s] starting' % (queue._cached_name, job.pk.get(),\n job._cached_identifier)", "docstring": "Return the message to log just befre the execution of the job" }, { "code": "def _deserialize(self, value, attr, data):\n if not self.context.get('convert_dates', True) or not value:\n return value\n value = super(ArrowField, self)._deserialize(value, attr, data)\n timezone = self.get_field_value('timezone')\n target = arrow.get(value)\n if timezone and text_type(target.to(timezone)) != text_type(target):\n raise ValidationError(\n \"The provided datetime is not in the \"\n \"{} timezone.\".format(timezone)\n )\n return target", "docstring": "Deserializes a string into an Arrow object." }, { "code": "def make_response(message, status_code, details=None):\n response_body = dict(message=message)\n if details:\n response_body['details'] = details\n response = jsonify(response_body)\n response.status_code = status_code\n return response", "docstring": "Make a jsonified response with specified message and status code." }, { "code": "def pack(self):\n if six.PY3:\n return {'message': six.text_type(self), 'args': self.args}\n return dict(message=self.__unicode__(), args=self.args)", "docstring": "Pack this exception into a serializable dictionary that is safe for\n transport via msgpack" }, { "code": "def disable_logger(self, disabled=True):\n if disabled:\n sys.stdout = _original_stdout\n sys.stderr = _original_stderr\n else:\n sys.stdout = self.__stdout_stream\n sys.stderr = self.__stderr_stream\n self.logger.disabled = disabled", "docstring": "Disable all logging calls." }, { "code": "def bin(x, bins, maxX=None, minX=None):\n if maxX is None:\n maxX = x.max()\n if minX is None:\n minX = x.min()\n if not np.iterable(bins):\n bins = np.linspace(minX, maxX+1e-5, bins+1)\n return np.digitize(x.ravel(), bins).reshape(x.shape), bins", "docstring": "bin signal x using 'binsN' bin. If minX, maxX are None, they default to the full\n range of the signal. If they are not None, everything above maxX gets assigned to\n binsN-1 and everything below minX gets assigned to 0, this is effectively the same\n as clipping x before passing it to 'bin'\n\n input:\n -----\n x: signal to be binned, some sort of iterable\n\n bins: int, number of bins\n iterable, bin edges\n\n maxX: clips data above maxX\n\n minX: clips data below maxX\n\n output:\n ------\n binnedX: x after being binned\n\n bins: bins used for binning.\n if input 'bins' is already an iterable it just returns the\n same iterable\n\n example:\n # make 10 bins of equal length spanning from x.min() to x.max()\n bin(x, 10)\n\n # use predefined bins such that each bin has the same number of points (maximize\n entropy)\n binsN = 10\n percentiles = list(np.arange(0, 100.1, 100/binsN))\n bins = np.percentile(x, percentiles)\n bin(x, bins)" }, { "code": "def set_execution_mode(self, execution_mode, notify=True):\n if not isinstance(execution_mode, StateMachineExecutionStatus):\n raise TypeError(\"status must be of type StateMachineExecutionStatus\")\n self._status.execution_mode = execution_mode\n if notify:\n self._status.execution_condition_variable.acquire()\n self._status.execution_condition_variable.notify_all()\n self._status.execution_condition_variable.release()", "docstring": "An observed setter for the execution mode of the state machine status. This is necessary for the\n monitoring client to update the local state machine in the same way as the root state machine of the server.\n\n :param execution_mode: the new execution mode of the state machine\n :raises exceptions.TypeError: if the execution mode is of the wrong type" }, { "code": "def print_dedicated_access(access):\n table = formatting.Table(['id', 'Name', 'Cpus', 'Memory', 'Disk', 'Created'], 'Dedicated Access')\n for host in access:\n host_id = host.get('id')\n host_fqdn = host.get('name')\n host_cpu = host.get('cpuCount')\n host_mem = host.get('memoryCapacity')\n host_disk = host.get('diskCapacity')\n host_created = host.get('createDate')\n table.add_row([host_id, host_fqdn, host_cpu, host_mem, host_disk, host_created])\n return table", "docstring": "Prints out the dedicated hosts a user can access" }, { "code": "def get_hyperedge_id(self, tail, head):\n frozen_tail = frozenset(tail)\n frozen_head = frozenset(head)\n if not self.has_hyperedge(frozen_tail, frozen_head):\n raise ValueError(\"No such hyperedge exists.\")\n return self._successors[frozen_tail][frozen_head]", "docstring": "From a tail and head set of nodes, returns the ID of the hyperedge\n that these sets comprise.\n\n :param tail: iterable container of references to nodes in the\n tail of the hyperedge to be added\n :param head: iterable container of references to nodes in the\n head of the hyperedge to be added\n :returns: str -- ID of the hyperedge that has that the specified\n tail and head sets comprise.\n :raises: ValueError -- No such hyperedge exists.\n\n Examples:\n ::\n\n >>> H = DirectedHypergraph()\n >>> hyperedge_list = ([\"A\"], [\"B\", \"C\"]),\n ((\"A\", \"B\"), (\"C\"), {weight: 2}),\n (set([\"B\"]), set([\"A\", \"C\"])))\n >>> hyperedge_ids = H.add_hyperedges(hyperedge_list)\n >>> x = H.get_hyperedge_id([\"A\"], [\"B\", \"C\"])" }, { "code": "def validate_date(date, project_member_id, filename):\n try:\n arrow.get(date)\n except Exception:\n return False\n return True", "docstring": "Check if date is in ISO 8601 format.\n\n :param date: This field is the date to be checked.\n :param project_member_id: This field is the project_member_id corresponding\n to the date provided.\n :param filename: This field is the filename corresponding to the date\n provided." }, { "code": "def unbounded(self):\n self._check_valid()\n return (self._problem._p.get_status() ==\n qsoptex.SolutionStatus.UNBOUNDED)", "docstring": "Whether the solution is unbounded" }, { "code": "def list_networks(kwargs=None, call=None):\n if call != 'function':\n raise SaltCloudSystemExit(\n 'The list_networks function must be called with '\n '-f or --function.'\n )\n return {'Networks': salt.utils.vmware.list_networks(_get_si())}", "docstring": "List all the standard networks for this VMware environment\n\n CLI Example:\n\n .. code-block:: bash\n\n salt-cloud -f list_networks my-vmware-config" }, { "code": "def schedule_violations(schedule, events, slots):\n array = converter.schedule_to_array(schedule, events, slots)\n return array_violations(array, events, slots)", "docstring": "Take a schedule and return a list of violated constraints\n\n Parameters\n ----------\n schedule : list or tuple\n a schedule in schedule form\n events : list or tuple\n of resources.Event instances\n slots : list or tuple\n of resources.Slot instances\n\n Returns\n -------\n Generator\n of a list of strings indicating the nature of the violated\n constraints" }, { "code": "def clear(self):\n self._level = None\n self._fingerprint = None\n self._transaction = None\n self._user = None\n self._tags = {}\n self._contexts = {}\n self._extras = {}\n self.clear_breadcrumbs()\n self._should_capture = True\n self._span = None", "docstring": "Clears the entire scope." }, { "code": "def build_command(self, config, **kwargs):\n command = ['perl', self.script, CLI_OPTIONS['config']['option'], config]\n for key, value in kwargs.items():\n if value:\n command.append(CLI_OPTIONS[key]['option'])\n if value is True:\n command.append(CLI_OPTIONS[key].get('default', '1'))\n else:\n command.append(value)\n return command", "docstring": "Builds the command to execute MIP." }, { "code": "def relabel_squeeze(data):\n palette, index = np.unique(data, return_inverse=True)\n data = index.reshape(data.shape)\n return data", "docstring": "Makes relabeling of data if there are unused values." }, { "code": "def _get_recipients(self, array):\n for address, name in array:\n if not name:\n yield address\n else:\n yield \"\\\"%s\\\" <%s>\" % (name, address)", "docstring": "Returns an iterator of objects\n in the form [\"Name 15:\n self.login_date = now\n if self.dirty:\n store = goldman.sess.store\n store.update(self)", "docstring": "Update the login_date timestamp\n\n Initialize the thread local sess.login property with\n the authenticated login model.\n\n The login_date update will be debounced so writes don't\n occur on every hit of the the API. If the login_date\n was modified within 15 minutes then don't update it." }, { "code": "def format_style(number: int) -> str:\n if str(number) not in _stylenums:\n raise InvalidStyle(number)\n return codeformat(number)", "docstring": "Return an escape code for a style, by number.\n This handles invalid style numbers." }, { "code": "def generate_output_path(args, project_path):\n milisec = datetime.now().microsecond\n dirname = 'results_{}_{}'.format(time.strftime('%Y.%m.%d_%H.%M.%S', time.localtime()), str(milisec))\n return os.path.join(project_path, 'results', dirname)", "docstring": "Generate default output directory" }, { "code": "def ec_construct_private(num):\n pub_ecpn = ec.EllipticCurvePublicNumbers(num['x'], num['y'],\n NIST2SEC[as_unicode(num['crv'])]())\n priv_ecpn = ec.EllipticCurvePrivateNumbers(num['d'], pub_ecpn)\n return priv_ecpn.private_key(default_backend())", "docstring": "Given a set of values on public and private attributes build a elliptic\n curve private key instance.\n\n :param num: A dictionary with public and private attributes and their values\n :return: A\n cryptography.hazmat.primitives.asymmetric.ec.EllipticCurvePrivateKey\n instance." }, { "code": "def _pickle_batch(self):\n payload = pickle.dumps(self.batch)\n header = struct.pack(\"!L\", len(payload))\n message = header + payload\n return message", "docstring": "Pickle the metrics into a form that can be understood\n by the graphite pickle connector." }, { "code": "def on_message(self, handler, msg):\n if self.remote_debugging:\n for h in self.handlers:\n if h != handler:\n h.write_message(msg, True)\n else:\n print(msg)", "docstring": "In remote debugging mode this simply acts as a forwarding\n proxy for the two clients." }, { "code": "def update_many(cls, filter, update, upsert=False):\n return cls.collection.update_many(filter, update, upsert).raw_result", "docstring": "Updates all documents that pass the filter with the update value\n Will upsert a new document if upsert=True and no document is filtered" }, { "code": "async def _register(self):\n if self.registered:\n return\n self._registration_attempts += 1\n self.connection.throttle = False\n if self.password:\n await self.rawmsg('PASS', self.password)\n await self.set_nickname(self._attempt_nicknames.pop(0))\n await self.rawmsg('USER', self.username, '0', '*', self.realname)", "docstring": "Perform IRC connection registration." }, { "code": "def DropConnection(self, connection):\n try:\n connection.cursor.close()\n except MySQLdb.Error:\n pass\n try:\n connection.dbh.close()\n except MySQLdb.Error:\n pass", "docstring": "Attempt to cleanly drop the connection." }, { "code": "def check_conditions(f, args, kwargs):\n member_function = is_member_function(f)\n check_preconditions(f, args, kwargs)\n base_classes = []\n if member_function:\n base_classes = inspect.getmro(type(args[0]))[1:-1]\n for clz in base_classes:\n super_fn = getattr(clz, f.func_name, None)\n check_preconditions(super_fn, args, kwargs)\n return_value = f(*args, **kwargs)\n check_postconditions(f, return_value)\n if member_function:\n for clz in base_classes:\n super_fn = getattr(clz, f.func_name, None)\n check_postconditions(super_fn, return_value)\n return return_value", "docstring": "This is what runs all of the conditions attached to a method,\n along with the conditions on the superclasses." }, { "code": "def shutdown(self):\n if self.lifecycle.is_live:\n self.lifecycle.fire_lifecycle_event(LIFECYCLE_STATE_SHUTTING_DOWN)\n self.near_cache_manager.destroy_all_near_caches()\n self.statistics.shutdown()\n self.partition_service.shutdown()\n self.heartbeat.shutdown()\n self.cluster.shutdown()\n self.reactor.shutdown()\n self.lifecycle.fire_lifecycle_event(LIFECYCLE_STATE_SHUTDOWN)\n self.logger.info(\"Client shutdown.\", extra=self._logger_extras)", "docstring": "Shuts down this HazelcastClient." }, { "code": "def size(self):\n if self.children:\n return sum( ( c.size() for c in self.children.values() ) ) + 1\n else:\n return 1", "docstring": "Size is number of nodes under the trie, including the current node" }, { "code": "def rewrite_references_json(json_content, rewrite_json):\n for ref in json_content:\n if ref.get(\"id\") and ref.get(\"id\") in rewrite_json:\n for key, value in iteritems(rewrite_json.get(ref.get(\"id\"))):\n ref[key] = value\n return json_content", "docstring": "general purpose references json rewriting by matching the id value" }, { "code": "def correct_rytov_output(radius, sphere_index, medium_index, radius_sampling):\n r\n params = get_params(radius_sampling)\n x = sphere_index / medium_index - 1\n radius_sc = radius * (params[\"ra\"] * x**2\n + params[\"rb\"] * x\n + params[\"rc\"])\n sphere_index_sc = sphere_index + medium_index * (params[\"na\"] * x**2\n + params[\"nb\"] * x)\n return radius_sc, sphere_index_sc", "docstring": "r\"\"\"Error-correction of refractive index and radius for Rytov\n\n This method corrects the fitting results for `radius`\n :math:`r_\\text{Ryt}` and `sphere_index` :math:`n_\\text{Ryt}`\n obtained using :func:`qpsphere.models.rytov` using\n the approach described in :cite:`Mueller2018` (eqns. 3,4, and 5).\n\n .. math::\n\n n_\\text{Ryt-SC} &= n_\\text{Ryt} + n_\\text{med} \\cdot\n \\left( a_n x^2 + b_n x + c_n \\right)\n\n r_\\text{Ryt-SC} &= r_\\text{Ryt} \\cdot\n \\left( a_r x^2 +b_r x + c_r \\right)\n\n &\\text{with} x = \\frac{n_\\text{Ryt}}{n_\\text{med}} - 1\n\n The correction factors are given in\n :data:`qpsphere.models.mod_rytov_sc.RSC_PARAMS`.\n\n Parameters\n ----------\n radius: float\n Fitted radius of the sphere :math:`r_\\text{Ryt}` [m]\n sphere_index: float\n Fitted refractive index of the sphere :math:`n_\\text{Ryt}`\n medium_index: float\n Refractive index of the surrounding medium :math:`n_\\text{med}`\n radius_sampling: int\n Number of pixels used to sample the sphere radius when\n computing the Rytov field.\n\n Returns\n -------\n radius_sc: float\n Systematically corrected radius of the sphere\n :math:`r_\\text{Ryt-SC}` [m]\n sphere_index_sc: float\n Systematically corrected refractive index of the sphere\n :math:`n_\\text{Ryt-SC}`\n\n See Also\n --------\n correct_rytov_sc_input: the inverse of this method" }, { "code": "def complete_worker(self, text, line, begidx, endidx):\n return [i for i in PsiturkNetworkShell.worker_commands if \\\n i.startswith(text)]", "docstring": "Tab-complete worker command." }, { "code": "def can_add_post(self, topic, user):\n can_add_post = self._perform_basic_permission_check(\n topic.forum, user, 'can_reply_to_topics',\n )\n can_add_post &= (\n not topic.is_locked or\n self._perform_basic_permission_check(topic.forum, user, 'can_reply_to_locked_topics')\n )\n return can_add_post", "docstring": "Given a topic, checks whether the user can append posts to it." }, { "code": "def CMS(data, format=\"PEM\"):\n bio = Membio(data)\n if format == \"PEM\":\n ptr = libcrypto.PEM_read_bio_CMS(bio.bio, None, None, None)\n else:\n ptr = libcrypto.d2i_CMS_bio(bio.bio, None)\n if ptr is None:\n raise CMSError(\"Error parsing CMS data\")\n typeoid = Oid(libcrypto.OBJ_obj2nid(libcrypto.CMS_get0_type(ptr)))\n if typeoid.shortname() == \"pkcs7-signedData\":\n return SignedData(ptr)\n elif typeoid.shortname() == \"pkcs7-envelopedData\":\n return EnvelopedData(ptr)\n elif typeoid.shortname() == \"pkcs7-encryptedData\":\n return EncryptedData(ptr)\n else:\n raise NotImplementedError(\"cannot handle \"+typeoid.shortname())", "docstring": "Factory function to create CMS objects from received messages.\n \n Parses CMS data and returns either SignedData or EnvelopedData\n object. format argument can be either \"PEM\" or \"DER\".\n\n It determines object type from the contents of received CMS\n structure." }, { "code": "def get_index_url(self, resource=None, **kwargs):\n default_kwargs = self.default_kwargs_for_urls() \\\n if resource == self.get_resource_name() else {}\n default_kwargs.update(kwargs)\n return self.get_full_url(\n self.app.reverse(\n '{}_index'.format(resource or self.get_resource_name()),\n **default_kwargs\n )\n )", "docstring": "Builds the url of the resource's index.\n\n :param resource: name of the resource or None\n :param kwargs: additional keyword arguments to build the url\n :return: url of the resource's index" }, { "code": "def _exit(self, status_code):\n exit_func = os._exit if threading.active_count() > 1 else sys.exit\n exit_func(status_code)", "docstring": "Properly kill Python process including zombie threads." }, { "code": "def member_profile_view(request, targetUsername):\n if targetUsername == request.user.username and targetUsername != ANONYMOUS_USERNAME:\n return HttpResponseRedirect(reverse('my_profile'))\n page_name = \"{0}'s Profile\".format(targetUsername)\n targetUser = get_object_or_404(User, username=targetUsername)\n targetProfile = get_object_or_404(UserProfile, user=targetUser)\n number_of_threads = Thread.objects.filter(owner=targetProfile).count()\n number_of_messages = Message.objects.filter(owner=targetProfile).count()\n number_of_requests = Request.objects.filter(owner=targetProfile).count()\n rooms = Room.objects.filter(current_residents=targetProfile)\n prev_rooms = PreviousResident.objects.filter(resident=targetProfile)\n return render_to_response('member_profile.html', {\n 'page_name': page_name,\n 'targetUser': targetUser,\n 'targetProfile': targetProfile,\n 'number_of_threads': number_of_threads,\n 'number_of_messages': number_of_messages,\n 'number_of_requests': number_of_requests,\n \"rooms\": rooms,\n \"prev_rooms\": prev_rooms,\n }, context_instance=RequestContext(request))", "docstring": "View a member's Profile." }, { "code": "def activate_next(self, _previous=False):\n current = self.get_current_value()\n options = sorted(self.values.keys())\n try:\n index = options.index(current)\n except ValueError:\n index = 0\n if _previous:\n index -= 1\n else:\n index += 1\n next_option = options[index % len(options)]\n self.values[next_option]()", "docstring": "Activate next value." }, { "code": "def getfile2(url, auth=None, outdir=None):\n import requests\n print(\"Retrieving: %s\" % url)\n fn = os.path.split(url)[-1]\n if outdir is not None:\n fn = os.path.join(outdir, fn)\n if auth is not None:\n r = requests.get(url, stream=True, auth=auth)\n else:\n r = requests.get(url, stream=True)\n chunk_size = 1000000\n with open(fn, 'wb') as fd:\n for chunk in r.iter_content(chunk_size):\n fd.write(chunk)", "docstring": "Function to fetch files using requests\n\n Works with https authentication" }, { "code": "def GetCacheValueByObject(self, vfs_object):\n for identifier, cache_value in iter(self._values.items()):\n if not cache_value:\n raise RuntimeError('Missing cache value.')\n if cache_value.vfs_object == vfs_object:\n return identifier, cache_value\n return None, None", "docstring": "Retrieves the cache value for the cached object.\n\n Args:\n vfs_object (object): VFS object that was cached.\n\n Returns:\n tuple[str, ObjectsCacheValue]: identifier and cache value object or\n (None, None) if not cached.\n\n Raises:\n RuntimeError: if the cache value is missing." }, { "code": "def session_demo_danger_callback(da_children, session_state=None, **kwargs):\n 'Update output based just on state'\n if not session_state:\n return \"Session state not yet available\"\n return \"Session state contains: \" + str(session_state.get('bootstrap_demo_state', \"NOTHING\")) + \" and the page render count is \" + str(session_state.get(\"ind_use\", \"NOT SET\"))", "docstring": "Update output based just on state" }, { "code": "def import_participant_element(diagram_graph, participants_dictionary, participant_element):\n participant_id = participant_element.getAttribute(consts.Consts.id)\n name = participant_element.getAttribute(consts.Consts.name)\n process_ref = participant_element.getAttribute(consts.Consts.process_ref)\n if participant_element.getAttribute(consts.Consts.process_ref) == '':\n diagram_graph.add_node(participant_id)\n diagram_graph.node[participant_id][consts.Consts.type] = consts.Consts.participant\n diagram_graph.node[participant_id][consts.Consts.process] = participant_id\n participants_dictionary[participant_id] = {consts.Consts.name: name, consts.Consts.process_ref: process_ref}", "docstring": "Adds 'participant' element to the collaboration dictionary.\n\n :param diagram_graph: NetworkX graph representing a BPMN process diagram,\n :param participants_dictionary: dictionary with participant element attributes. Key is participant ID, value\n is a dictionary of participant attributes,\n :param participant_element: object representing a BPMN XML 'participant' element." }, { "code": "def _build_meta(text: str, title: str) -> DocstringMeta:\n meta = _sections[title]\n if meta == \"returns\" and \":\" not in text.split()[0]:\n return DocstringMeta([meta], description=text)\n before, desc = text.split(\":\", 1)\n if desc:\n desc = desc[1:] if desc[0] == \" \" else desc\n if \"\\n\" in desc:\n first_line, rest = desc.split(\"\\n\", 1)\n desc = first_line + \"\\n\" + inspect.cleandoc(rest)\n desc = desc.strip(\"\\n\")\n m = re.match(r\"(\\S+) \\((\\S+)\\)$\", before)\n if meta == \"param\" and m:\n arg_name, type_name = m.group(1, 2)\n args = [meta, type_name, arg_name]\n else:\n args = [meta, before]\n return DocstringMeta(args, description=desc)", "docstring": "Build docstring element.\n\n :param text: docstring element text\n :param title: title of section containing element\n :return:" }, { "code": "def _set_italian_leading_zeros_for_phone_number(national_number, numobj):\n if len(national_number) > 1 and national_number[0] == U_ZERO:\n numobj.italian_leading_zero = True\n number_of_leading_zeros = 1\n while (number_of_leading_zeros < len(national_number) - 1 and\n national_number[number_of_leading_zeros] == U_ZERO):\n number_of_leading_zeros += 1\n if number_of_leading_zeros != 1:\n numobj.number_of_leading_zeros = number_of_leading_zeros", "docstring": "A helper function to set the values related to leading zeros in a\n PhoneNumber." }, { "code": "def normalize_version(version):\n if version is None:\n return None\n error = False\n try:\n version = int(version)\n error = version < 1\n except (ValueError, TypeError):\n try:\n version = consts.MICRO_VERSION_MAPPING[version.upper()]\n except (KeyError, AttributeError):\n error = True\n if error or not 0 < version < 41 and version not in consts.MICRO_VERSIONS:\n raise VersionError('Unsupported version \"{0}\". '\n 'Supported: {1} and 1 .. 40'\n .format(version, ', '.join(sorted(consts.MICRO_VERSION_MAPPING.keys()))))\n return version", "docstring": "\\\n Canonicalizes the provided `version`.\n\n If the `version` is ``None``, this function returns ``None``. Otherwise\n this function checks if `version` is an integer or a Micro QR Code version.\n In case the string represents a Micro QR Code version, an uppercased\n string identifier is returned.\n\n If the `version` does not represent a valid version identifier (aside of\n ``None``, a VersionError is raised.\n\n :param version: An integer, a string or ``None``.\n :raises: VersionError: In case the version is not ``None`` and does not\n represent a valid (Micro) QR Code version.\n :rtype: int, str or ``None``" }, { "code": "def get_protein_data_pgrouped(proteindata, p_acc, headerfields):\n report = get_protein_data_base(proteindata, p_acc, headerfields)\n return get_cov_protnumbers(proteindata, p_acc, report)", "docstring": "Parses protein data for a certain protein into tsv output\n dictionary" }, { "code": "def mutex():\n mutex_num = [50, 50, 50, 500, 500, 500, 1000, 1000, 1000]\n locks = [10000, 25000, 50000, 10000, 25000, 50000, 10000, 25000, 50000]\n mutex_locks = []\n mutex_locks.extend(locks)\n mutex_loops = [2500, 5000, 10000, 10000, 2500, 5000, 5000, 10000, 2500]\n test_command = 'sysbench --num-threads=250 --test=mutex '\n test_command += '--mutex-num={0} --mutex-locks={1} --mutex-loops={2} run '\n result = None\n ret_val = {}\n for num, locks, loops in zip(mutex_num, mutex_locks, mutex_loops):\n key = 'Mutex: {0} Locks: {1} Loops: {2}'.format(num, locks, loops)\n run_command = test_command.format(num, locks, loops)\n result = __salt__['cmd.run'](run_command)\n ret_val[key] = _parser(result)\n return ret_val", "docstring": "Tests the implementation of mutex\n\n CLI Examples:\n\n .. code-block:: bash\n\n salt '*' sysbench.mutex" }, { "code": "def full_name(self):\n if self.prefix is not None:\n return '.'.join([self.prefix, self.member])\n return self.member", "docstring": "Return full name of member" }, { "code": "def _hide_loading_page(self):\r\n self.infowidget.hide()\r\n self.shellwidget.show()\r\n self.info_page = self.blank_page\r\n self.set_info_page()\r\n self.shellwidget.sig_prompt_ready.disconnect(self._hide_loading_page)", "docstring": "Hide animation shown while the kernel is loading." }, { "code": "def chunks(iterable, size):\n it = iter(iterable)\n item = list(islice(it, size))\n while item:\n yield item\n item = list(islice(it, size))", "docstring": "Splits a very large list into evenly sized chunks.\n Returns an iterator of lists that are no more than the size passed in." }, { "code": "def uninit_ui(self):\n self.lay.removeWidget(self.tool_pb)\n self.tooltip.deleteLater()\n self.tool_pb.deleteLater()", "docstring": "Delete the tooltip\n\n :returns: None\n :rtype: None\n :raises: None" }, { "code": "def _get_subject_alternative_names(self, ext):\n values = []\n for san in ext.value:\n if isinstance(san.value, string):\n values.append(san.value)\n elif isinstance(san.value, x509.Name):\n values.extend(\n self._name_attribute_to_string(rdn) for rdn in san.value.rdns\n )\n return values", "docstring": "Return a list of Subject Alternative Name values for the given x509\n extension object." }, { "code": "def _findbytes(self, bytes_, start, end, bytealigned):\n assert self._datastore.offset == 0\n assert bytealigned is True\n bytepos = (start + 7) // 8\n found = False\n p = bytepos\n finalpos = end // 8\n increment = max(1024, len(bytes_) * 10)\n buffersize = increment + len(bytes_)\n while p < finalpos:\n buf = bytearray(self._datastore.getbyteslice(p, min(p + buffersize, finalpos)))\n pos = buf.find(bytes_)\n if pos != -1:\n found = True\n p += pos\n break\n p += increment\n if not found:\n return ()\n return (p * 8,)", "docstring": "Quicker version of find when everything's whole byte\n and byte aligned." }, { "code": "def _array_io(self, action, array, frames):\n if (array.ndim not in (1, 2) or\n array.ndim == 1 and self.channels != 1 or\n array.ndim == 2 and array.shape[1] != self.channels):\n raise ValueError(\"Invalid shape: {0!r}\".format(array.shape))\n if not array.flags.c_contiguous:\n raise ValueError(\"Data must be C-contiguous\")\n ctype = self._check_dtype(array.dtype.name)\n assert array.dtype.itemsize == _ffi.sizeof(ctype)\n cdata = _ffi.cast(ctype + '*', array.__array_interface__['data'][0])\n return self._cdata_io(action, cdata, ctype, frames)", "docstring": "Check array and call low-level IO function." }, { "code": "def give_satellite_json(self):\n daemon_properties = ['type', 'name', 'uri', 'spare', 'configuration_sent',\n 'realm_name', 'manage_sub_realms',\n 'active', 'reachable', 'alive', 'passive',\n 'last_check', 'polling_interval', 'max_check_attempts']\n (livestate, livestate_output) = self.get_livestate()\n res = {\n \"livestate\": livestate,\n \"livestate_output\": livestate_output\n }\n for sat_prop in daemon_properties:\n res[sat_prop] = getattr(self, sat_prop, 'not_yet_defined')\n return res", "docstring": "Get the json information for a satellite.\n\n This to provide information that will be exposed by a daemon on its HTTP interface.\n\n :return: dictionary of information common to all the links\n :rtype: dict" }, { "code": "def _set_expressions(self, expressions):\n self.expressions = {}\n for key, item in expressions.items():\n self.expressions[key] = {'function': item}", "docstring": "Extract expressions and variables from the user provided expressions." }, { "code": "def query(cls, database, map_fun, reduce_fun,\n language='javascript', **options):\n return database.query(map_fun, reduce_fun=reduce_fun, language=language,\n wrapper=cls._wrap_row, **options)", "docstring": "Execute a CouchDB temporary view and map the result values back to\n objects of this mapping.\n\n Note that by default, any properties of the document that are not\n included in the values of the view will be treated as if they were\n missing from the document. If you want to load the full document for\n every row, set the ``include_docs`` option to ``True``." }, { "code": "def container_config_delete(name, config_key, remote_addr=None,\n cert=None, key=None, verify_cert=True):\n container = container_get(\n name, remote_addr, cert, key, verify_cert, _raw=True\n )\n return _delete_property_dict_item(\n container, 'config', config_key\n )", "docstring": "Delete a container config value\n\n name :\n Name of the container\n\n config_key :\n The config key to delete\n\n remote_addr :\n An URL to a remote Server, you also have to give cert and key if\n you provide remote_addr and its a TCP Address!\n\n Examples:\n https://myserver.lan:8443\n /var/lib/mysocket.sock\n\n cert :\n PEM Formatted SSL Certificate.\n\n Examples:\n ~/.config/lxc/client.crt\n\n key :\n PEM Formatted SSL Key.\n\n Examples:\n ~/.config/lxc/client.key\n\n verify_cert : True\n Wherever to verify the cert, this is by default True\n but in the most cases you want to set it off as LXD\n normaly uses self-signed certificates." }, { "code": "def items(self):\n if type(self.transaction['items']['item']) == list:\n return self.transaction['items']['item']\n else:\n return [self.transaction['items']['item'],]", "docstring": "Lista dos items do pagamento" }, { "code": "def entity_categories(self, entity_id):\n attributes = self.entity_attributes(entity_id)\n return attributes.get(ENTITY_CATEGORY, [])", "docstring": "Get a list of entity categories for an entity id.\n\n :param entity_id: Entity id\n :return: Entity categories\n\n :type entity_id: string\n :rtype: [string]" }, { "code": "def log_to_api(self):\n if self.entries:\n try:\n headers = {'Content-Type': 'application/json'}\n self.session.post('/v2/logs/app', headers=headers, json=self.entries)\n except Exception:\n pass", "docstring": "Best effort API logger.\n\n Send logs to the ThreatConnect API and do nothing if the attempt fails." }, { "code": "def outfile_maker(inname, outext='.out', outname='', outdir='', append_to_name=''):\n orig_dir, orig_name, orig_ext = split_folder_and_path(inname)\n if not outname:\n outname = orig_name\n if not outdir:\n outdir = orig_dir\n if append_to_name:\n outname += append_to_name\n final_outfile = op.join(outdir, '{}{}'.format(outname, outext))\n return final_outfile", "docstring": "Create a default name for an output file based on the inname name, unless a output name is specified.\n\n Args:\n inname: Path to input file\n outext: Optional specified extension for output file (with the \".\"). Default is \".out\".\n outfile: Optional specified name of output file.\n outdir: Optional path to output directory.\n\n Returns:\n str: Path to final output destination.\n\n Examples:\n\n >>> outfile_maker(inname='P00001.fasta')\n 'P00001.out'\n\n >>> outfile_maker(inname='P00001')\n 'P00001.out'\n\n >>> outfile_maker(inname='P00001.fasta', append_to_name='_new')\n 'P00001_new.out'\n\n >>> outfile_maker(inname='P00001.fasta', outext='.mao')\n 'P00001.mao'\n\n >>> outfile_maker(inname='P00001.fasta', outext='.mao', append_to_name='_new')\n 'P00001_new.mao'\n\n >>> outfile_maker(inname='P00001.fasta', outext='.new', outname='P00001_aligned')\n 'P00001_aligned.new'\n\n >>> outfile_maker(inname='P00001.fasta', outname='P00001_aligned')\n 'P00001_aligned.out'\n\n >>> outfile_maker(inname='P00001.fasta', outname='P00001_aligned', append_to_name='_new')\n 'P00001_aligned_new.out'\n\n >>> outfile_maker(inname='P00001.fasta', outname='P00001_aligned', outdir='/my/dir/')\n '/my/dir/P00001_aligned.out'\n\n >>> outfile_maker(inname='/test/other/dir/P00001.fasta', append_to_name='_new')\n '/test/other/dir/P00001_new.out'\n\n >>> outfile_maker(inname='/test/other/dir/P00001.fasta', outname='P00001_aligned')\n '/test/other/dir/P00001_aligned.out'\n\n >>> outfile_maker(inname='/test/other/dir/P00001.fasta', outname='P00001_aligned', outdir='/my/dir/')\n '/my/dir/P00001_aligned.out'" }, { "code": "def generate_sample_sls_module(env_root, module_dir=None):\n if module_dir is None:\n module_dir = os.path.join(env_root, 'sampleapp.sls')\n generate_sample_module(module_dir)\n for i in ['config-dev-us-east-1.json', 'handler.py', 'package.json',\n 'serverless.yml']:\n shutil.copyfile(\n os.path.join(ROOT,\n 'templates',\n 'serverless',\n i),\n os.path.join(module_dir, i),\n )\n LOGGER.info(\"Sample Serverless module created at %s\",\n module_dir)", "docstring": "Generate skeleton Serverless sample module." }, { "code": "def format_expose(expose):\n if isinstance(expose, six.string_types):\n return expose,\n elif isinstance(expose, collections.Iterable):\n return map(six.text_type, expose)\n return six.text_type(expose),", "docstring": "Converts a port number or multiple port numbers, as used in the Dockerfile ``EXPOSE`` command, to a tuple.\n\n :param: Port numbers, can be as integer, string, or a list/tuple of those.\n :type expose: int | unicode | str | list | tuple\n :return: A tuple, to be separated by spaces before inserting in a Dockerfile.\n :rtype: tuple" }, { "code": "def decisionviz(model,\n X,\n y,\n colors=None,\n classes=None,\n features=None,\n show_scatter=True,\n step_size=0.0025,\n markers=None,\n pcolormesh_alpha=0.8,\n scatter_alpha=1.0,\n title=None,\n **kwargs):\n visualizer = DecisionBoundariesVisualizer(model,\n X,\n y,\n colors=colors,\n classes=classes,\n features=features,\n show_scatter=show_scatter,\n step_size=step_size,\n markers=markers,\n pcolormesh_alpha=pcolormesh_alpha,\n scatter_alpha=scatter_alpha,\n title=title,\n **kwargs)\n visualizer.fit_draw_poof(X, y, **kwargs)\n return visualizer.ax", "docstring": "DecisionBoundariesVisualizer is a bivariate data visualization algorithm\n that plots the decision boundaries of each class.\n\n This helper function is a quick wrapper to utilize the\n DecisionBoundariesVisualizers for one-off analysis.\n\n Parameters\n ----------\n model : the Scikit-Learn estimator, required\n Should be an instance of a classifier, else the __init__ will\n return an error.\n\n x : matrix, required\n The feature name that corresponds to a column name or index postion\n in the matrix that will be plotted against the x-axis\n\n y : array, required\n The feature name that corresponds to a column name or index postion\n in the matrix that will be plotted against the y-axis\n\n classes : a list of class names for the legend, default: None\n If classes is None and a y value is passed to fit then the classes\n are selected from the target vector.\n\n features : list of strings, default: None\n The names of the features or columns\n\n show_scatter : boolean, default: True\n If boolean is True, then a scatter plot with points will be drawn\n on top of the decision boundary graph\n\n step_size : float percentage, default: 0.0025\n Determines the step size for creating the numpy meshgrid that will\n later become the foundation of the decision boundary graph. The\n default value of 0.0025 means that the step size for constructing\n the meshgrid will be 0.25%% of differenes of the max and min of x\n and y for each feature.\n\n markers : iterable of strings, default: ,od*vh+\n Matplotlib style markers for points on the scatter plot points\n\n pcolormesh_alpha : float, default: 0.8\n Sets the alpha transparency for the meshgrid of model boundaries\n\n scatter_alpha : float, default: 1.0\n Sets the alpha transparency for the scatter plot points\n\n title : string, default: stringified feature_one and feature_two\n Sets the title of the visualization\n\n kwargs : keyword arguments passed to the super class.\n\n Returns\n -------\n ax : matplotlib axes\n Returns the axes that the decision boundaries graph were drawn on." }, { "code": "def _parse_patterns(self, pattern):\n self.pattern = []\n self.npatterns = None\n npattern = []\n for p in pattern:\n if _wcparse.is_negative(p, self.flags):\n npattern.append(p[1:])\n else:\n self.pattern.extend(\n [_wcparse.WcPathSplit(x, self.flags).split() for x in _wcparse.expand_braces(p, self.flags)]\n )\n if npattern:\n self.npatterns = _wcparse.compile(npattern, self.flags ^ (_wcparse.NEGATE | _wcparse.REALPATH))\n if not self.pattern and self.npatterns is not None:\n self.pattern.append(_wcparse.WcPathSplit((b'**' if self.is_bytes else '**'), self.flags).split())", "docstring": "Parse patterns." }, { "code": "def to_inches(value, units):\n lookup = {'in': lambda x: x,\n 'cm': lambda x: x/2.54,\n 'mm': lambda x: x/(2.54*10)}\n try:\n return lookup[units](value)\n except KeyError:\n raise PlotnineError(\"Unknown units '{}'\".format(units))", "docstring": "Convert value to inches\n\n Parameters\n ----------\n value : float\n Value to be converted\n units : str\n Units of value. Must be one of\n `['in', 'cm', 'mm']`." }, { "code": "def fetch_entities(self):\n query = text(\n )\n response = self.perform_query(query)\n entities = {}\n domains = set()\n for [entity] in response:\n domain = entity.split(\".\")[0]\n domains.add(domain)\n entities.setdefault(domain, []).append(entity)\n self._domains = list(domains)\n self._entities = entities\n print(\"There are {} entities with data\".format(len(entities)))", "docstring": "Fetch entities for which we have data." }, { "code": "def createDocument_(self, initDict = None) :\n \"create and returns a completely empty document or one populated with initDict\"\n if initDict is None :\n initV = {}\n else :\n initV = initDict\n return self.documentClass(self, initV)", "docstring": "create and returns a completely empty document or one populated with initDict" }, { "code": "def recursive_iterator(func):\n tee_store = {}\n @_coconut.functools.wraps(func)\n def recursive_iterator_func(*args, **kwargs):\n hashable_args_kwargs = _coconut.pickle.dumps((args, kwargs), _coconut.pickle.HIGHEST_PROTOCOL)\n try:\n to_tee = tee_store[hashable_args_kwargs]\n except _coconut.KeyError:\n to_tee = func(*args, **kwargs)\n tee_store[hashable_args_kwargs], to_return = _coconut_tee(to_tee)\n return to_return\n return recursive_iterator_func", "docstring": "Decorates a function by optimizing it for iterator recursion.\n Requires function arguments to be pickleable." }, { "code": "def diff_medians(array_one, array_two):\n array_one = check_array(array_one)\n array_two = check_array(array_two)\n diff_medians = np.ma.median(array_one) - np.ma.median(array_two)\n return diff_medians", "docstring": "Computes the difference in medians between two arrays of values.\n\n Given arrays will be flattened (to 1D array) regardless of dimension,\n and any non-finite/NaN values will be ignored.\n\n Parameters\n ----------\n array_one, array_two : iterable\n Two arrays of values, possibly of different length.\n\n Returns\n -------\n diff_medians : float\n scalar measuring the difference in medians, ignoring NaNs/non-finite values.\n\n Raises\n ------\n ValueError\n If one or more of the arrays are empty." }, { "code": "def unperturbed_hamiltonian(states):\n r\n Ne = len(states)\n H0 = np.zeros((Ne, Ne), complex)\n for i in range(Ne):\n H0[i, i] = hbar*states[i].omega\n return H0", "docstring": "r\"\"\"Return the unperturbed atomic hamiltonian for given states.\n\n We calcualte the atomic hamiltonian in the basis of the ground states of \\\n rubidium 87 (in GHz).\n >>> g = State(\"Rb\", 87, 5, 0, 1/Integer(2))\n >>> magnetic_states = make_list_of_states([g], \"magnetic\")\n >>> print(np.diag(unperturbed_hamiltonian(magnetic_states))/hbar/2/pi*1e-9)\n [-4.2717+0.j -4.2717+0.j -4.2717+0.j 2.563 +0.j 2.563 +0.j 2.563 +0.j\n 2.563 +0.j 2.563 +0.j]" }, { "code": "def _run_select(self):\n return self._connection.select(\n self.to_sql(), self.get_bindings(), not self._use_write_connection\n )", "docstring": "Run the query as a \"select\" statement against the connection.\n\n :return: The result\n :rtype: list" }, { "code": "def check_status_logfile(self, checker_func):\n self.status = checker_func(self.logfile)\n return self.status", "docstring": "Check on the status of this particular job using the logfile" }, { "code": "def _del_flow_entry(self, datapath, in_port, dst, src=None):\n del_flow = self._del_flow_func.get(datapath.ofproto.OFP_VERSION)\n assert del_flow\n del_flow(datapath, in_port, dst, src)", "docstring": "remove a flow entry." }, { "code": "def interpolate_string(self, testString, section):\n reObj = re.search(r\"\\$\\{.*?\\}\", testString)\n while reObj:\n repString = (reObj).group(0)[2:-1]\n splitString = repString.split('|')\n if len(splitString) == 1:\n try:\n testString = testString.replace('${'+repString+'}',\\\n self.get(section,splitString[0]))\n except ConfigParser.NoOptionError:\n print(\"Substitution failed\")\n raise\n if len(splitString) == 2:\n try:\n testString = testString.replace('${'+repString+'}',\\\n self.get(splitString[0],splitString[1]))\n except ConfigParser.NoOptionError:\n print(\"Substitution failed\")\n raise\n reObj = re.search(r\"\\$\\{.*?\\}\", testString)\n return testString", "docstring": "Take a string and replace all example of ExtendedInterpolation\n formatting within the string with the exact value.\n\n For values like ${example} this is replaced with the value that\n corresponds to the option called example ***in the same section***\n\n For values like ${common|example} this is replaced with the value that\n corresponds to the option example in the section [common]. Note that\n in the python3 config parser this is ${common:example} but python2.7\n interprets the : the same as a = and this breaks things\n\n Nested interpolation is not supported here.\n\n Parameters\n ----------\n testString : String\n The string to parse and interpolate\n section : String\n The current section of the ConfigParser object\n\n Returns\n ----------\n testString : String\n Interpolated string" }, { "code": "def validate_uuid(value):\n if value and not isinstance(value, UUID):\n try:\n return UUID(str(value), version=4)\n except (AttributeError, ValueError):\n raise ValidationError('not a valid UUID')\n return value", "docstring": "UUID 128-bit validator" }, { "code": "def publish_pdb_state(self):\n if self._pdb_obj and self._do_publish_pdb_state:\n state = dict(namespace_view = self.get_namespace_view(),\n var_properties = self.get_var_properties(),\n step = self._pdb_step)\n self.send_spyder_msg('pdb_state', content={'pdb_state': state})\n self._do_publish_pdb_state = True", "docstring": "Publish Variable Explorer state and Pdb step through\n send_spyder_msg." }, { "code": "def _set_repo(self, url):\n if url.startswith('http'):\n try:\n self.repo = Proxy(url)\n except ProxyError, e:\n log.exception('Error setting repo: %s' % url)\n raise GritError(e)\n else:\n try:\n self.repo = Local(url)\n except NotGitRepository:\n raise GritError('Invalid url: %s' % url)\n except Exception, e:\n log.exception('Error setting repo: %s' % url)\n raise GritError(e)", "docstring": "sets the underlying repo object" }, { "code": "def mouse_release_event(self, x, y, button):\n if button == 1:\n print(\"Left mouse button released @\", x, y)\n if button == 2:\n print(\"Right mouse button released @\", x, y)", "docstring": "Reports left and right mouse button releases + position" }, { "code": "def create_transcript_file(video_id, language_code, file_format, resource_fs, static_dir):\n transcript_filename = '{video_id}-{language_code}.srt'.format(\n video_id=video_id,\n language_code=language_code\n )\n transcript_data = get_video_transcript_data(video_id, language_code)\n if transcript_data:\n transcript_content = Transcript.convert(\n transcript_data['content'],\n input_format=file_format,\n output_format=Transcript.SRT\n )\n create_file_in_fs(transcript_content, transcript_filename, resource_fs, static_dir)\n return transcript_filename", "docstring": "Writes transcript file to file system.\n\n Arguments:\n video_id (str): Video id of the video transcript file is attached.\n language_code (str): Language code of the transcript.\n file_format (str): File format of the transcript file.\n static_dir (str): The Directory to store transcript file.\n resource_fs (SubFS): The file system to store transcripts." }, { "code": "async def get(self, source_, *args, **kwargs):\n await self.connect()\n if isinstance(source_, peewee.Query):\n query = source_\n model = query.model\n else:\n query = source_.select()\n model = source_\n conditions = list(args) + [(getattr(model, k) == v)\n for k, v in kwargs.items()]\n if conditions:\n query = query.where(*conditions)\n try:\n result = await self.execute(query)\n return list(result)[0]\n except IndexError:\n raise model.DoesNotExist", "docstring": "Get the model instance.\n\n :param source_: model or base query for lookup\n\n Example::\n\n async def my_async_func():\n obj1 = await objects.get(MyModel, id=1)\n obj2 = await objects.get(MyModel, MyModel.id==1)\n obj3 = await objects.get(MyModel.select().where(MyModel.id==1))\n\n All will return `MyModel` instance with `id = 1`" }, { "code": "def to_dataframe(self, extra_edges_columns=[]):\n return df_util.to_dataframe(\n self.session.get(self.__url).json(),\n edges_attr_cols=extra_edges_columns\n )", "docstring": "Return this network in pandas DataFrame.\n\n :return: Network as DataFrame. This is equivalent to SIF." }, { "code": "def _clauses(lexer, varname, nvars):\n tok = next(lexer)\n toktype = type(tok)\n if toktype is OP_not or toktype is IntegerToken:\n lexer.unpop_token(tok)\n first = _clause(lexer, varname, nvars)\n rest = _clauses(lexer, varname, nvars)\n return (first, ) + rest\n else:\n lexer.unpop_token(tok)\n return tuple()", "docstring": "Return a tuple of DIMACS CNF clauses." }, { "code": "def get_nts(self, goids=None, sortby=None):\n nts = []\n if goids is None:\n goids = self.go_sources\n else:\n chk_goids(goids, \"GoSubDag::get_nts\")\n if goids:\n ntobj = cx.namedtuple(\"NtGo\", \" \".join(self.prt_attr['flds']))\n go2nt = self.get_go2nt(goids)\n for goid, ntgo in self._get_sorted_go2nt(go2nt, sortby):\n assert ntgo is not None, \"{GO} NOT IN go2nt\".format(GO=goid)\n if goid == ntgo.GO:\n nts.append(ntgo)\n else:\n fld2vals = ntgo._asdict()\n fld2vals['GO'] = goid\n nts.append(ntobj(**fld2vals))\n return nts", "docstring": "Given GO IDs, get a list of namedtuples." }, { "code": "def prevPlot(self):\n if self.stacker.currentIndex() > 0:\n self.stacker.setCurrentIndex(self.stacker.currentIndex()-1)", "docstring": "Moves the displayed plot to the previous one" }, { "code": "def to_timedelta(value, strict=True):\n if isinstance(value, int):\n return timedelta(seconds=value)\n elif isinstance(value, timedelta):\n return value\n elif isinstance(value, str):\n hours, minutes, seconds = _parse(value, strict)\n elif isinstance(value, tuple):\n check_tuple(value, strict)\n hours, minutes, seconds = value\n else:\n raise TypeError(\n 'Value %s (type %s) not supported' % (\n value, type(value).__name__\n )\n )\n return timedelta(hours=hours, minutes=minutes, seconds=seconds)", "docstring": "converts duration string to timedelta\n\n strict=True (by default) raises StrictnessError if either hours,\n minutes or seconds in duration string exceed allowed values" }, { "code": "def calibration_stimulus(self, mode):\n if mode == 'tone':\n return self.tone_calibrator.stimulus\n elif mode =='noise':\n return self.bs_calibrator.stimulus", "docstring": "Gets the stimulus model for calibration\n\n :param mode: Type of stimulus to get: tone or noise\n :type mode: str\n :returns: :class:`StimulusModel`" }, { "code": "def get_file_hash(fpath, blocksize=65536, hasher=None, stride=1,\n hexdigest=False):\n r\n if hasher is None:\n hasher = hashlib.sha1()\n with open(fpath, 'rb') as file_:\n buf = file_.read(blocksize)\n while len(buf) > 0:\n hasher.update(buf)\n if stride > 1:\n file_.seek(blocksize * (stride - 1), 1)\n buf = file_.read(blocksize)\n if hexdigest:\n return hasher.hexdigest()\n else:\n return hasher.digest()", "docstring": "r\"\"\"\n For better hashes use hasher=hashlib.sha256, and keep stride=1\n\n Args:\n fpath (str): file path string\n blocksize (int): 2 ** 16. Affects speed of reading file\n hasher (None): defaults to sha1 for fast (but insecure) hashing\n stride (int): strides > 1 skip data to hash, useful for faster\n hashing, but less accurate, also makes hash dependant on\n blocksize.\n\n References:\n http://stackoverflow.com/questions/3431825/generating-a-md5-checksum-of-a-file\n http://stackoverflow.com/questions/5001893/when-should-i-use-sha-1-and-when-should-i-use-sha-2\n\n CommandLine:\n python -m utool.util_hash --test-get_file_hash\n python -m utool.util_hash --test-get_file_hash:0\n python -m utool.util_hash --test-get_file_hash:1\n\n Example:\n >>> # DISABLE_DOCTEST\n >>> from utool.util_hash import * # NOQA\n >>> fpath = ut.grab_test_imgpath('patsy.jpg')\n >>> #blocksize = 65536 # 2 ** 16\n >>> blocksize = 2 ** 16\n >>> hasher = None\n >>> stride = 1\n >>> hashbytes_20 = get_file_hash(fpath, blocksize, hasher, stride)\n >>> result = repr(hashbytes_20)\n >>> print(result)\n '7\\x07B\\x0eX>> # DISABLE_DOCTEST\n >>> from utool.util_hash import * # NOQA\n >>> #fpath = ut.grab_file_url('http://en.wikipedia.org/wiki/List_of_comets_by_type')\n >>> fpath = ut.unixjoin(ut.ensure_app_resource_dir('utool'), 'tmp.txt')\n >>> ut.write_to(fpath, ut.lorium_ipsum())\n >>> blocksize = 2 ** 3\n >>> hasher = None\n >>> stride = 2\n >>> hashbytes_20 = get_file_hash(fpath, blocksize, hasher, stride)\n >>> result = repr(hashbytes_20)\n >>> print(result)\n '5KP\\xcf>R\\xf6\\xffO:L\\xac\\x9c\\xd3V+\\x0e\\xf6\\xe1n'\n\n Ignore:\n file_ = open(fpath, 'rb')" }, { "code": "def _http_get(self, url, query):\n if not self.authorization_as_header:\n query.update({'access_token': self.access_token})\n response = None\n self._normalize_query(query)\n kwargs = {\n 'params': query,\n 'headers': self._request_headers()\n }\n if self._has_proxy():\n kwargs['proxies'] = self._proxy_parameters()\n response = requests.get(\n self._url(url),\n **kwargs\n )\n if response.status_code == 429:\n raise RateLimitExceededError(response)\n return response", "docstring": "Performs the HTTP GET Request." }, { "code": "def eval_nonagg_call(self, exp):\n \"helper for eval_callx; evaluator for CallX that consume a single value\"\n args=self.eval(exp.args)\n if exp.f=='coalesce':\n a,b=args\n return b if a is None else a\n elif exp.f=='unnest': return self.eval(exp.args)[0]\n elif exp.f in ('to_tsquery','to_tsvector'): return set(self.eval(exp.args.children[0]).split())\n else: raise NotImplementedError('unk_function',exp.f)", "docstring": "helper for eval_callx; evaluator for CallX that consume a single value" }, { "code": "def search(self, **kwargs):\n return super(ApiObjectGroupPermissionGeneral, self).get(self.prepare_url('api/v3/object-group-perm-general/',\n kwargs))", "docstring": "Method to search object group permissions general based on extends search.\n\n :param search: Dict containing QuerySets to find object group permissions general.\n :param include: Array containing fields to include on response.\n :param exclude: Array containing fields to exclude on response.\n :param fields: Array containing fields to override default fields.\n :param kind: Determine if result will be detailed ('detail') or basic ('basic').\n :return: Dict containing object group permissions general" }, { "code": "def parse(self, data, extent, desc_tag):\n if self._initialized:\n raise pycdlibexception.PyCdlibInternalError('UDF Unallocated Space Descriptor already initialized')\n (tag_unused, self.vol_desc_seqnum,\n num_alloc_descriptors, end_unused) = struct.unpack_from(self.FMT, data, 0)\n self.desc_tag = desc_tag\n if num_alloc_descriptors != 0:\n raise pycdlibexception.PyCdlibInvalidISO('UDF Unallocated Space Descriptor allocated descriptors is not 0')\n self.orig_extent_loc = extent\n self._initialized = True", "docstring": "Parse the passed in data into a UDF Unallocated Space Descriptor.\n\n Parameters:\n data - The data to parse.\n extent - The extent that this descriptor currently lives at.\n desc_tag - A UDFTag object that represents the Descriptor Tag.\n Returns:\n Nothing." }, { "code": "def namedTempFileReader(self) -> NamedTempFileReader:\n directory = self._directory()\n assert isinstance(directory, Directory), (\n \"Expected Directory, receieved %s\" % directory)\n return NamedTempFileReader(directory, self)", "docstring": "Named Temporary File Reader\n\n This provides an object compatible with NamedTemporaryFile, used for reading this\n files contents. This will still delete after the object falls out of scope.\n\n This solves the problem on windows where a NamedTemporaryFile can not be read\n while it's being written to" }, { "code": "def ismethoddescriptor(object):\n return (hasattr(object, \"__get__\")\n and not hasattr(object, \"__set__\")\n and not ismethod(object)\n and not isfunction(object)\n and not isclass(object))", "docstring": "Return true if the object is a method descriptor.\n\n But not if ismethod() or isclass() or isfunction() are true.\n\n This is new in Python 2.2, and, for example, is true of int.__add__.\n An object passing this test has a __get__ attribute but not a __set__\n attribute, but beyond that the set of attributes varies. __name__ is\n usually sensible, and __doc__ often is.\n\n Methods implemented via descriptors that also pass one of the other\n tests return false from the ismethoddescriptor() test, simply because\n the other tests promise more -- you can, e.g., count on having the\n im_func attribute (etc) when an object passes ismethod()." }, { "code": "def provider(func=None, *, singleton=False, injector=None):\n def decorator(func):\n wrapped = _wrap_provider_func(func, {'singleton': singleton})\n if injector:\n injector.register_provider(wrapped)\n return wrapped\n if func:\n return decorator(func)\n return decorator", "docstring": "Decorator to mark a function as a provider.\n\n Args:\n singleton (bool): The returned value should be a singleton or shared\n instance. If False (the default) the provider function will be\n invoked again for every time it's needed for injection.\n injector (Injector): If provided, the function is immediately\n registered as a provider with the injector instance.\n\n Example:\n @diay.provider(singleton=True)\n def myfunc() -> MyClass:\n return MyClass(args)" }, { "code": "def construct_chunk(cls, chunk_type, payload, encoding='utf-8'):\n if isinstance(payload, str):\n payload = payload.encode(encoding)\n elif not isinstance(payload, bytes):\n raise TypeError('cannot encode type: {}'.format(type(payload)))\n header = struct.pack(cls.HEADER_FMT, len(payload), chunk_type)\n return header + payload", "docstring": "Construct and return a single chunk." }, { "code": "def resend_transaction_frames(self, connection, transaction):\n for frame in self._transaction_frames[connection][transaction]:\n self.send(frame)", "docstring": "Resend the messages that were ACK'd in specified transaction.\n\n This is called by the engine when there is an abort command.\n\n @param connection: The client connection that aborted the transaction.\n @type connection: L{coilmq.server.StompConnection}\n\n @param transaction: The transaction id (which was aborted).\n @type transaction: C{str}" }, { "code": "def remove(self):\n for cgroup in self.paths:\n remove_cgroup(cgroup)\n del self.paths\n del self.per_subsystem", "docstring": "Remove all cgroups this instance represents from the system.\n This instance is afterwards not usable anymore!" }, { "code": "def rename(self, new_lid):\n logger.info(\"rename(new_lid=\\\"%s\\\") [lid=%s]\", new_lid, self.__lid)\n evt = self._client._request_entity_rename(self.__lid, new_lid)\n self._client._wait_and_except_if_failed(evt)\n self.__lid = new_lid\n self._client._notify_thing_lid_change(self.__lid, new_lid)", "docstring": "Rename the Thing.\n\n `ADVANCED USERS ONLY` This can be confusing. You are changing the local id of a Thing to `new_lid`. If you\n create another Thing using the \"old_lid\", the system will oblige, but it will be a completely _new_ Thing.\n\n Raises [IOTException](./Exceptions.m.html#IoticAgent.IOT.Exceptions.IOTException)\n containing the error if the infrastructure detects a problem\n\n Raises [LinkException](../Core/AmqpLink.m.html#IoticAgent.Core.AmqpLink.LinkException)\n if there is a communications problem between you and the infrastructure\n\n `new_lid` (required) (string) the new local identifier of your Thing" }, { "code": "def _FormatIPToken(self, token_data):\n data = ''.join(['{0:02x}'.format(byte) for byte in token_data.data])\n return {'IPv4_Header': data}", "docstring": "Formats an IPv4 packet header token as a dictionary of values.\n\n Args:\n token_data (bsm_token_data_ip): AUT_IP token data.\n\n Returns:\n dict[str, str]: token values." }, { "code": "def probe_git():\n try:\n repo = git.Repo()\n except git.InvalidGitRepositoryError:\n LOGGER.warning(\n \"We highly recommend keeping your model in a git repository.\"\n \" It allows you to track changes and to easily collaborate with\"\n \" others via online platforms such as https://github.com.\\n\")\n return\n if repo.is_dirty():\n LOGGER.critical(\n \"Please git commit or git stash all changes before running\"\n \" the memote suite.\")\n sys.exit(1)\n return repo", "docstring": "Return a git repository instance if it exists." }, { "code": "def metrics(self):\n masterThrp, backupThrp = self.getThroughputs(self.instances.masterId)\n r = self.instance_throughput_ratio(self.instances.masterId)\n m = [\n (\"{} Monitor metrics:\".format(self), None),\n (\"Delta\", self.Delta),\n (\"Lambda\", self.Lambda),\n (\"Omega\", self.Omega),\n (\"instances started\", self.instances.started),\n (\"ordered request counts\",\n {i: r[0] for i, r in self.numOrderedRequests.items()}),\n (\"ordered request durations\",\n {i: r[1] for i, r in self.numOrderedRequests.items()}),\n (\"master request latencies\", self.masterReqLatencies),\n (\"client avg request latencies\", {i: self.getLatency(i)\n for i in self.instances.ids}),\n (\"throughput\", {i: self.getThroughput(i)\n for i in self.instances.ids}),\n (\"master throughput\", masterThrp),\n (\"total requests\", self.totalRequests),\n (\"avg backup throughput\", backupThrp),\n (\"master throughput ratio\", r)]\n return m", "docstring": "Calculate and return the metrics." }, { "code": "def get_home(self):\n if 'HOME_POSITION' in self.master.messages:\n h = self.master.messages['HOME_POSITION']\n return mavutil.mavlink.MAVLink_mission_item_message(self.target_system,\n self.target_component,\n 0,\n 0,\n mavutil.mavlink.MAV_CMD_NAV_WAYPOINT,\n 0, 0, 0, 0, 0, 0,\n h.latitude*1.0e-7, h.longitude*1.0e-7, h.altitude*1.0e-3)\n if self.wploader.count() > 0:\n return self.wploader.wp(0)\n return None", "docstring": "get home location" }, { "code": "def filter_geometry(queryset, **filters):\n fieldname = geo_field(queryset).name\n query = {'%s__%s' % (fieldname, k): v for k, v in filters.items()}\n return queryset.filter(**query)", "docstring": "Helper function for spatial lookups filters.\n\n Provide spatial lookup types as keywords without underscores instead of the\n usual \"geometryfield__lookuptype\" format." }, { "code": "def logout(self):\n data = self._read_uaa_cache()\n if self.uri in data:\n for client in data[self.uri]:\n if client['id'] == self.client['id']:\n data[self.uri].remove(client)\n with open(self._cache_path, 'w') as output:\n output.write(json.dumps(data, sort_keys=True, indent=4))", "docstring": "Log currently authenticated user out, invalidating any existing tokens." }, { "code": "def default(self):\n if isinstance(self.__default, (str, unicode)):\n return self.valueFromString(self.__default)\n else:\n return self.__default", "docstring": "Returns the default value for this column to return\n when generating new instances.\n\n :return " }, { "code": "def post_worker_init(worker):\n quit_command = 'CTRL-BREAK' if sys.platform == 'win32' else 'CONTROL-C'\n sys.stdout.write(\n \"Django version {djangover}, Gunicorn version {gunicornver}, \"\n \"using settings {settings!r}\\n\"\n \"Starting development server at {urls}\\n\"\n \"Quit the server with {quit_command}.\\n\".format(\n djangover=django.get_version(),\n gunicornver=gunicorn.__version__,\n settings=os.environ.get('DJANGO_SETTINGS_MODULE'),\n urls=', '.join('http://{0}/'.format(b) for b in worker.cfg.bind),\n quit_command=quit_command,\n ),\n )", "docstring": "Hook into Gunicorn to display message after launching.\n\n This mimics the behaviour of Django's stock runserver command." }, { "code": "def dag(self) -> Tuple[Dict, Dict]:\n from pipelines import dags\n operations = self.operations.all().prefetch_related('downstream_operations')\n def get_downstream(op):\n return op.downstream_operations.values_list('id', flat=True)\n return dags.get_dag(operations, get_downstream)", "docstring": "Construct the DAG of this pipeline based on the its operations and their downstream." }, { "code": "def get_supervisor(func: types.AnyFunction) -> types.Supervisor:\n if not callable(func):\n raise TypeError(\"func is not callable\")\n if asyncio.iscoroutinefunction(func):\n supervisor = _async_supervisor\n else:\n supervisor = _sync_supervisor\n return functools.partial(supervisor, func)", "docstring": "Get the appropriate supervisor to use and pre-apply the function.\n\n Args:\n func: A function." }, { "code": "def download(url, proxies=None):\n if proxies is None:\n proxies = [\"\"]\n for proxy in proxies:\n if proxy == \"\":\n socket.socket = DEFAULT_SOCKET\n elif proxy.startswith('socks'):\n if proxy[5] == '4':\n proxy_type = socks.SOCKS4\n else:\n proxy_type = socks.SOCKS5\n proxy = proxy[proxy.find('://') + 3:]\n try:\n proxy, port = proxy.split(':')\n except ValueError:\n port = None\n socks.set_default_proxy(proxy_type, proxy, port)\n socket.socket = socks.socksocket\n else:\n try:\n proxy, port = proxy.split(':')\n except ValueError:\n port = None\n socks.set_default_proxy(socks.HTTP, proxy, port)\n socket.socket = socks.socksocket\n downloaded = _download_helper(url)\n if downloaded is not None:\n return downloaded\n return (None, None)", "docstring": "Download a PDF or DJVU document from a url, eventually using proxies.\n\n :params url: The URL to the PDF/DJVU document to fetch.\n :params proxies: An optional list of proxies to use. Proxies will be \\\n used sequentially. Proxies should be a list of proxy strings. \\\n Do not forget to include ``\"\"`` (empty string) in the list if \\\n you want to try direct fetching without any proxy.\n\n :returns: A tuple of the raw content of the downloaded data and its \\\n associated content-type. Returns ``(None, None)`` if it was \\\n unable to download the document.\n\n >>> download(\"http://arxiv.org/pdf/1312.4006.pdf\") # doctest: +SKIP" }, { "code": "def selected(self, interrupt=False):\n self.ao2.output(self.get_title(), interrupt=interrupt)", "docstring": "This object has been selected." }, { "code": "def vote_poll(\n self,\n chat_id: Union[int, str],\n message_id: id,\n option: int\n ) -> bool:\n poll = self.get_messages(chat_id, message_id).poll\n self.send(\n functions.messages.SendVote(\n peer=self.resolve_peer(chat_id),\n msg_id=message_id,\n options=[poll.options[option].data]\n )\n )\n return True", "docstring": "Use this method to vote a poll.\n\n Args:\n chat_id (``int`` | ``str``):\n Unique identifier (int) or username (str) of the target chat.\n For your personal cloud (Saved Messages) you can simply use \"me\" or \"self\".\n For a contact that exists in your Telegram address book you can use his phone number (str).\n\n message_id (``int``):\n Unique poll message identifier inside this chat.\n\n option (``int``):\n Index of the poll option you want to vote for (0 to 9).\n\n Returns:\n On success, True is returned.\n\n Raises:\n :class:`RPCError ` in case of a Telegram RPC error." }, { "code": "def is_after(self, ts):\n if self.timestamp >= int(calendar.timegm(ts.timetuple())):\n return True\n return False", "docstring": "Compare this event's timestamp to a give timestamp." }, { "code": "def read_file(filename):\n if os.path.isfile(filename):\n with open(filename, 'r') as f:\n return f.read()", "docstring": "return the contents of the file named filename or None if file not found" }, { "code": "def frame_info(self):\n if not self._logger.isEnabledFor(logging.DEBUG):\n return ''\n f = sys._getframe(3)\n fname = os.path.split(f.f_code.co_filename)[1]\n return '{}:{}'.format(fname, f.f_lineno)", "docstring": "Return a string identifying the current frame." }, { "code": "def _compare_columns(self, new_columns, old_columns):\n add_columns = {}\n remove_columns = {}\n rename_columns = {}\n retype_columns = {}\n resize_columns = {}\n for key, value in new_columns.items():\n if key not in old_columns.keys():\n add_columns[key] = True\n if value[2]:\n if value[2] in old_columns.keys():\n rename_columns[key] = value[2]\n del add_columns[key]\n else:\n if value[1] != old_columns[key][1]:\n retype_columns[key] = value[1]\n if value[3] != old_columns[key][3]:\n resize_columns[key] = value[3]\n remove_keys = set(old_columns.keys()) - set(new_columns.keys())\n if remove_keys:\n for key in list(remove_keys):\n remove_columns[key] = True\n return add_columns, remove_columns, rename_columns, retype_columns, resize_columns", "docstring": "a helper method for generating differences between column properties" }, { "code": "def __select_builder(lxml_builder, libxml2_builder, cmdline_builder):\n if prefer_xsltproc:\n return cmdline_builder\n if not has_libxml2:\n if has_lxml:\n return lxml_builder\n else:\n return cmdline_builder\n return libxml2_builder", "docstring": "Selects a builder, based on which Python modules are present." }, { "code": "def _anchor_path(self, anchor_id):\n \"Absolute path to the data file for `anchor_id`.\"\n file_name = '{}.yml'.format(anchor_id)\n file_path = self._spor_dir / file_name\n return file_path", "docstring": "Absolute path to the data file for `anchor_id`." }, { "code": "def include_fields(self, *args):\n r\n for arg in args:\n self._includefields.append(arg)\n return self", "docstring": "r\"\"\"\n Include fields is the fields that you want to be returned when\n searching. These are in addition to the fields that are always\n included below.\n\n :param args: items passed in will be turned into a list\n :returns: :class:`Search`\n\n >>> bugzilla.search_for.include_fields(\"flags\")\n\n The following fields are always included in search:\n 'version', 'id', 'summary', 'status', 'op_sys',\n 'resolution', 'product', 'component', 'platform'" }, { "code": "def reset_config(ip, mac):\n click.echo(\"Reset configuration of button %s...\" % ip)\n data = {\n 'single': \"\",\n 'double': \"\",\n 'long': \"\",\n 'touch': \"\",\n }\n request = requests.post(\n 'http://{}/{}/{}/'.format(ip, URI, mac), data=data, timeout=TIMEOUT)\n if request.status_code == 200:\n click.echo(\"Reset configuration of %s\" % mac)", "docstring": "Reset the current configuration of a myStrom WiFi Button." }, { "code": "def is_base_datatype(datatype, version=None):\n if version is None:\n version = get_default_version()\n lib = load_library(version)\n return lib.is_base_datatype(datatype)", "docstring": "Check if the given datatype is a base datatype of the specified version\n\n :type datatype: ``str``\n :param datatype: the datatype (e.g. ST)\n\n :type version: ``str``\n :param version: the HL7 version (e.g. 2.5)\n\n :return: ``True`` if it is a base datatype, ``False`` otherwise\n\n >>> is_base_datatype('ST')\n True\n >>> is_base_datatype('CE')\n False" }, { "code": "def _add_parameters(self, parameter_map, parameter_list):\n for parameter in parameter_list:\n if parameter.get('$ref'):\n parameter = self.specification['parameters'].get(parameter.get('$ref').split('/')[-1])\n parameter_map[parameter['name']] = parameter", "docstring": "Populates the given parameter map with the list of parameters provided, resolving any reference objects encountered.\n\n Args:\n parameter_map: mapping from parameter names to parameter objects\n parameter_list: list of either parameter objects or reference objects" }, { "code": "def comments(accountable):\n comments = accountable.issue_comments()\n headers = sorted(['author_name', 'body', 'updated'])\n if comments:\n rows = [[v for k, v in sorted(c.items()) if k in headers]\n for c in comments]\n rows.insert(0, headers)\n print_table(SingleTable(rows))\n else:\n click.secho('No comments found for {}'.format(\n accountable.issue_key\n ), fg='red')", "docstring": "Lists all comments for a given issue key." }, { "code": "def _on_split_requested(self):\n orientation = self.sender().text()\n widget = self.widget(self.tab_under_menu())\n if 'horizontally' in orientation:\n self.split_requested.emit(\n widget, QtCore.Qt.Horizontal)\n else:\n self.split_requested.emit(\n widget, QtCore.Qt.Vertical)", "docstring": "Emits the split requested signal with the desired orientation." }, { "code": "def _get_ln_a_n_max(self, C, n_sites, idx, rup):\n ln_a_n_max = C[\"lnSC1AM\"] * np.ones(n_sites)\n for i in [2, 3, 4]:\n if np.any(idx[i]):\n ln_a_n_max[idx[i]] += C[\"S{:g}\".format(i)]\n return ln_a_n_max", "docstring": "Defines the rock site amplification defined in equations 10a and 10b" }, { "code": "def code_timer(reset=False):\n global CODE_TIMER\n if reset:\n CODE_TIMER = CodeTimer()\n else:\n if CODE_TIMER is None:\n return CodeTimer()\n else:\n return CODE_TIMER", "docstring": "Sets a global variable for tracking the timer accross multiple\n files" }, { "code": "def show_disk(name=None, kwargs=None, call=None):\n if not kwargs or 'disk_name' not in kwargs:\n log.error(\n 'Must specify disk_name.'\n )\n return False\n conn = get_conn()\n return _expand_disk(conn.ex_get_volume(kwargs['disk_name']))", "docstring": "Show the details of an existing disk.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt-cloud -a show_disk myinstance disk_name=mydisk\n salt-cloud -f show_disk gce disk_name=mydisk" }, { "code": "def compose(f: Callable[[Any], Monad], g: Callable[[Any], Monad]) -> Callable[[Any], Monad]:\n r\n return lambda x: g(x).bind(f)", "docstring": "r\"\"\"Monadic compose function.\n\n Right-to-left Kleisli composition of two monadic functions.\n\n (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c\n f <=< g = \\x -> g x >>= f" }, { "code": "def tone_marks():\n return RegexBuilder(\n pattern_args=symbols.TONE_MARKS,\n pattern_func=lambda x: u\"(?<={}).\".format(x)).regex", "docstring": "Keep tone-modifying punctuation by matching following character.\n\n Assumes the `tone_marks` pre-processor was run for cases where there might\n not be any space after a tone-modifying punctuation mark." }, { "code": "def requires_lock(function):\n def new_lock_requiring_function(self, filename, *args, **kwargs):\n if self.owns_lock(filename):\n return function(self, filename, *args, **kwargs)\n else:\n raise RequiresLockException()\n return new_lock_requiring_function", "docstring": "Decorator to check if the user owns the required lock.\n The first argument must be the filename." }, { "code": "def close(self):\n if self._mode == _MODE_CLOSED:\n return\n try:\n if self._mode in (_MODE_READ, _MODE_READ_EOF):\n self._decompressor = None\n self._buffer = None\n elif self._mode == _MODE_WRITE:\n self._fp.write(self._compressor.flush())\n self._compressor = None\n finally:\n try:\n if self._closefp:\n self._fp.close()\n finally:\n self._fp = None\n self._closefp = False\n self._mode = _MODE_CLOSED", "docstring": "Flush and close the file.\n\n May be called more than once without error. Once the file is\n closed, any other operation on it will raise a ValueError." }, { "code": "def libvlc_media_list_new(p_instance):\n f = _Cfunctions.get('libvlc_media_list_new', None) or \\\n _Cfunction('libvlc_media_list_new', ((1,),), class_result(MediaList),\n ctypes.c_void_p, Instance)\n return f(p_instance)", "docstring": "Create an empty media list.\n @param p_instance: libvlc instance.\n @return: empty media list, or NULL on error." }, { "code": "def r2z(r):\n with np.errstate(invalid='ignore', divide='ignore'):\n return 0.5 * (np.log(1 + r) - np.log(1 - r))", "docstring": "Function that calculates the Fisher z-transformation\n\n Parameters\n ----------\n r : int or ndarray\n Correlation value\n\n Returns\n ----------\n result : int or ndarray\n Fishers z transformed correlation value" }, { "code": "def detect_encoding(fp, default=None):\n init_pos = fp.tell()\n try:\n sample = fp.read(\n current_app.config.get('PREVIEWER_CHARDET_BYTES', 1024))\n result = cchardet.detect(sample)\n threshold = current_app.config.get('PREVIEWER_CHARDET_CONFIDENCE', 0.9)\n if result.get('confidence', 0) > threshold:\n return result.get('encoding', default)\n else:\n return default\n except Exception:\n current_app.logger.warning('Encoding detection failed.', exc_info=True)\n return default\n finally:\n fp.seek(init_pos)", "docstring": "Detect the cahracter encoding of a file.\n\n :param fp: Open Python file pointer.\n :param default: Fallback encoding to use.\n :returns: The detected encoding.\n\n .. note:: The file pointer is returned at its original read position." }, { "code": "def friendships_create(self, user_id=None, screen_name=None,\n follow=None):\n params = {}\n set_str_param(params, 'user_id', user_id)\n set_str_param(params, 'screen_name', screen_name)\n set_bool_param(params, 'follow', follow)\n return self._post_api('friendships/create.json', params)", "docstring": "Allows the authenticating users to follow the specified user.\n\n https://dev.twitter.com/docs/api/1.1/post/friendships/create\n\n :param str user_id:\n The screen name of the user for whom to befriend. Required if\n ``screen_name`` isn't given.\n :param str screen_name:\n The ID of the user for whom to befriend. Required if ``user_id``\n isn't given.\n :param bool follow:\n Enable notifications for the target user.\n\n :returns:\n A dict containing the newly followed user." }, { "code": "def remove_option(self, section, name, value=None):\n if self._is_live():\n raise RuntimeError('Submitted units cannot update their options')\n removed = 0\n for option in list(self._data['options']):\n if option['section'] == section:\n if option['name'] == name:\n if value is None or option['value'] == value:\n self._data['options'].remove(option)\n removed += 1\n if removed > 0:\n return True\n return False", "docstring": "Remove an option from a unit\n\n Args:\n section (str): The section to remove from.\n name (str): The item to remove.\n value (str, optional): If specified, only the option matching this value will be removed\n If not specified, all options with ``name`` in ``section`` will be removed\n\n Returns:\n True: At least one item was removed\n False: The item requested to remove was not found" }, { "code": "def getAtomLinesForResidueInRosettaStructure(self, resid):\n lines = [line for line in self.lines if line[0:4] == \"ATOM\" and resid == int(line[22:27])]\n if not lines:\n raise Exception(\"Could not find the ATOM/HETATM line corresponding to residue '%(resid)s'.\" % vars())\n return lines", "docstring": "We assume a Rosetta-generated structure where residues are uniquely identified by number." }, { "code": "def kabsch_rmsd(P, Q, translate=False):\n if translate:\n Q = Q - centroid(Q)\n P = P - centroid(P)\n P = kabsch_rotate(P, Q)\n return rmsd(P, Q)", "docstring": "Rotate matrix P unto Q using Kabsch algorithm and calculate the RMSD.\n\n Parameters\n ----------\n P : array\n (N,D) matrix, where N is points and D is dimension.\n Q : array\n (N,D) matrix, where N is points and D is dimension.\n translate : bool\n Use centroids to translate vector P and Q unto each other.\n\n Returns\n -------\n rmsd : float\n root-mean squared deviation" }, { "code": "def hidden_cursor(self):\n self.stream.write(self.hide_cursor)\n try:\n yield\n finally:\n self.stream.write(self.normal_cursor)", "docstring": "Return a context manager that hides the cursor while inside it and\n makes it visible on leaving." }, { "code": "def is_analyst_assignment_allowed(self):\n if not self.allow_edit:\n return False\n if not self.can_manage:\n return False\n if self.filter_by_user:\n return False\n return True", "docstring": "Check if the analyst can be assigned" }, { "code": "def inserted_hs_indices(self):\n if self.dimension_type in DT.ARRAY_TYPES:\n return []\n return [\n idx\n for idx, item in enumerate(\n self._iter_interleaved_items(self.valid_elements)\n )\n if item.is_insertion\n ]", "docstring": "list of int index of each inserted subtotal for the dimension.\n\n Each value represents the position of a subtotal in the interleaved\n sequence of elements and subtotals items." }, { "code": "def get_branching_nodes(self):\n nodes = set()\n for n in self.graph.nodes():\n if self.graph.out_degree(n) >= 2:\n nodes.add(n)\n return nodes", "docstring": "Returns all nodes that has an out degree >= 2" }, { "code": "def nodes_with_role(rolename):\n nodes = [n['name'] for n in\n lib.get_nodes_with_role(rolename, env.chef_environment)]\n if not len(nodes):\n print(\"No nodes found with role '{0}'\".format(rolename))\n sys.exit(0)\n return node(*nodes)", "docstring": "Configures a list of nodes that have the given role in their run list" }, { "code": "def get_all_parents(self):\n ownership = Ownership.objects.filter(child=self)\n parents = Company.objects.filter(parent__in=ownership)\n for parent in parents:\n parents = parents | parent.get_all_parents()\n return parents", "docstring": "Return all parents of this company." }, { "code": "def _get_all_run_infos(self):\n info_dir = self._settings.info_dir\n if not os.path.isdir(info_dir):\n return []\n paths = [os.path.join(info_dir, x) for x in os.listdir(info_dir)]\n return [d for d in\n [RunInfo(os.path.join(p, 'info')).get_as_dict() for p in paths\n if os.path.isdir(p) and not os.path.islink(p)]\n if 'timestamp' in d]", "docstring": "Find the RunInfos for all runs since the last clean-all." }, { "code": "def register_service(service):\n frame = inspect.currentframe()\n m_name = frame.f_back.f_globals['__name__']\n m = sys.modules[m_name]\n m._SERVICE_NAME = service", "docstring": "Register the ryu application specified by 'service' as\n a provider of events defined in the calling module.\n\n If an application being loaded consumes events (in the sense of\n set_ev_cls) provided by the 'service' application, the latter\n application will be automatically loaded.\n\n This mechanism is used to e.g. automatically start ofp_handler if\n there are applications consuming OFP events." }, { "code": "def _looks_like_numpy_function(func_name, numpy_module_name, node):\n return node.name == func_name and node.parent.name == numpy_module_name", "docstring": "Return True if the current node correspond to the function inside\n the numpy module in parameters\n\n :param node: the current node\n :type node: FunctionDef\n :param func_name: name of the function\n :type func_name: str\n :param numpy_module_name: name of the numpy module\n :type numpy_module_name: str\n :return: True if the current node correspond to the function looked for\n :rtype: bool" }, { "code": "def size_in_bytes(self, offset, timestamp, key, value, headers=None):\n assert not headers, \"Headers not supported in v0/v1\"\n magic = self._magic\n return self.LOG_OVERHEAD + self.record_size(magic, key, value)", "docstring": "Actual size of message to add" }, { "code": "def validate_callback(callback):\n if not(hasattr(callback, '_validated')) or callback._validated == False:\n assert hasattr(callback, 'on_loop_start') \\\n or hasattr(callback, 'on_loop_end'), \\\n 'callback must have `on_loop_start` or `on_loop_end` method'\n if hasattr(callback, 'on_loop_start'):\n setattr(callback, 'on_loop_start',\n validate_callback_data(callback.on_loop_start))\n if hasattr(callback, 'on_loop_end'):\n setattr(callback, 'on_loop_end',\n validate_callback_data(callback.on_loop_end))\n setattr(callback, '_validated', True)\n return callback", "docstring": "validates a callback's on_loop_start and on_loop_end methods\n\n Parameters\n ----------\n callback : Callback object\n\n Returns\n -------\n validated callback" }, { "code": "def _looks_like_resource_file(self, name):\n if (re.search(r'__init__.(txt|robot|html|tsv)$', name)):\n return False\n found_keyword_table = False\n if (name.lower().endswith(\".robot\") or\n name.lower().endswith(\".txt\") or\n name.lower().endswith(\".tsv\")):\n with open(name, \"r\") as f:\n data = f.read()\n for match in re.finditer(r'^\\*+\\s*(Test Cases?|(?:User )?Keywords?)',\n data, re.MULTILINE|re.IGNORECASE):\n if (re.match(r'Test Cases?', match.group(1), re.IGNORECASE)):\n return False\n if (not found_keyword_table and\n re.match(r'(User )?Keywords?', match.group(1), re.IGNORECASE)):\n found_keyword_table = True\n return found_keyword_table", "docstring": "Return true if the file has a keyword table but not a testcase table" }, { "code": "def lstltc(string, n, lenvals, array):\n string = stypes.stringToCharP(string)\n array = stypes.listToCharArrayPtr(array, xLen=lenvals, yLen=n)\n n = ctypes.c_int(n)\n lenvals = ctypes.c_int(lenvals)\n return libspice.lstltc_c(string, n, lenvals, array)", "docstring": "Given a character string and an ordered array of character\n strings, find the index of the largest array element less than\n the given string.\n\n http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/lstltc_c.html\n\n :param string: Upper bound value to search against.\n :type string: int\n :param n: Number elements in array.\n :type n: int\n :param lenvals: String length.\n :type lenvals: int\n :param array: Array of possible lower bounds\n :type array: list\n :return:\n index of the last element of array that\n is lexically less than string.\n :rtype: int" }, { "code": "def _q_iteration(self, Q, Bpp_solver, Vm, Va, pq):\n dVm = -Bpp_solver.solve(Q)\n Vm[pq] = Vm[pq] + dVm\n V = Vm * exp(1j * Va)\n return V, Vm, Va", "docstring": "Performs a Q iteration, updates Vm." }, { "code": "def elapsed(self, label=None, total=True):\n t = timer()\n if label is None:\n label = self.dfltlbl\n if label not in self.t0:\n return 0.0\n if label not in self.t0:\n raise KeyError('Unrecognized timer key %s' % label)\n te = 0.0\n if self.t0[label] is not None:\n te = t - self.t0[label]\n if total:\n te += self.td[label]\n return te", "docstring": "Get elapsed time since timer start.\n\n Parameters\n ----------\n label : string, optional (default None)\n Specify the label of the timer for which the elapsed time is\n required. If it is ``None``, the default timer with label\n specified by the ``dfltlbl`` parameter of :meth:`__init__`\n is selected.\n total : bool, optional (default True)\n If ``True`` return the total elapsed time since the first\n call of :meth:`start` for the selected timer, otherwise\n return the elapsed time since the most recent call of\n :meth:`start` for which there has not been a corresponding\n call to :meth:`stop`.\n\n Returns\n -------\n dlt : float\n Elapsed time" }, { "code": "def setup(self):\n if not self.networks():\n for _ in range(self.practice_repeats):\n network = self.create_network()\n network.role = \"practice\"\n self.session.add(network)\n for _ in range(self.experiment_repeats):\n network = self.create_network()\n network.role = \"experiment\"\n self.session.add(network)\n self.session.commit()", "docstring": "Create the networks if they don't already exist." }, { "code": "def select_and_start_cluster(self, platform):\n clusters = self.reactor_config.get_enabled_clusters_for_platform(platform)\n if not clusters:\n raise UnknownPlatformException('No clusters found for platform {}!'\n .format(platform))\n retry_contexts = {\n cluster.name: ClusterRetryContext(self.max_cluster_fails)\n for cluster in clusters\n }\n while True:\n try:\n possible_cluster_info = self.get_clusters(platform,\n retry_contexts,\n clusters)\n except AllClustersFailedException as ex:\n cluster = ClusterInfo(None, platform, None, None)\n build_info = WorkerBuildInfo(build=None,\n cluster_info=cluster,\n logger=self.log)\n build_info.monitor_exception = repr(ex)\n self.worker_builds.append(build_info)\n return\n for cluster_info in possible_cluster_info:\n ctx = retry_contexts[cluster_info.cluster.name]\n try:\n self.log.info('Attempting to start build for platform %s on cluster %s',\n platform, cluster_info.cluster.name)\n self.do_worker_build(cluster_info)\n return\n except OsbsException:\n ctx.try_again_later(self.failure_retry_delay)", "docstring": "Choose a cluster and start a build on it" }, { "code": "def get(self):\n content = {}\n if self.mime_type is not None:\n content[\"type\"] = self.mime_type\n if self.content is not None:\n content[\"value\"] = self.content\n return content", "docstring": "Get a JSON-ready representation of this HtmlContent.\n\n :returns: This HtmlContent, ready for use in a request body.\n :rtype: dict" }, { "code": "def _index_entities(self):\n all_ents = pd.DataFrame.from_records(\n [v.entities for v in self.variables.values()])\n constant = all_ents.apply(lambda x: x.nunique() == 1)\n if constant.empty:\n self.entities = {}\n else:\n keep = all_ents.columns[constant]\n ents = {k: all_ents[k].dropna().iloc[0] for k in keep}\n self.entities = {k: v for k, v in ents.items() if pd.notnull(v)}", "docstring": "Sets current instance's entities based on the existing index.\n\n Note: Only entity key/value pairs common to all rows in all contained\n Variables are returned. E.g., if a Collection contains Variables\n extracted from runs 1, 2 and 3 from subject '01', the returned dict\n will be {'subject': '01'}; the runs will be excluded as they vary\n across the Collection contents." }, { "code": "def load_glove(file):\n model = {}\n with open(file, encoding=\"utf8\", errors='ignore') as f:\n for line in f:\n line = line.split(' ')\n word = line[0]\n vector = np.array([float(val) for val in line[1:]])\n model[word] = vector\n return model", "docstring": "Loads GloVe vectors in numpy array.\n\n Args:\n file (str): a path to a glove file.\n\n Return:\n dict: a dict of numpy arrays." }, { "code": "def clear(self, contours=True, components=True, anchors=True,\n guidelines=True, image=True):\n self._clear(contours=contours, components=components,\n anchors=anchors, guidelines=guidelines, image=image)", "docstring": "Clear the glyph.\n\n >>> glyph.clear()\n\n This clears:\n\n - contours\n - components\n - anchors\n - guidelines\n - image\n\n It's possible to turn off the clearing of portions of\n the glyph with the listed arguments.\n\n >>> glyph.clear(guidelines=False)" }, { "code": "def _del_module(self, lpBaseOfDll):\n try:\n aModule = self.__moduleDict[lpBaseOfDll]\n del self.__moduleDict[lpBaseOfDll]\n except KeyError:\n aModule = None\n msg = \"Unknown base address %d\" % HexDump.address(lpBaseOfDll)\n warnings.warn(msg, RuntimeWarning)\n if aModule:\n aModule.clear()", "docstring": "Private method to remove a module object from the snapshot.\n\n @type lpBaseOfDll: int\n @param lpBaseOfDll: Module base address." }, { "code": "def asDictionary(self):\n template = {\n \"xmin\" : self._xmin,\n \"ymin\" : self._ymin,\n \"xmax\" : self._xmax,\n \"ymax\" : self._ymax,\n \"spatialReference\" : self.spatialReference\n }\n if self._zmax is not None and \\\n self._zmin is not None:\n template['zmin'] = self._zmin\n template['zmax'] = self._zmax\n if self._mmin is not None and \\\n self._mmax is not None:\n template['mmax'] = self._mmax\n template['mmin'] = self._mmin\n return template", "docstring": "returns the envelope as a dictionary" }, { "code": "def start_recording(self, file='mingus_dump.wav'):\n w = wave.open(file, 'wb')\n w.setnchannels(2)\n w.setsampwidth(2)\n w.setframerate(44100)\n self.wav = w", "docstring": "Initialize a new wave file for recording." }, { "code": "def paginator(context, adjacent_pages=2):\r\n current_page = context.get('page')\r\n paginator = context.get('paginator')\r\n if not paginator:\r\n return\r\n pages = paginator.num_pages\r\n current_range = range(current_page - adjacent_pages, current_page + adjacent_pages + 1)\r\n page_numbers = [n for n in current_range if n > 0 and n <= pages]\r\n slugtype = ''\r\n if 'topic_slug' in context:\r\n page_url = context[\"topic\"].get_short_url()\r\n slugtype = 'topic'\r\n elif 'forum_slug' in context:\r\n page_url = '/forum/%s/' % context[\"forum_slug\"]\r\n slugtype = 'forum'\r\n else:\r\n page_url = context['request'].get_full_path()\r\n return {\r\n \"is_paginated\": context[\"is_paginated\"],\r\n \"page\": current_page,\r\n \"pages\": pages,\r\n \"page_obj\": context['page_obj'],\r\n \"page_numbers\": page_numbers,\r\n \"has_next\": context[\"page_obj\"].has_next(),\r\n \"has_previous\": context[\"page_obj\"].has_previous(),\r\n \"page_url\" : page_url,\r\n 'slugtype' : slugtype,\r\n }", "docstring": "To be used in conjunction with the object_list generic view.\r\n Adds pagination context variables for use in displaying first, adjacent and\r\n last page links in addition to those created by the object_list generic view." }, { "code": "def compute_We(self, Eemin=None, Eemax=None):\n if Eemin is None and Eemax is None:\n We = self.We\n else:\n if Eemax is None:\n Eemax = self.Eemax\n if Eemin is None:\n Eemin = self.Eemin\n log10gmin = np.log10(Eemin / mec2).value\n log10gmax = np.log10(Eemax / mec2).value\n gam = np.logspace(\n log10gmin, log10gmax, int(self.nEed * (log10gmax - log10gmin))\n )\n nelec = (\n self.particle_distribution(gam * mec2).to(1 / mec2_unit).value\n )\n We = trapz_loglog(gam * nelec, gam * mec2)\n return We", "docstring": "Total energy in electrons between energies Eemin and Eemax\n\n Parameters\n ----------\n Eemin : :class:`~astropy.units.Quantity` float, optional\n Minimum electron energy for energy content calculation.\n\n Eemax : :class:`~astropy.units.Quantity` float, optional\n Maximum electron energy for energy content calculation." }, { "code": "def getChemicalPotential(self, solution):\n if isinstance(solution, Solution):\n solution = solution.getSolution()\n self.mu = self.solver.chemicalPotential(solution)\n return self.mu", "docstring": "Call solver in order to calculate chemical potential." }, { "code": "def get_bug_report():\n platform_info = BugReporter.get_platform_info()\n module_info = {\n 'version': hal_version.__version__,\n 'build': hal_version.__build__\n }\n return {\n 'platform': platform_info,\n 'pyhal': module_info\n }", "docstring": "Generate information for a bug report\n\n :return: information for bug report" }, { "code": "def create(self, name, redirect_uri=None):\n data = dict(name=name)\n if redirect_uri:\n data['redirect_uri'] = redirect_uri\n auth_request_resource = self.resource.create(data)\n return (auth_request_resource.attributes['metadata']['device_token'],\n auth_request_resource.attributes['mfa_uri'])", "docstring": "Create a new Device object.\n\n Devices tie Users and Applications together. For your Application to\n access and act on behalf of a User, the User must authorize a Device\n created by your Application.\n\n This function will return a `device_token` which you must store and use\n after the Device is approved in\n `client.authenticate_device(api_token, device_token)`\n\n The second value returned is an `mfa_uri` which is the location the User\n must visit to approve the new device. After this function completes,\n you should launch a new browser tab or webview with this value as the\n location. After the User approves the Device, they will be redirected to\n the redirect_uri you specify in this call.\n\n Args:\n name (str): Human-readable name for the device\n (e.g. \"Suzanne's iPhone\")\n redirect_uri (str, optional): A URI to which to redirect the User after\n they approve the new Device.\n\n Returns: A tuple of (device_token, mfa_uri)" }, { "code": "def add_arrow(self, tipLoc, tail=None, arrow=arrow.default):\n self._arrows.append((tipLoc, tail, arrow))", "docstring": "This method adds a straight arrow that points to\n @var{TIPLOC}, which is a tuple of integers. @var{TAIL}\n specifies the starting point of the arrow. It is either None\n or a string consisting of the following letters: 'l', 'c',\n 'r', 't', 'm,', and 'b'. Letters 'l', 'c', or 'r' means to\n start the arrow from the left, center, or right of the text\n box, respectively. Letters 't', 'm', or 'b' means to start the\n arrow from the top, middle or bottom of the text box. For\n example, when @samp{tail = 'tc'} then arrow is drawn from\n top-center point of the text box. ARROW specifies the style of\n the arrow. <>." }, { "code": "def contains(self, key):\n try:\n self._api.objects_get(self._bucket, key)\n except datalab.utils.RequestException as e:\n if e.status == 404:\n return False\n raise e\n except Exception as e:\n raise e\n return True", "docstring": "Checks if the specified item exists.\n\n Args:\n key: the key of the item to lookup.\n Returns:\n True if the item exists; False otherwise.\n Raises:\n Exception if there was an error requesting information about the item." }, { "code": "def set_spacing(self, new_spacing):\n if not isinstance(new_spacing, (tuple, list)):\n raise ValueError('arg must be tuple or list')\n if len(new_spacing) != self.dimension:\n raise ValueError('must give a spacing value for each dimension (%i)' % self.dimension)\n libfn = utils.get_lib_fn('setSpacing%s'%self._libsuffix)\n libfn(self.pointer, new_spacing)", "docstring": "Set image spacing\n\n Arguments\n ---------\n new_spacing : tuple or list\n updated spacing for the image.\n should have one value for each dimension\n\n Returns\n -------\n None" }, { "code": "def check_cmake_exists(cmake_command):\n from subprocess import Popen, PIPE\n p = Popen(\n '{0} --version'.format(cmake_command),\n shell=True,\n stdin=PIPE,\n stdout=PIPE)\n if not ('cmake version' in p.communicate()[0].decode('UTF-8')):\n sys.stderr.write(' This code is built using CMake\\n\\n')\n sys.stderr.write(' CMake is not found\\n')\n sys.stderr.write(' get CMake at http://www.cmake.org/\\n')\n sys.stderr.write(' on many clusters CMake is installed\\n')\n sys.stderr.write(' but you have to load it first:\\n')\n sys.stderr.write(' $ module load cmake\\n')\n sys.exit(1)", "docstring": "Check whether CMake is installed. If not, print\n informative error message and quits." }, { "code": "async def logs(\n self,\n service_id: str,\n *,\n details: bool = False,\n follow: bool = False,\n stdout: bool = False,\n stderr: bool = False,\n since: int = 0,\n timestamps: bool = False,\n is_tty: bool = False,\n tail: str = \"all\"\n ) -> Union[str, AsyncIterator[str]]:\n if stdout is False and stderr is False:\n raise TypeError(\"Need one of stdout or stderr\")\n params = {\n \"details\": details,\n \"follow\": follow,\n \"stdout\": stdout,\n \"stderr\": stderr,\n \"since\": since,\n \"timestamps\": timestamps,\n \"tail\": tail,\n }\n response = await self.docker._query(\n \"services/{service_id}/logs\".format(service_id=service_id),\n method=\"GET\",\n params=params,\n )\n return await multiplexed_result(response, follow, is_tty=is_tty)", "docstring": "Retrieve logs of the given service\n\n Args:\n details: show service context and extra details provided to logs\n follow: return the logs as a stream.\n stdout: return logs from stdout\n stderr: return logs from stderr\n since: return logs since this time, as a UNIX timestamp\n timestamps: add timestamps to every log line\n is_tty: the service has a pseudo-TTY allocated\n tail: only return this number of log lines\n from the end of the logs, specify as an integer\n or `all` to output all log lines." }, { "code": "def pad_sentences(sentences, padding_word=\"\"):\n sequence_length = max(len(x) for x in sentences)\n padded_sentences = []\n for i, sentence in enumerate(sentences):\n num_padding = sequence_length - len(sentence)\n new_sentence = sentence + [padding_word] * num_padding\n padded_sentences.append(new_sentence)\n return padded_sentences", "docstring": "Pads all sentences to the same length. The length is defined by the longest sentence.\n Returns padded sentences." }, { "code": "def exists(self, digest):\n return self.conn.client.blob_exists(self.container_name, digest)", "docstring": "Check if a blob exists\n\n :param digest: Hex digest of the blob\n :return: Boolean indicating existence of the blob" }, { "code": "def _update(self, **kwargs):\n path = self._construct_path_to_item()\n if not kwargs:\n return\n return self._http.put(path, json.dumps(kwargs))", "docstring": "Update a resource in a remote Transifex server." }, { "code": "def get_record_value(request, uid, keyword, default=None):\n value = request.get(keyword)\n if not value:\n return default\n if not isinstance(value, list):\n return default\n return value[0].get(uid, default) or default", "docstring": "Returns the value for the keyword and uid from the request" }, { "code": "def abort(status_code, message=None):\n if message is None:\n message = STATUS_CODES.get(status_code)\n message = message.decode(\"utf8\")\n sanic_exception = _sanic_exceptions.get(status_code, SanicException)\n raise sanic_exception(message=message, status_code=status_code)", "docstring": "Raise an exception based on SanicException. Returns the HTTP response\n message appropriate for the given status code, unless provided.\n\n :param status_code: The HTTP status code to return.\n :param message: The HTTP response body. Defaults to the messages\n in response.py for the given status code." }, { "code": "def _prepare_resource_chunks(self, resources, resource_delim=','):\n return [self._prepare_resource_chunk(resources, resource_delim, pos)\n for pos in range(0, len(resources), self._resources_per_req)]", "docstring": "As in some VirusTotal API methods the call can be made for multiple\n resources at once this method prepares a list of concatenated resources\n according to the maximum number of resources per requests.\n\n Args:\n resources: a list of the resources.\n resource_delim: a string used to separate the resources.\n Default value is a comma.\n Returns:\n A list of the concatenated resources." }, { "code": "def row(self, data):\n for column in self.column_funcs:\n if callable(column):\n yield column(data)\n else:\n yield utils.lookup(data, *column)", "docstring": "Return a formatted row for the given data." }, { "code": "def add(self, uuid):\n if uuid:\n try:\n x = hash64(uuid)\n except UnicodeEncodeError:\n x = hash64(uuid.encode('ascii', 'ignore'))\n j = x & ((1 << self.b) - 1)\n w = x >> self.b\n self.M[j] = max(self.M[j], self._get_rho(w, self.bitcount_arr))", "docstring": "Adds a key to the HyperLogLog" }, { "code": "def update_buttons(self):\n current_scheme = self.current_scheme\n names = self.get_option(\"names\")\n try:\n names.pop(names.index(u'Custom'))\n except ValueError:\n pass\n delete_enabled = current_scheme not in names\n self.delete_button.setEnabled(delete_enabled)\n self.reset_button.setEnabled(not delete_enabled)", "docstring": "Updates the enable status of delete and reset buttons." }, { "code": "def split_arguments(args):\n prev = False\n for i, value in enumerate(args[1:]):\n if value.startswith('-'):\n prev = True\n elif prev:\n prev = False\n else:\n return args[:i+1], args[i+1:]\n return args, []", "docstring": "Split specified arguments to two list.\n\n This is used to distinguish the options of the program and\n execution command/arguments.\n\n Parameters\n ----------\n args : list\n Command line arguments\n\n Returns\n -------\n list : options, arguments\n options indicate the optional arguments for the program and\n arguments indicate the execution command/arguments" }, { "code": "def right(ctx, text, num_chars):\n num_chars = conversions.to_integer(num_chars, ctx)\n if num_chars < 0:\n raise ValueError(\"Number of chars can't be negative\")\n elif num_chars == 0:\n return ''\n else:\n return conversions.to_string(text, ctx)[-num_chars:]", "docstring": "Returns the last characters in a text string" }, { "code": "def get_route(self, route_id):\n raw = self.protocol.get('/routes/{id}', id=route_id)\n return model.Route.deserialize(raw, bind_client=self)", "docstring": "Gets specified route.\n\n Will be detail-level if owned by authenticated user; otherwise summary-level.\n\n https://strava.github.io/api/v3/routes/#retreive\n\n :param route_id: The ID of route to fetch.\n :type route_id: int\n\n :rtype: :class:`stravalib.model.Route`" }, { "code": "def merge_dicts(dict1, dict2, deep_merge=True):\n if deep_merge:\n if isinstance(dict1, list) and isinstance(dict2, list):\n return dict1 + dict2\n if not isinstance(dict1, dict) or not isinstance(dict2, dict):\n return dict2\n for key in dict2:\n dict1[key] = merge_dicts(dict1[key], dict2[key]) if key in dict1 else dict2[key]\n return dict1\n dict3 = dict1.copy()\n dict3.update(dict2)\n return dict3", "docstring": "Merge dict2 into dict1." }, { "code": "def delete(self):\n self.close()\n if self.does_file_exist():\n os.remove(self.path)", "docstring": "Delete the file." }, { "code": "def _overwrite(self, n):\n if os.path.isfile(n[:-4]):\n shutil.copy2(n[:-4], n[:-4] + \".old\")\n print(\"Old file {0} saved as {1}.old\".format(\n n[:-4].split(\"/\")[-1], n[:-4].split(\"/\")[-1]))\n if os.path.isfile(n):\n shutil.move(n, n[:-4])\n print(\"New file {0} overwrite as {1}\".format(\n n.split(\"/\")[-1], n[:-4].split(\"/\")[-1]))", "docstring": "Overwrite old file with new and keep file with suffix .old" }, { "code": "def create_d1_dn_subject(common_name_str):\n return cryptography.x509.Name(\n [\n cryptography.x509.NameAttribute(\n cryptography.x509.oid.NameOID.COUNTRY_NAME, \"US\"\n ),\n cryptography.x509.NameAttribute(\n cryptography.x509.oid.NameOID.STATE_OR_PROVINCE_NAME, \"California\"\n ),\n cryptography.x509.NameAttribute(\n cryptography.x509.oid.NameOID.LOCALITY_NAME, \"San Francisco\"\n ),\n cryptography.x509.NameAttribute(\n cryptography.x509.oid.NameOID.ORGANIZATION_NAME, \"Root CA\"\n ),\n cryptography.x509.NameAttribute(\n cryptography.x509.oid.NameOID.COMMON_NAME, \"ca.ca.com\"\n ),\n ]\n )", "docstring": "Create the DN Subject for certificate that will be used in a DataONE environment.\n\n The DN is formatted into a DataONE subject, which is used in authentication,\n authorization and event tracking.\n\n Args:\n common_name_str: str\n DataONE uses simple DNs without physical location information, so only the\n ``common_name_str`` (``CommonName``) needs to be specified.\n\n For Member Node Client Side certificates or CSRs, ``common_name_str`` is the\n ``node_id``, e.g., ``urn:node:ABCD`` for production, or\n ``urn:node:mnTestABCD`` for the test environments.\n\n For a local CA, something like ``localCA`` may be used.\n\n For a locally trusted client side certificate, something like\n ``localClient`` may be used." }, { "code": "def events(self, *events):\n return self.send_events(self.create_event(e) for e in events)", "docstring": "Sends multiple events in a single message\n\n >>> client.events({'service': 'riemann-client', 'state': 'awesome'})\n\n :param \\*events: event dictionaries for :py:func:`create_event`\n :returns: The response message from Riemann" }, { "code": "def has_path(self, path, method=None):\n method = self._normalize_method_name(method)\n path_dict = self.get_path(path)\n path_dict_exists = path_dict is not None\n if method:\n return path_dict_exists and method in path_dict\n return path_dict_exists", "docstring": "Returns True if this Swagger has the given path and optional method\n\n :param string path: Path name\n :param string method: HTTP method\n :return: True, if this path/method is present in the document" }, { "code": "def set_category(self, category):\n pcategory = self.find(\"general/category\")\n pcategory.clear()\n name = ElementTree.SubElement(pcategory, \"name\")\n if isinstance(category, Category):\n id_ = ElementTree.SubElement(pcategory, \"id\")\n id_.text = category.id\n name.text = category.name\n elif isinstance(category, basestring):\n name.text = category", "docstring": "Set the policy's category.\n\n Args:\n category: A category object." }, { "code": "def append_tag(self, field_number, wire_type):\n self._stream.append_var_uint32(wire_format.pack_tag(field_number, wire_type))", "docstring": "Appends a tag containing field number and wire type information." }, { "code": "def delete_operation(\n self, name, retry=gapic_v1.method.DEFAULT, timeout=gapic_v1.method.DEFAULT\n ):\n request = operations_pb2.DeleteOperationRequest(name=name)\n self._delete_operation(request, retry=retry, timeout=timeout)", "docstring": "Deletes a long-running operation.\n\n This method indicates that the client is no longer interested in the\n operation result. It does not cancel the operation.\n\n Example:\n >>> from google.api_core import operations_v1\n >>> api = operations_v1.OperationsClient()\n >>> name = ''\n >>> api.delete_operation(name)\n\n Args:\n name (str): The name of the operation resource to be deleted.\n retry (google.api_core.retry.Retry): The retry strategy to use\n when invoking the RPC. If unspecified, the default retry from\n the client configuration will be used. If ``None``, then this\n method will not retry the RPC at all.\n timeout (float): The amount of time in seconds to wait for the RPC\n to complete. Note that if ``retry`` is used, this timeout\n applies to each individual attempt and the overall time it\n takes for this method to complete may be longer. If\n unspecified, the the default timeout in the client\n configuration is used. If ``None``, then the RPC method will\n not time out.\n\n Raises:\n google.api_core.exceptions.MethodNotImplemented: If the server\n does not support this method. Services are not required to\n implement this method.\n google.api_core.exceptions.GoogleAPICallError: If an error occurred\n while invoking the RPC, the appropriate ``GoogleAPICallError``\n subclass will be raised." }, { "code": "async def enable_digital_reporting(self, command):\n pin = int(command[0])\n await self.core.enable_digital_reporting(pin)", "docstring": "Enable Firmata reporting for a digital pin.\n\n :param command: {\"method\": \"enable_digital_reporting\", \"params\": [PIN]}\n :returns: {\"method\": \"digital_message_reply\", \"params\": [PIN, DIGITAL_DATA_VALUE]}" }, { "code": "def rename(name):\n from peltak.extra.gitflow import logic\n if name is None:\n name = click.prompt('Hotfix name')\n logic.hotfix.rename(name)", "docstring": "Give the currently developed hotfix a new name." }, { "code": "def _validate_sub(claims, subject=None):\n if 'sub' not in claims:\n return\n if not isinstance(claims['sub'], string_types):\n raise JWTClaimsError('Subject must be a string.')\n if subject is not None:\n if claims.get('sub') != subject:\n raise JWTClaimsError('Invalid subject')", "docstring": "Validates that the 'sub' claim is valid.\n\n The \"sub\" (subject) claim identifies the principal that is the\n subject of the JWT. The claims in a JWT are normally statements\n about the subject. The subject value MUST either be scoped to be\n locally unique in the context of the issuer or be globally unique.\n The processing of this claim is generally application specific. The\n \"sub\" value is a case-sensitive string containing a StringOrURI\n value. Use of this claim is OPTIONAL.\n\n Args:\n claims (dict): The claims dictionary to validate.\n subject (str): The subject of the token." }, { "code": "def get_days_off(transactions):\n days_off = []\n for trans in transactions:\n date, action, _ = _parse_transaction_entry(trans)\n if action == 'off':\n days_off.append(date)\n return days_off", "docstring": "Return the dates for any 'take day off' transactions." }, { "code": "def rebin(self, factor):\n if self.pilimage != None:\n raise RuntimeError, \"Cannot rebin anymore, PIL image already exists !\"\n if type(factor) != type(0):\n raise RuntimeError, \"Rebin factor must be an integer !\"\n if factor < 1:\n return\n origshape = np.asarray(self.numpyarray.shape)\n neededshape = origshape - (origshape % factor)\n if not (origshape == neededshape).all():\n if self.verbose :\n print \"Rebinning %ix%i : I have to crop from %s to %s\" % (factor, factor, origshape, neededshape)\n self.crop(0, neededshape[0], 0, neededshape[1])\n else:\n if self.verbose :\n print \"Rebinning %ix%i : I do not need to crop\" % (factor, factor)\n self.numpyarray = rebin(self.numpyarray, neededshape/factor)\n self.binfactor = int(self.binfactor * factor)", "docstring": "I robustly rebin your image by a given factor.\n You simply specify a factor, and I will eventually take care of a crop to bring\n the image to interger-multiple-of-your-factor dimensions.\n Note that if you crop your image before, you must directly crop to compatible dimensions !\n We update the binfactor, this allows you to draw on the image later, still using the\n orignial pixel coordinates.\n Here we work on the numpy array." }, { "code": "def _exec_cmd(self, args, shell, timeout, stderr):\n if timeout and timeout <= 0:\n raise ValueError('Timeout is not a positive value: %s' % timeout)\n try:\n (ret, out, err) = utils.run_command(\n args, shell=shell, timeout=timeout)\n except psutil.TimeoutExpired:\n raise AdbTimeoutError(\n cmd=args, timeout=timeout, serial=self.serial)\n if stderr:\n stderr.write(err)\n logging.debug('cmd: %s, stdout: %s, stderr: %s, ret: %s',\n utils.cli_cmd_to_string(args), out, err, ret)\n if ret == 0:\n return out\n else:\n raise AdbError(\n cmd=args,\n stdout=out,\n stderr=err,\n ret_code=ret,\n serial=self.serial)", "docstring": "Executes adb commands.\n\n Args:\n args: string or list of strings, program arguments.\n See subprocess.Popen() documentation.\n shell: bool, True to run this command through the system shell,\n False to invoke it directly. See subprocess.Popen() docs.\n timeout: float, the number of seconds to wait before timing out.\n If not specified, no timeout takes effect.\n stderr: a Byte stream, like io.BytesIO, stderr of the command will\n be written to this object if provided.\n\n Returns:\n The output of the adb command run if exit code is 0.\n\n Raises:\n ValueError: timeout value is invalid.\n AdbError: The adb command exit code is not 0.\n AdbTimeoutError: The adb command timed out." }, { "code": "def subscribers(self, date=\"\", page=1, page_size=1000, order_field=\"email\", order_direction=\"asc\", include_tracking_information=False):\n params = {\n \"date\": date,\n \"page\": page,\n \"pagesize\": page_size,\n \"orderfield\": order_field,\n \"orderdirection\": order_direction,\n \"includetrackinginformation\": include_tracking_information\n }\n response = self._get(self.uri_for(\"active\"), params=params)\n return json_to_py(response)", "docstring": "Gets the active subscribers in this segment." }, { "code": "def dumps(obj, *args, **kwargs):\n return json.dumps(obj, *args, cls=TypelessSONEncoder, ensure_ascii=False, **kwargs)", "docstring": "Typeless dump an object to json string" }, { "code": "def add(user_id, resource_policy, admin, inactive, rate_limit):\n try:\n user_id = int(user_id)\n except ValueError:\n pass\n with Session() as session:\n try:\n data = session.KeyPair.create(\n user_id,\n is_active=not inactive,\n is_admin=admin,\n resource_policy=resource_policy,\n rate_limit=rate_limit)\n except Exception as e:\n print_error(e)\n sys.exit(1)\n if not data['ok']:\n print_fail('KeyPair creation has failed: {0}'.format(data['msg']))\n sys.exit(1)\n item = data['keypair']\n print('Access Key: {0}'.format(item['access_key']))\n print('Secret Key: {0}'.format(item['secret_key']))", "docstring": "Add a new keypair.\n\n USER_ID: User ID of a new key pair.\n RESOURCE_POLICY: resource policy for new key pair." }, { "code": "def _reload_config(self, reload_original_config):\n if reload_original_config:\n self.original_config = self.running_config\n self.original_config.set_name('original')\n paths = self.running_config.get_paths()\n self.running_config = FortiConfig('running', vdom=self.vdom)\n for path in paths:\n self.load_config(path, empty_candidate=True)", "docstring": "This command will update the running config from the live device.\n\n Args:\n * reload_original_config:\n * If ``True`` the original config will be loaded with the running config before reloading the\\\n original config.\n * If ``False`` the original config will remain untouched." }, { "code": "def get_relative_to_remote(self):\n s = self.git(\"status\", \"--short\", \"-b\")[0]\n r = re.compile(\"\\[([^\\]]+)\\]\")\n toks = r.findall(s)\n if toks:\n try:\n s2 = toks[-1]\n adj, n = s2.split()\n assert(adj in (\"ahead\", \"behind\"))\n n = int(n)\n return -n if adj == \"behind\" else n\n except Exception as e:\n raise ReleaseVCSError(\n (\"Problem parsing first line of result of 'git status \"\n \"--short -b' (%s):\\n%s\") % (s, str(e)))\n else:\n return 0", "docstring": "Return the number of commits we are relative to the remote. Negative\n is behind, positive in front, zero means we are matched to remote." }, { "code": "def _init():\n if (hasattr(_local_context, '_initialized') and\n _local_context._initialized == os.environ.get('REQUEST_ID_HASH')):\n return\n _local_context.registry = []\n _local_context._executing_async_context = None\n _local_context._executing_async = []\n _local_context._initialized = os.environ.get('REQUEST_ID_HASH')\n return _local_context", "docstring": "Initialize the furious context and registry.\n\n NOTE: Do not directly run this method." }, { "code": "def process_response(self, request, response):\n if hasattr(request, 'COUNTRY_CODE'):\n response.set_cookie(\n key=constants.COUNTRY_COOKIE_NAME,\n value=request.COUNTRY_CODE,\n max_age=settings.LANGUAGE_COOKIE_AGE,\n path=settings.LANGUAGE_COOKIE_PATH,\n domain=settings.LANGUAGE_COOKIE_DOMAIN\n )\n return response", "docstring": "Shares config with the language cookie as they serve a similar purpose" }, { "code": "def compute_qkv(query_antecedent,\n memory_antecedent,\n total_key_depth,\n total_value_depth,\n q_filter_width=1,\n kv_filter_width=1,\n q_padding=\"VALID\",\n kv_padding=\"VALID\",\n vars_3d_num_heads=0,\n layer_collection=None):\n if memory_antecedent is None:\n memory_antecedent = query_antecedent\n q = compute_attention_component(\n query_antecedent,\n total_key_depth,\n q_filter_width,\n q_padding,\n \"q\",\n vars_3d_num_heads=vars_3d_num_heads,\n layer_collection=layer_collection)\n k = compute_attention_component(\n memory_antecedent,\n total_key_depth,\n kv_filter_width,\n kv_padding,\n \"k\",\n vars_3d_num_heads=vars_3d_num_heads,\n layer_collection=layer_collection)\n v = compute_attention_component(\n memory_antecedent,\n total_value_depth,\n kv_filter_width,\n kv_padding,\n \"v\",\n vars_3d_num_heads=vars_3d_num_heads,\n layer_collection=layer_collection)\n return q, k, v", "docstring": "Computes query, key and value.\n\n Args:\n query_antecedent: a Tensor with shape [batch, length_q, channels]\n memory_antecedent: a Tensor with shape [batch, length_m, channels]\n total_key_depth: an integer\n total_value_depth: an integer\n q_filter_width: An integer specifying how wide you want the query to be.\n kv_filter_width: An integer specifying how wide you want the keys and values\n to be.\n q_padding: One of \"VALID\", \"SAME\" or \"LEFT\". Default is VALID: No padding.\n kv_padding: One of \"VALID\", \"SAME\" or \"LEFT\". Default is VALID: No padding.\n vars_3d_num_heads: an optional (if we want to use 3d variables)\n layer_collection: A tensorflow_kfac.LayerCollection. Only used by the\n KFAC optimizer. Default is None.\n\n Returns:\n q, k, v : [batch, length, depth] tensors" }, { "code": "def data(self):\n content = {\n 'form_data': self.form_data,\n 'token': self.token,\n 'viz_name': self.viz_type,\n 'filter_select_enabled': self.datasource.filter_select_enabled,\n }\n return content", "docstring": "This is the data object serialized to the js layer" }, { "code": "def log(self, time, message, level=None, attachment=None):\n logger.debug(\"log queued\")\n args = {\n \"time\": time,\n \"message\": message,\n \"level\": level,\n \"attachment\": attachment,\n }\n self.queue.put_nowait((\"log\", args))", "docstring": "Logs a message with attachment.\n\n The attachment is a dict of:\n name: name of attachment\n data: file content\n mime: content type for attachment" }, { "code": "def check_in_out_dates(self):\n if self.checkout and self.checkin:\n if self.checkin < self.date_order:\n raise ValidationError(_('Check-in date should be greater than \\\n the current date.'))\n if self.checkout < self.checkin:\n raise ValidationError(_('Check-out date should be greater \\\n than Check-in date.'))", "docstring": "When date_order is less then check-in date or\n Checkout date should be greater than the check-in date." }, { "code": "def get_sdb_by_id(self, sdb_id):\n sdb_resp = get_with_retry(self.cerberus_url + '/v2/safe-deposit-box/' + sdb_id,\n headers=self.HEADERS)\n throw_if_bad_response(sdb_resp)\n return sdb_resp.json()", "docstring": "Return the details for the given safe deposit box id\n\n Keyword arguments:\n sdb_id -- this is the id of the safe deposit box, not the path." }, { "code": "def flatten(self, df, column_name):\n _exp_list = [[md5, x] for md5, value_list in zip(df['md5'], df[column_name]) for x in value_list]\n return pd.DataFrame(_exp_list, columns=['md5',column_name])", "docstring": "Flatten a column in the dataframe that contains lists" }, { "code": "def interact_GxG(pheno,snps1,snps2=None,K=None,covs=None):\n if K is None:\n K=SP.eye(N)\n N=snps1.shape[0]\n if snps2 is None:\n snps2 = snps1\n return interact_GxE(snps=snps1,pheno=pheno,env=snps2,covs=covs,K=K)", "docstring": "Epistasis test between two sets of SNPs\n\n Args:\n pheno: [N x 1] SP.array of 1 phenotype for N individuals\n snps1: [N x S1] SP.array of S1 SNPs for N individuals\n snps2: [N x S2] SP.array of S2 SNPs for N individuals\n K: [N x N] SP.array of LMM-covariance/kinship koefficients (optional)\n If not provided, then linear regression analysis is performed\n covs: [N x D] SP.array of D covariates for N individuals\n\n Returns:\n pv: [S2 x S1] SP.array of P values for epistasis tests beten all SNPs in\n snps1 and snps2" }, { "code": "def add_device_net(self, name, destname=None):\n if not self.running:\n return False\n if os.path.exists(\"/sys/class/net/%s/phy80211/name\" % name):\n with open(\"/sys/class/net/%s/phy80211/name\" % name) as fd:\n phy = fd.read().strip()\n if subprocess.call(['iw', 'phy', phy, 'set', 'netns',\n str(self.init_pid)]) != 0:\n return False\n if destname:\n def rename_interface(args):\n old, new = args\n return subprocess.call(['ip', 'link', 'set',\n 'dev', old, 'name', new])\n return self.attach_wait(rename_interface, (name, destname),\n namespaces=(CLONE_NEWNET)) == 0\n return True\n if not destname:\n destname = name\n if not os.path.exists(\"/sys/class/net/%s/\" % name):\n return False\n return subprocess.call(['ip', 'link', 'set',\n 'dev', name,\n 'netns', str(self.init_pid),\n 'name', destname]) == 0", "docstring": "Add network device to running container." }, { "code": "def operations_happening_at_same_time_as(\n self, scheduled_operation: ScheduledOperation\n ) -> List[ScheduledOperation]:\n overlaps = self.query(\n time=scheduled_operation.time,\n duration=scheduled_operation.duration)\n return [e for e in overlaps if e != scheduled_operation]", "docstring": "Finds operations happening at the same time as the given operation.\n\n Args:\n scheduled_operation: The operation specifying the time to query.\n\n Returns:\n Scheduled operations that overlap with the given operation." }, { "code": "def resolve_widget(self, field):\n if hasattr(field, 'field'):\n widget = field.field.widget\n else:\n widget = field.widget\n return widget", "docstring": "Given a Field or BoundField, return widget instance.\n\n Todo:\n Raise an exception if given field object does not have a\n widget.\n\n Arguments:\n field (Field or BoundField): A field instance.\n\n Returns:\n django.forms.widgets.Widget: Retrieved widget from given field." }, { "code": "def jdn_to_gdate(jdn):\n l = jdn + 68569\n n = (4 * l) // 146097\n l = l - (146097 * n + 3) // 4\n i = (4000 * (l + 1)) // 1461001\n l = l - (1461 * i) // 4 + 31\n j = (80 * l) // 2447\n day = l - (2447 * j) // 80\n l = j // 11\n month = j + 2 - (12 * l)\n year = 100 * (n - 49) + i + l\n return datetime.date(year, month, day)", "docstring": "Convert from the Julian day to the Gregorian day.\n\n Algorithm from 'Julian and Gregorian Day Numbers' by Peter Meyer.\n Return: day, month, year" }, { "code": "def order(self, order):\n given = self.given\n surname = self.surname\n if order in (ORDER_MAIDEN_GIVEN, ORDER_GIVEN_MAIDEN):\n surname = self.maiden or self.surname\n given = (\"1\" + given) if given else \"2\"\n surname = (\"1\" + surname) if surname else \"2\"\n if order in (ORDER_SURNAME_GIVEN, ORDER_MAIDEN_GIVEN):\n return (surname, given)\n elif order in (ORDER_GIVEN_SURNAME, ORDER_GIVEN_MAIDEN):\n return (given, surname)\n else:\n raise ValueError(\"unexpected order: {}\".format(order))", "docstring": "Returns name order key.\n\n Returns tuple with two strings that can be compared to other such\n tuple obtained from different name. Note that if you want\n locale-dependent ordering then you need to compare strings using\n locale-aware method (e.g. ``locale.strxfrm``).\n\n :param order: One of the ORDER_* constants.\n :returns: tuple of two strings" }, { "code": "def to_json(self):\n return {\n 'wind_speed': self.wind_speed,\n 'wind_direction': self.wind_direction,\n 'rain': self.rain,\n 'snow_on_ground': self.snow_on_ground\n }", "docstring": "Convert the Wind Condition to a dictionary." }, { "code": "def get_patient_vcf(job, patient_dict):\n temp = job.fileStore.readGlobalFile(patient_dict['mutation_vcf'],\n os.path.join(os.getcwd(), 'temp.gz'))\n if is_gzipfile(temp):\n outfile = job.fileStore.writeGlobalFile(gunzip(temp))\n job.fileStore.deleteGlobalFile(patient_dict['mutation_vcf'])\n else:\n outfile = patient_dict['mutation_vcf']\n return outfile", "docstring": "Convenience function to get the vcf from the patient dict\n\n :param dict patient_dict: dict of patient info\n :return: The vcf\n :rtype: toil.fileStore.FileID" }, { "code": "def datetime_to_time(date, time):\n if (255 in date) or (255 in time):\n raise RuntimeError(\"specific date and time required\")\n time_tuple = (\n date[0]+1900, date[1], date[2],\n time[0], time[1], time[2],\n 0, 0, -1,\n )\n return _mktime(time_tuple)", "docstring": "Take the date and time 4-tuples and return the time in seconds since\n the epoch as a floating point number." }, { "code": "def add_service_spec(self, service_spec):\n assert service_spec is not None\n if service_spec.name in self.service_specs:\n raise ThriftCompilerError(\n 'Cannot define service \"%s\". That name is already taken.'\n % service_spec.name\n )\n self.service_specs[service_spec.name] = service_spec", "docstring": "Registers the given ``ServiceSpec`` into the scope.\n\n Raises ``ThriftCompilerError`` if the name has already been used." }, { "code": "def process_documentline(line, nanopubs_metadata):\n matches = re.match('SET DOCUMENT\\s+(\\w+)\\s+=\\s+\"?(.*?)\"?$', line)\n key = matches.group(1)\n val = matches.group(2)\n nanopubs_metadata[key] = val\n return nanopubs_metadata", "docstring": "Process SET DOCUMENT line in BEL script" }, { "code": "def delete_role_policy(role_name, policy_name, region=None, key=None,\n keyid=None, profile=None):\n conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)\n _policy = get_role_policy(role_name, policy_name, region, key, keyid, profile)\n if not _policy:\n return True\n try:\n conn.delete_role_policy(role_name, policy_name)\n log.info('Successfully deleted policy %s for IAM role %s.',\n policy_name, role_name)\n return True\n except boto.exception.BotoServerError as e:\n log.debug(e)\n log.error('Failed to delete policy %s for IAM role %s.',\n policy_name, role_name)\n return False", "docstring": "Delete a role policy.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt myminion boto_iam.delete_role_policy myirole mypolicy" }, { "code": "def expand_uri(self, **kwargs):\n kwargs = dict([(k, v if v != 0 else '0') for k, v in kwargs.items()])\n return uritemplate.expand(self.link.uri, kwargs)", "docstring": "Returns the template uri expanded with the current arguments" }, { "code": "def from_key(api_key, **kwargs):\n h = Heroku(**kwargs)\n h.authenticate(api_key)\n return h", "docstring": "Returns an authenticated Heroku instance, via API Key." }, { "code": "def addConcept(self, conceptUri, weight, label = None, conceptType = None):\n assert isinstance(weight, (float, int)), \"weight value has to be a positive or negative integer\"\n concept = {\"uri\": conceptUri, \"wgt\": weight}\n if label != None: concept[\"label\"] = label\n if conceptType != None: concept[\"type\"] = conceptType\n self.topicPage[\"concepts\"].append(concept)", "docstring": "add a relevant concept to the topic page\n @param conceptUri: uri of the concept to be added\n @param weight: importance of the provided concept (typically in range 1 - 50)" }, { "code": "def get_deposit_address(self, currency):\n self._validate_currency(currency)\n self._log('get deposit address for {}'.format(currency))\n coin_name = self.major_currencies[currency]\n return self._rest_client.post(\n endpoint='/{}_deposit_address'.format(coin_name)\n )", "docstring": "Return the deposit address for the given major currency.\n\n :param currency: Major currency name in lowercase (e.g. \"btc\", \"eth\").\n :type currency: str | unicode\n :return: Deposit address.\n :rtype: str | unicode" }, { "code": "def _json_body_(cls):\n json = []\n for series_name, data in six.iteritems(cls._datapoints):\n for point in data:\n json_point = {\n \"measurement\": series_name,\n \"fields\": {},\n \"tags\": {},\n \"time\": getattr(point, \"time\")\n }\n for field in cls._fields:\n value = getattr(point, field)\n if value is not None:\n json_point['fields'][field] = value\n for tag in cls._tags:\n json_point['tags'][tag] = getattr(point, tag)\n json.append(json_point)\n return json", "docstring": "Return the JSON body of given datapoints.\n\n :return: JSON body of these datapoints." }, { "code": "def session_commit(self, session):\n if not hasattr(session, 'meepo_unique_id'):\n self.logger.debug(\"skipped - session_commit\")\n return\n self.logger.debug(\"%s - session_commit\" % session.meepo_unique_id)\n self._session_pub(session)\n signal(\"session_commit\").send(session)\n self._session_del(session)", "docstring": "Send session_commit signal in sqlalchemy ``before_commit``.\n\n This marks the success of session so the session may enter commit\n state." }, { "code": "def register_admin(app, admin):\n category = 'Knowledge'\n admin.category_icon_classes[category] = \"fa fa-mortar-board\"\n admin.add_view(\n KnowledgeAdmin(app, KnwKB, db.session,\n name='Knowledge Base', category=category,\n endpoint=\"kb\")\n )\n admin.add_view(\n KnwKBRVALAdmin(app, KnwKBRVAL, db.session,\n name=\"Knowledge Mappings\", category=category,\n endpoint=\"kbrval\")\n )", "docstring": "Called on app initialization to register administration interface." }, { "code": "def convert(self, imtls, nsites, idx=0):\n curves = numpy.zeros(nsites, imtls.dt)\n for imt in curves.dtype.names:\n curves_by_imt = curves[imt]\n for sid in self:\n curves_by_imt[sid] = self[sid].array[imtls(imt), idx]\n return curves", "docstring": "Convert a probability map into a composite array of length `nsites`\n and dtype `imtls.dt`.\n\n :param imtls:\n DictArray instance\n :param nsites:\n the total number of sites\n :param idx:\n index on the z-axis (default 0)" }, { "code": "def change_profile(self, profile_name):\n self._server_side_completer = self._create_server_side_completer(\n session=botocore.session.Session(profile=profile_name))", "docstring": "Change the profile used for server side completions." }, { "code": "def sortBy(self, val=None):\n if val is not None:\n if _(val).isString():\n return self._wrap(sorted(self.obj, key=lambda x,\n *args: x.get(val)))\n else:\n return self._wrap(sorted(self.obj, key=val))\n else:\n return self._wrap(sorted(self.obj))", "docstring": "Sort the object's values by a criterion produced by an iterator." }, { "code": "def compose(*funcs):\n return lambda x: reduce(lambda v, f: f(v), reversed(funcs), x)", "docstring": "compose a list of functions" }, { "code": "def info(args):\n \" Show information about site. \"\n site = find_site(args.PATH)\n print_header(\"%s -- install information\" % site.get_name())\n LOGGER.debug(site.get_info(full=True))\n return True", "docstring": "Show information about site." }, { "code": "def register(self, intent):\n response = self.api.post_intent(intent.serialize)\n print(response)\n print()\n if response['status']['code'] == 200:\n intent.id = response['id']\n elif response['status']['code'] == 409:\n intent.id = next(i.id for i in self.api.agent_intents if i.name == intent.name)\n self.update(intent)\n return intent", "docstring": "Registers a new intent and returns the Intent object with an ID" }, { "code": "def set_cell(self, index, value):\n if self._sort:\n exists, i = sorted_exists(self._index, index)\n if not exists:\n self._insert_row(i, index)\n else:\n try:\n i = self._index.index(index)\n except ValueError:\n i = len(self._index)\n self._add_row(index)\n self._data[i] = value", "docstring": "Sets the value of a single cell. If the index is not in the current index then a new index will be created.\n\n :param index: index value\n :param value: value to set\n :return: nothing" }, { "code": "def build(self, shutit):\n\t\tif shutit.build['delivery'] in ('docker','dockerfile'):\n\t\t\tif shutit.get_current_shutit_pexpect_session_environment().install_type == 'apt':\n\t\t\t\tshutit.add_to_bashrc('export DEBIAN_FRONTEND=noninteractive')\n\t\t\t\tif not shutit.command_available('lsb_release'):\n\t\t\t\t\tshutit.install('lsb-release')\n\t\t\t\tshutit.lsb_release()\n\t\t\telif shutit.get_current_shutit_pexpect_session_environment().install_type == 'yum':\n\t\t\t\tshutit.send('yum update -y', timeout=9999, exit_values=['0', '1'])\n\t\t\tshutit.pause_point('Anything you want to do to the target host ' + 'before the build starts?', level=2)\n\t\treturn True", "docstring": "Initializes target ready for build and updating package management if in container." }, { "code": "def url(self, **kwargs):\n url = self.fields(self._locale()).get('file', {}).get('url', '')\n args = ['{0}={1}'.format(k, v) for k, v in kwargs.items()]\n if args:\n url += '?{0}'.format('&'.join(args))\n return url", "docstring": "Returns a formatted URL for the asset's File\n with serialized parameters.\n\n Usage:\n >>> my_asset.url()\n \"//images.contentful.com/spaces/foobar/...\"\n >>> my_asset.url(w=120, h=160)\n \"//images.contentful.com/spaces/foobar/...?w=120&h=160\"" }, { "code": "def _validate_integer(name, val, min_val=0):\n msg = \"'{name:s}' must be an integer >={min_val:d}\".format(name=name,\n min_val=min_val)\n if val is not None:\n if is_float(val):\n if int(val) != val:\n raise ValueError(msg)\n val = int(val)\n elif not (is_integer(val) and val >= min_val):\n raise ValueError(msg)\n return val", "docstring": "Checks whether the 'name' parameter for parsing is either\n an integer OR float that can SAFELY be cast to an integer\n without losing accuracy. Raises a ValueError if that is\n not the case.\n\n Parameters\n ----------\n name : string\n Parameter name (used for error reporting)\n val : int or float\n The value to check\n min_val : int\n Minimum allowed value (val < min_val will result in a ValueError)" }, { "code": "def multiple_sequence_alignment(seqs_fp, threads=1):\n logger = logging.getLogger(__name__)\n logger.info('multiple_sequence_alignment seqs file %s' % seqs_fp)\n if threads == 0:\n threads = -1\n if stat(seqs_fp).st_size == 0:\n logger.warning('msa failed. file %s has no reads' % seqs_fp)\n return None\n msa_fp = seqs_fp + '.msa'\n params = ['mafft', '--quiet', '--preservecase', '--parttree', '--auto',\n '--thread', str(threads), seqs_fp]\n sout, serr, res = _system_call(params, stdoutfilename=msa_fp)\n if not res == 0:\n logger.info('msa failed for file %s (maybe only 1 read?)' % seqs_fp)\n logger.debug('stderr : %s' % serr)\n return None\n return msa_fp", "docstring": "Perform multiple sequence alignment on FASTA file using MAFFT.\n\n Parameters\n ----------\n seqs_fp: string\n filepath to FASTA file for multiple sequence alignment\n threads: integer, optional\n number of threads to use. 0 to use all threads\n\n Returns\n -------\n msa_fp : str\n name of output alignment file or None if error encountered" }, { "code": "def delete_user(name, runas=None):\n if runas is None and not salt.utils.platform.is_windows():\n runas = salt.utils.user.get_user()\n res = __salt__['cmd.run_all'](\n [RABBITMQCTL, 'delete_user', name],\n reset_system_locale=False,\n python_shell=False,\n runas=runas)\n msg = 'Deleted'\n return _format_response(res, msg)", "docstring": "Deletes a user via rabbitmqctl delete_user.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' rabbitmq.delete_user rabbit_user" }, { "code": "def md5(self):\n target = '{}{}'.format(\n util.md5_object(bytes().join(e._bytes()\n for e in self.entities)),\n self.vertices.md5())\n return target", "docstring": "An MD5 hash of the current vertices and entities.\n\n Returns\n ------------\n md5: str, two appended MD5 hashes" }, { "code": "def load_from_file(cls, file_path: str):\n with open(file_path, \"r\") as f:\n data = json.load(f)\n item = cls.decode(data=data)\n return item", "docstring": "Read and reconstruct the data from a JSON file." }, { "code": "def returnPorts(self):\n if self._gotPorts:\n map(portpicker.return_port, self.ports)\n self._gotPorts = False\n self.ports = []", "docstring": "deallocate specific ports on the current machine" }, { "code": "def _format_executable(lines, element, spacer=\"\"):\n rlines = []\n rlines.append(element.signature)\n _format_summary(rlines, element)\n rlines.append(\"\")\n rlines.append(\"PARAMETERS\")\n for p in element.ordered_parameters:\n _format_value_element(rlines, p)\n rlines.append(\"\")\n _format_generic(rlines, element, [\"summary\"])\n if len(element.types) > 0:\n rlines.append(\"\\nEMBEDDED TYPES\")\n for key, value in list(element.types.items()):\n _format_type(rlines, value, \" \")\n if len(element.executables) > 0:\n rlines.append(\"\\nEMBEDDED EXECUTABLES\")\n for key, value in list(element.executables.items()):\n _format_executable(rlines, value, \" \")\n lines.extend([spacer + l for l in rlines])", "docstring": "Performs formatting specific to a Subroutine or Function code\n element for relevant docstrings." }, { "code": "def run(self):\n self.tap = Quartz.CGEventTapCreate(\n Quartz.kCGSessionEventTap,\n Quartz.kCGHeadInsertEventTap,\n Quartz.kCGEventTapOptionDefault,\n Quartz.CGEventMaskBit(Quartz.kCGEventKeyDown) |\n Quartz.CGEventMaskBit(Quartz.kCGEventKeyUp) |\n Quartz.CGEventMaskBit(Quartz.kCGEventFlagsChanged),\n self.handler,\n None)\n loopsource = Quartz.CFMachPortCreateRunLoopSource(None, self.tap, 0)\n loop = Quartz.CFRunLoopGetCurrent()\n Quartz.CFRunLoopAddSource(loop, loopsource, Quartz.kCFRunLoopDefaultMode)\n Quartz.CGEventTapEnable(self.tap, True)\n while self.listening:\n Quartz.CFRunLoopRunInMode(Quartz.kCFRunLoopDefaultMode, 5, False)", "docstring": "Creates a listener and loops while waiting for an event. Intended to run as\n a background thread." }, { "code": "def get_node_instances(nodelist, instances):\n context = _get_main_context(nodelist)\n if TemplateAdapter is not None and isinstance(nodelist, TemplateAdapter):\n nodelist = nodelist.template\n return _scan_nodes(nodelist, context, instances)", "docstring": "Find the nodes of a given instance.\n\n In contract to the standard ``template.nodelist.get_nodes_by_type()`` method,\n this also looks into ``{% extends %}`` and ``{% include .. %}`` nodes\n to find all possible nodes of the given type.\n\n :param instances: A class Type, or tuple of types to find.\n :param nodelist: The Template object, or nodelist to scan.\n :returns: A list of Node objects which inherit from the list of given `instances` to find.\n :rtype: list" }, { "code": "def _convert_nonstring_categoricals(self, param_dict):\n return {name: (self.categorical_mappings_[name][val] if name in self.categorical_mappings_ else val)\n for (name, val) in param_dict.items()}", "docstring": "Apply the self.categorical_mappings_ mappings where necessary." }, { "code": "def beta_pdf(x, a, b):\n bc = 1 / beta(a, b)\n fc = x ** (a - 1)\n sc = (1 - x) ** (b - 1)\n return bc * fc * sc", "docstring": "Beta distirbution probability density function." }, { "code": "def event_return(events):\n with _get_serv(events, commit=True) as cur:\n for event in events:\n tag = event.get('tag', '')\n data = event.get('data', '')\n sql =\n cur.execute(sql, (tag, psycopg2.extras.Json(data),\n __opts__['id'], time.time()))", "docstring": "Return event to Pg server\n\n Requires that configuration be enabled via 'event_return'\n option in master config." }, { "code": "def draw(self, gdefs, theme):\n for g in gdefs:\n g.theme = theme\n g._set_defaults()\n return [g.draw() for g in gdefs]", "docstring": "Draw out each guide definition\n\n Parameters\n ----------\n gdefs : list of guide_legend|guide_colorbar\n guide definitions\n theme : theme\n Plot theme\n\n Returns\n -------\n out : list of matplotlib.offsetbox.Offsetbox\n A drawing of each legend" }, { "code": "def get_free_port(ports=None):\n if ports is None:\n with contextlib.closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as _socket:\n _socket.bind(('', 0))\n _, port = _socket.getsockname()\n return port\n for port in ports:\n with contextlib.closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as _socket:\n try:\n _socket.bind(('', port))\n return port\n except socket.error as ex:\n if ex.errno not in (48, 98):\n raise\n raise RuntimeError(\"could not find a free port\")", "docstring": "Get a free port.\n\n Parameters\n ----------\n ports : iterable\n ports to check (obtain a random port by default)\n\n Returns\n -------\n port : int\n a free port" }, { "code": "def run(\n paths,\n output=_I_STILL_HATE_EVERYTHING,\n recurse=core.flat,\n sort_by=None,\n ls=core.ls,\n stdout=stdout,\n):\n if output is _I_STILL_HATE_EVERYTHING:\n output = core.columnized if stdout.isatty() else core.one_per_line\n if sort_by is None:\n if output == core.as_tree:\n def sort_by(thing):\n return (\n thing.parent(),\n thing.basename().lstrip(string.punctuation).lower(),\n )\n else:\n def sort_by(thing):\n return thing\n def _sort_by(thing):\n return not getattr(thing, \"_always_sorts_first\", False), sort_by(thing)\n contents = [\n path_and_children\n for path in paths or (project.from_path(FilePath(\".\")),)\n for path_and_children in recurse(path=path, ls=ls)\n ]\n for line in output(contents, sort_by=_sort_by):\n stdout.write(line)\n stdout.write(\"\\n\")", "docstring": "Project-oriented directory and file information lister." }, { "code": "def _find_files(self):\n files = []\n for ext in self.extensions:\n ext_files = util.find_files(self.root, \"*\" + ext)\n log.debug(\"found {} '*{}' files in '{}'\".format(\n len(ext_files), ext, self.root)\n )\n files.extend(ext_files)\n return files", "docstring": "Find files recursively in the root path\n using provided extensions.\n\n :return: list of absolute file paths" }, { "code": "def _function_add_return_edge(self, return_from_addr, return_to_addr, function_addr):\n return_to_node = self._nodes.get(return_to_addr, None)\n if return_to_node is None:\n return_to_snippet = self._to_snippet(addr=return_to_addr, base_state=self._base_state)\n to_outside = False\n else:\n return_to_snippet = self._to_snippet(cfg_node=return_to_node)\n to_outside = return_to_node.function_address != function_addr\n self.kb.functions._add_return_from_call(function_addr, return_from_addr, return_to_snippet,\n to_outside=to_outside)", "docstring": "Generate CodeNodes for return_to_addr, add this node for function to\n function manager generating new edge\n\n :param int return_from_addr: target address\n :param int return_to_addr: target address\n :param int function_addr: address of function\n :return: None" }, { "code": "def commit(self):\n assert self.batch is not None, \"No active batch, call start() first\"\n logger.debug(\"Comitting batch from %d sources...\", len(self.batch))\n by_priority = []\n for name in self.batch.keys():\n priority = self.priorities.get(name, self.default_priority)\n by_priority.append((priority, name))\n for priority, name in sorted(by_priority, key=lambda key: key[0]):\n logger.debug(\"Processing items from '%s' (priority=%d)...\", name, priority)\n items = self.batch[name]\n for handlers in items.values():\n for agg, handler in handlers:\n try:\n if agg is None:\n handler()\n else:\n handler(agg)\n except Exception as error:\n logger.exception(\"Error while invoking handler.\")\n self.batch = None\n logger.debug(\"Batch committed.\")", "docstring": "Commit a batch." }, { "code": "def get_file_hash(file_path, block_size=1024, hasher=None):\n if hasher is None:\n hasher = hashlib.md5()\n with open(file_path, 'rb') as f:\n while True:\n buffer = f.read(block_size)\n if len(buffer) <= 0:\n break\n hasher.update(buffer)\n return hasher.hexdigest()", "docstring": "Generate hash for given file\n\n :param file_path: Path to file\n :type file_path: str\n :param block_size: Size of block to be read at once (default: 1024)\n :type block_size: int\n :param hasher: Use specific hasher, defaults to md5 (default: None)\n :type hasher: _hashlib.HASH\n :return: Hash of file\n :rtype: str" }, { "code": "def is_ini_file(filename, show_warnings = False):\n try:\n config_dict = load_config(filename, file_type = \"ini\")\n if config_dict == {}:\n is_ini = False\n else:\n is_ini = True\n except:\n is_ini = False\n return(is_ini)", "docstring": "Check configuration file type is INI\n Return a boolean indicating wheather the file is INI format or not" }, { "code": "def _is_finished(self, as_of):\n if self.is_one_off():\n last_billing_cycle = self.get_billing_cycles()[self.total_billing_cycles - 1]\n return last_billing_cycle.date_range.upper <= as_of\n else:\n return False", "docstring": "Have the specified number of billing cycles been completed?\n\n If so, we should not be enacting this RecurringCost." }, { "code": "def claim_keys(self, key_request, timeout=None):\n content = {\"one_time_keys\": key_request}\n if timeout:\n content[\"timeout\"] = timeout\n return self._send(\"POST\", \"/keys/claim\", content=content)", "docstring": "Claims one-time keys for use in pre-key messages.\n\n Args:\n key_request (dict): The keys to be claimed. Format should be\n : { : }.\n timeout (int): Optional. The time (in milliseconds) to wait when\n downloading keys from remote servers." }, { "code": "def save(self, entity):\n assert isinstance(entity, Entity), \" entity must have an instance of Entity\"\n return self.__collection.save(entity.as_dict())", "docstring": "Maps entity to dict and returns future" }, { "code": "def get_column(column_name, node, context):\n column = try_get_column(column_name, node, context)\n if column is None:\n selectable = get_node_selectable(node, context)\n raise AssertionError(\n u'Column \"{}\" not found in selectable \"{}\". Columns present are {}. '\n u'Context is {}.'.format(column_name, selectable.original,\n [col.name for col in selectable.c], context))\n return column", "docstring": "Get a column by name from the selectable.\n\n Args:\n column_name: str, name of the column to retrieve.\n node: SqlNode, the node the column is being retrieved for.\n context: CompilationContext, compilation specific metadata.\n\n Returns:\n column, the SQLAlchemy column if found. Raises an AssertionError otherwise." }, { "code": "def remove(env, securitygroup_id, rule_id):\n mgr = SoftLayer.NetworkManager(env.client)\n ret = mgr.remove_securitygroup_rule(securitygroup_id, rule_id)\n if not ret:\n raise exceptions.CLIAbort(\"Failed to remove security group rule\")\n table = formatting.Table(REQUEST_BOOL_COLUMNS)\n table.add_row([ret['requestId']])\n env.fout(table)", "docstring": "Remove a rule from a security group." }, { "code": "def clear(self, username, project):\n method = 'DELETE'\n url = ('/project/{username}/{project}/build-cache?'\n 'circle-token={token}'.format(username=username,\n project=project,\n token=self.client.api_token))\n json_data = self.client.request(method, url)\n return json_data", "docstring": "Clear the cache for given project." }, { "code": "def render_pdf_file_to_image_files__ghostscript_png(pdf_file_name,\n root_output_file_path,\n res_x=150, res_y=150):\n if not gs_executable: init_and_test_gs_executable(exit_on_fail=True)\n command = [gs_executable, \"-dBATCH\", \"-dNOPAUSE\", \"-sDEVICE=pnggray\",\n \"-r\"+res_x+\"x\"+res_y, \"-sOutputFile=\"+root_output_file_path+\"-%06d.png\",\n pdf_file_name]\n comm_output = get_external_subprocess_output(command, env=gs_environment)\n return comm_output", "docstring": "Use Ghostscript to render a PDF file to .png images. The root_output_file_path\n is prepended to all the output files, which have numbers and extensions added.\n Return the command output." }, { "code": "def lspcn(body, et, abcorr):\n body = stypes.stringToCharP(body)\n et = ctypes.c_double(et)\n abcorr = stypes.stringToCharP(abcorr)\n return libspice.lspcn_c(body, et, abcorr)", "docstring": "Compute L_s, the planetocentric longitude of the sun, as seen\n from a specified body.\n\n http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/lspcn_c.html\n\n :param body: Name of central body.\n :type body: str\n :param et: Epoch in seconds past J2000 TDB.\n :type et: float\n :param abcorr: Aberration correction.\n :type abcorr: str\n :return: planetocentric longitude of the sun\n :rtype: float" }, { "code": "def get(self, s3_path, destination_local_path):\n (bucket, key) = self._path_to_bucket_and_key(s3_path)\n self.s3.meta.client.download_file(bucket, key, destination_local_path)", "docstring": "Get an object stored in S3 and write it to a local path." }, { "code": "def get_new_ip(self):\n attempts = 0\n while True:\n if attempts == self.new_ip_max_attempts:\n raise TorIpError(\"Failed to obtain a new usable Tor IP\")\n attempts += 1\n try:\n current_ip = self.get_current_ip()\n except (RequestException, TorIpError):\n self._obtain_new_ip()\n continue\n if not self._ip_is_usable(current_ip):\n self._obtain_new_ip()\n continue\n self._manage_used_ips(current_ip)\n break\n return current_ip", "docstring": "Try to obtain new a usable TOR IP.\n\n :returns bool\n :raises TorIpError" }, { "code": "def edit(community):\n form = EditCommunityForm(formdata=request.values, obj=community)\n deleteform = DeleteCommunityForm()\n ctx = mycommunities_ctx()\n ctx.update({\n 'form': form,\n 'is_new': False,\n 'community': community,\n 'deleteform': deleteform,\n })\n if form.validate_on_submit():\n for field, val in form.data.items():\n setattr(community, field, val)\n file = request.files.get('logo', None)\n if file:\n if not community.save_logo(file.stream, file.filename):\n form.logo.errors.append(_(\n 'Cannot add this file as a logo. Supported formats: '\n 'PNG, JPG and SVG. Max file size: 1.5 MB.'))\n if not form.logo.errors:\n db.session.commit()\n flash(\"Community successfully edited.\", category='success')\n return redirect(url_for('.edit', community_id=community.id))\n return render_template(\n current_app.config['COMMUNITIES_EDIT_TEMPLATE'],\n **ctx\n )", "docstring": "Create or edit a community." }, { "code": "def getcomments(self):\n comment_list = self.bugzilla.get_comments([self.bug_id])\n return comment_list['bugs'][str(self.bug_id)]['comments']", "docstring": "Returns an array of comment dictionaries for this bug" }, { "code": "def worklogs(self, issue):\n r_json = self._get_json('issue/' + str(issue) + '/worklog')\n worklogs = [Worklog(self._options, self._session, raw_worklog_json)\n for raw_worklog_json in r_json['worklogs']]\n return worklogs", "docstring": "Get a list of worklog Resources from the server for an issue.\n\n :param issue: ID or key of the issue to get worklogs from\n :rtype: List[Worklog]" }, { "code": "def delete(self, key_id=None):\n url = self.bitbucket.url('DELETE_SSH_KEY', key_id=key_id)\n return self.bitbucket.dispatch('DELETE', url, auth=self.bitbucket.auth)", "docstring": "Delete one of the ssh keys associated with your account.\n Please use with caution as there is NO confimation and NO undo." }, { "code": "def is_answer_valid(self, ans):\n return ans in [str(i+1) for i in range(len(self.choices))]", "docstring": "Validate user's answer against available choices." }, { "code": "def mode(self, mode):\n _LOGGER.debug(\"Setting new mode: %s\", mode)\n if self.mode == Mode.Boost and mode != Mode.Boost:\n self.boost = False\n if mode == Mode.Boost:\n self.boost = True\n return\n elif mode == Mode.Away:\n end = datetime.now() + self._away_duration\n return self.set_away(end, self._away_temp)\n elif mode == Mode.Closed:\n return self.set_mode(0x40 | int(EQ3BT_OFF_TEMP * 2))\n elif mode == Mode.Open:\n return self.set_mode(0x40 | int(EQ3BT_ON_TEMP * 2))\n if mode == Mode.Manual:\n temperature = max(min(self._target_temperature, self.max_temp),\n self.min_temp)\n return self.set_mode(0x40 | int(temperature * 2))\n else:\n return self.set_mode(0)", "docstring": "Set the operation mode." }, { "code": "def corr(self):\r\n cov = self.cov()\r\n N = cov.shape[0]\r\n corr = ndarray((N,N))\r\n for r in range(N):\r\n for c in range(r):\r\n corr[r,c] = corr[c,r] = cov[r,c]/sqrt(cov[r,r]*cov[c,c])\r\n corr[r,r] = 1.\r\n return corr", "docstring": "The correlation matrix" }, { "code": "def _find_git_info(self, gitdir):\n res = {'remotes': None, 'tag': None, 'commit': None, 'dirty': None}\n try:\n logger.debug('opening %s as git.Repo', gitdir)\n repo = Repo(path=gitdir, search_parent_directories=False)\n res['commit'] = repo.head.commit.hexsha\n res['dirty'] = repo.is_dirty(untracked_files=True)\n res['remotes'] = {}\n for rmt in repo.remotes:\n urls = [u for u in rmt.urls]\n if len(urls) > 0:\n res['remotes'][rmt.name] = urls[0]\n for tag in repo.tags:\n if tag.commit.hexsha == res['commit']:\n res['tag'] = tag.name\n except Exception:\n logger.debug('Exception getting git information', exc_info=True)\n return res", "docstring": "Find information about the git repository, if this file is in a clone.\n\n :param gitdir: path to the git repo's .git directory\n :type gitdir: str\n :returns: information about the git clone\n :rtype: dict" }, { "code": "def widget_status(self):\n widget_status_list = []\n for i in self.widgetlist:\n widget_status_list += [[i.name, i.status]]\n return widget_status_list", "docstring": "This method will return the status of all of the widgets in the\n widget list" }, { "code": "def blast_seqs(seqs,\n blast_constructor,\n blast_db=None,\n blast_mat_root=None,\n params={},\n add_seq_names=True,\n out_filename=None,\n WorkingDir=None,\n SuppressStderr=None,\n SuppressStdout=None,\n input_handler=None,\n HALT_EXEC=False\n ):\n if blast_db:\n params[\"-d\"] = blast_db\n if out_filename:\n params[\"-o\"] = out_filename\n ih = input_handler or guess_input_handler(seqs, add_seq_names)\n blast_app = blast_constructor(\n params=params,\n blast_mat_root=blast_mat_root,\n InputHandler=ih,\n WorkingDir=WorkingDir,\n SuppressStderr=SuppressStderr,\n SuppressStdout=SuppressStdout,\n HALT_EXEC=HALT_EXEC)\n return blast_app(seqs)", "docstring": "Blast list of sequences.\n\n seqs: either file name or list of sequence objects or list of strings or\n single multiline string containing sequences.\n\n WARNING: DECISION RULES FOR INPUT HANDLING HAVE CHANGED. Decision rules\n for data are as follows. If it's s list, treat as lines, unless\n add_seq_names is true (in which case treat as list of seqs). If it's a\n string, test whether it has newlines. If it doesn't have newlines, assume\n it's a filename. If it does have newlines, it can't be a filename, so\n assume it's a multiline string containing sequences.\n\n If you want to skip the detection and force a specific type of input\n handler, use input_handler='your_favorite_handler'.\n\n add_seq_names: boolean. if True, sequence names are inserted in the list\n of sequences. if False, it assumes seqs is a list of lines of some\n proper format that the program can handle" }, { "code": "def url_to_attrs_dict(url, url_attr):\n result = dict()\n if isinstance(url, six.string_types):\n url_value = url\n else:\n try:\n url_value = url[\"url\"]\n except TypeError:\n raise BootstrapError(\n 'Function \"url_to_attrs_dict\" expects a string or a dict with key \"url\".'\n )\n crossorigin = url.get(\"crossorigin\", None)\n integrity = url.get(\"integrity\", None)\n if crossorigin:\n result[\"crossorigin\"] = crossorigin\n if integrity:\n result[\"integrity\"] = integrity\n result[url_attr] = url_value\n return result", "docstring": "Sanitize url dict as used in django-bootstrap3 settings." }, { "code": "def init_backend(self, *args, **kwargs):\n self.model.attrs = {}\n self.use_memory_cache = kwargs.get('use_memory_cache', True)\n if self.use_memory_cache:\n self.init_memory_cache()\n self.use_disk_cache = kwargs.get('use_disk_cache', False)\n if self.use_disk_cache:\n self.init_disk_cache()\n self.load_model()\n self.model.unpicklable += ['_backend']", "docstring": "Initialize the backend." }, { "code": "def draw(self, renderer):\n dpi_cor = renderer.points_to_pixels(1.)\n self.dpi_transform.clear()\n self.dpi_transform.scale(dpi_cor, dpi_cor)\n for c in self._children:\n c.draw(renderer)\n self.stale = False", "docstring": "Draw the children" }, { "code": "def get_category_aliases_under(parent_alias=None):\n return [ch.alias for ch in get_cache().get_children_for(parent_alias, only_with_aliases=True)]", "docstring": "Returns a list of category aliases under the given parent.\n\n Could be useful to pass to `ModelWithCategory.enable_category_lists_editor`\n in `additional_parents_aliases` parameter.\n\n :param str|None parent_alias: Parent alias or None to categories under root\n :rtype: list\n :return: a list of category aliases" }, { "code": "def unregister(self, observer):\n self.observer_manager.observers.remove(observer)\n observer.manager = None", "docstring": "Remove the observers of the observers list.\n It will not receive any more notifications when occurs changes.\n\n :param UpdatesObserver observer: Observer you will not receive any more notifications then\n occurs changes." }, { "code": "def _find_metadata_vars(self, ds, refresh=False):\n if self._metadata_vars.get(ds, None) and refresh is False:\n return self._metadata_vars[ds]\n self._metadata_vars[ds] = []\n for name, var in ds.variables.items():\n if name in self._find_ancillary_vars(ds) or name in self._find_coord_vars(ds):\n continue\n if name in ('platform_name', 'station_name', 'instrument_name', 'station_id', 'platform_id', 'surface_altitude'):\n self._metadata_vars[ds].append(name)\n elif getattr(var, 'cf_role', '') != '':\n self._metadata_vars[ds].append(name)\n elif getattr(var, 'standard_name', None) is None and len(var.dimensions) == 0:\n self._metadata_vars[ds].append(name)\n return self._metadata_vars[ds]", "docstring": "Returns a list of netCDF variable instances for those that are likely metadata variables\n\n :param netCDF4.Dataset ds: An open netCDF dataset\n :param bool refresh: if refresh is set to True, the cache is\n invalidated.\n :rtype: list\n :return: List of variable names (str) that are likely metadata\n variable candidates." }, { "code": "def speak(self):\n if self.quiet is False:\n bot.info('[helper|%s]' %(self.name))\n self._speak()", "docstring": "a function for the helper to announce him or herself, depending\n on the level specified. If you want your client to have additional\n announced things here, then implement the class `_speak` for your\n client." }, { "code": "def get_form(self, form, name):\n kwargs = self.get_kwargs(form, name)\n form_class = self.get_form_class(form, name)\n composite_form = form_class(\n data=form.data if form.is_bound else None,\n files=form.files if form.is_bound else None,\n **kwargs)\n return composite_form", "docstring": "Get an instance of the form." }, { "code": "def data_gen(n_ops=100):\n while True:\n X = np.random.uniform(size=(64, 64))\n yield dict(X=costly_function(X, n_ops),\n y=np.random.randint(10, size=(1,)))", "docstring": "Yield data, while optionally burning compute cycles.\n\n Parameters\n ----------\n n_ops : int, default=100\n Number of operations to run between yielding data.\n\n Returns\n -------\n data : dict\n A object which looks like it might come from some\n machine learning problem, with X as features, and y as targets." }, { "code": "def _build_relations_config(self, yamlconfig):\n config = {}\n for element in yamlconfig:\n if isinstance(element, str):\n config[element] = {'relation_name': element, 'schemas': []}\n elif isinstance(element, dict):\n if 'relation_name' not in element or 'schemas' not in element:\n self.log.warning(\"Unknown element format for relation element %s\", element)\n continue\n if not isinstance(element['schemas'], list):\n self.log.warning(\"Expected a list of schemas for %s\", element)\n continue\n name = element['relation_name']\n config[name] = {'relation_name': name, 'schemas': element['schemas']}\n else:\n self.log.warning('Unhandled relations config type: {}'.format(element))\n return config", "docstring": "Builds a dictionary from relations configuration while maintaining compatibility" }, { "code": "def next_lookup(self, symbol):\n result = []\n if symbol == self.initialsymbol:\n result.append(EndSymbol())\n for production in self.productions:\n if symbol in production.rightside:\n nextindex = production.rightside.index(symbol) + 1\n while nextindex < len(production.rightside):\n nextsymbol = production.rightside[nextindex]\n firstlist = self.first_lookup(nextsymbol)\n cleanfirstlist = Choice([x for x in firstlist if x != NullSymbol()])\n result.append(cleanfirstlist)\n if NullSymbol() not in firstlist:\n break\n else:\n result += self.next_lookup(production.leftside[0])\n return result", "docstring": "Returns the next TerminalSymbols produced by the input symbol within this grammar definition" }, { "code": "def update_savings_goal_data(self) -> None:\n response = get(\n _url(\n \"/account/{0}/savings-goals\".format(self._account_uid),\n self._sandbox\n ),\n headers=self._auth_headers\n )\n response.raise_for_status()\n response = response.json()\n response_savings_goals = response.get('savingsGoalList', {})\n returned_uids = []\n for goal in response_savings_goals:\n uid = goal.get('savingsGoalUid')\n returned_uids.append(uid)\n if uid not in self.savings_goals:\n self.savings_goals[uid] = SavingsGoal(\n self._auth_headers,\n self._sandbox,\n self._account_uid\n )\n self.savings_goals[uid].update(goal)\n for uid in list(self.savings_goals):\n if uid not in returned_uids:\n self.savings_goals.pop(uid)", "docstring": "Get the latest savings goal information for the account." }, { "code": "def saved_search(self, sid, **kw):\n path = 'data/v1/searches/%s/results' % sid\n params = self._params(kw)\n return self._get(self._url(path), body_type=models.Items,\n params=params).get_body()", "docstring": "Execute a saved search by search id.\n\n :param sid string: The id of the search\n :returns: :py:class:`planet.api.models.Items`\n :raises planet.api.exceptions.APIException: On API error.\n\n :Options:\n\n * page_size (int): Size of response pages\n * sort (string): Sorting order in the form `field (asc|desc)`" }, { "code": "def disable_scanners_by_group(self, group):\n if group == 'all':\n self.logger.debug('Disabling all scanners')\n return self.zap.ascan.disable_all_scanners()\n try:\n scanner_list = self.scanner_group_map[group]\n except KeyError:\n raise ZAPError(\n 'Invalid group \"{0}\" provided. Valid groups are: {1}'.format(\n group, ', '.join(self.scanner_groups)\n )\n )\n self.logger.debug('Disabling scanner group {0}'.format(group))\n return self.disable_scanners_by_ids(scanner_list)", "docstring": "Disables the scanners in the group if it matches one in the scanner_group_map." }, { "code": "def get_per_object_threshold(method, image, threshold, mask=None, labels=None,\n threshold_range_min = None,\n threshold_range_max = None,\n **kwargs):\n if labels is None:\n labels = np.ones(image.shape,int)\n if not mask is None:\n labels[np.logical_not(mask)] = 0 \n label_extents = scipy.ndimage.find_objects(labels,np.max(labels))\n local_threshold = np.ones(image.shape,image.dtype)\n for i, extent in enumerate(label_extents, start=1):\n label_mask = labels[extent]==i\n if not mask is None:\n label_mask = np.logical_and(mask[extent], label_mask)\n values = image[extent]\n per_object_threshold = get_global_threshold(\n method, values, mask = label_mask, **kwargs)\n local_threshold[extent][label_mask] = per_object_threshold\n return local_threshold", "docstring": "Return a matrix giving threshold per pixel calculated per-object\n \n image - image to be thresholded\n mask - mask out \"don't care\" pixels\n labels - a label mask indicating object boundaries\n threshold - the global threshold" }, { "code": "def register_model(self, model_id, properties, parameters, outputs, connector):\n self.validate_connector(connector)\n try:\n return self.registry.register_model(\n model_id,\n properties,\n parameters,\n outputs,\n connector\n )\n except DuplicateKeyError as ex:\n raise ValueError(str(ex))", "docstring": "Register a new model with the engine. Expects connection information\n for RabbitMQ to submit model run requests to workers.\n\n Raises ValueError if the given model identifier is not unique.\n\n Parameters\n ----------\n model_id : string\n Unique model identifier\n properties : Dictionary\n Dictionary of model specific properties.\n parameters : list(scodata.attribute.AttributeDefinition)\n List of attribute definitions for model run parameters\n outputs : ModelOutputs\n Description of model outputs\n connector : dict\n Connection information to communicate with model workers. Expected\n to contain at least the connector name 'connector'.\n\n Returns\n -------\n ModelHandle" }, { "code": "def _unkown_type(self, uridecodebin, decodebin, caps):\n streaminfo = caps.to_string()\n if not streaminfo.startswith('audio/'):\n return\n self.read_exc = UnknownTypeError(streaminfo)\n self.ready_sem.release()", "docstring": "The callback for decodebin's \"unknown-type\" signal." }, { "code": "def _make_definition(self, definition):\n if not definition:\n return EndpointDefinition()\n if isinstance(definition, EndpointDefinition):\n return definition\n elif len(definition) == 1:\n return EndpointDefinition(\n func=definition[0],\n )\n elif len(definition) == 2:\n return EndpointDefinition(\n func=definition[0],\n response_schema=definition[1],\n )\n elif len(definition) == 3:\n return EndpointDefinition(\n func=definition[0],\n request_schema=definition[1],\n response_schema=definition[2],\n )\n elif len(definition) == 4:\n return EndpointDefinition(\n func=definition[0],\n request_schema=definition[1],\n response_schema=definition[2],\n header_func=definition[3],\n )", "docstring": "Generate a definition.\n\n The input might already be a `EndpointDefinition` or it might be a tuple." }, { "code": "def get_unused_code(self, min_confidence=0, sort_by_size=False):\n if not 0 <= min_confidence <= 100:\n raise ValueError('min_confidence must be between 0 and 100.')\n def by_name(item):\n return (item.filename.lower(), item.first_lineno)\n def by_size(item):\n return (item.size,) + by_name(item)\n unused_code = (self.unused_attrs + self.unused_classes +\n self.unused_funcs + self.unused_imports +\n self.unused_props + self.unused_vars +\n self.unreachable_code)\n confidently_unused = [obj for obj in unused_code\n if obj.confidence >= min_confidence]\n return sorted(confidently_unused,\n key=by_size if sort_by_size else by_name)", "docstring": "Return ordered list of unused Item objects." }, { "code": "def generate_property_deprecation_message(to_be_removed_in_version, old_name, new_name, new_attribute,\n module_name='Client'):\n message = \"Call to deprecated property '{name}'. This property will be removed in version '{version}'\".format(\n name=old_name,\n version=to_be_removed_in_version,\n )\n message += \" Please use the '{new_name}' property on the '{module_name}.{new_attribute}' attribute moving forward.\".format(\n new_name=new_name,\n module_name=module_name,\n new_attribute=new_attribute,\n )\n return message", "docstring": "Generate a message to be used when warning about the use of deprecated properties.\n\n :param to_be_removed_in_version: Version of this module the deprecated property will be removed in.\n :type to_be_removed_in_version: str\n :param old_name: Deprecated property name.\n :type old_name: str\n :param new_name: Name of the new property name to use.\n :type new_name: str\n :param new_attribute: The new attribute where the new property can be found.\n :type new_attribute: str\n :param module_name: Name of the module containing the new method to use.\n :type module_name: str\n :return: Full deprecation warning message for the indicated property.\n :rtype: str" }, { "code": "def denoise_z15():\n hparams = xmoe2_dense_0()\n hparams.decoder_type = \"denoising\"\n hparams.noising_spec_train = {\"type\": \"random_zipfian\", \"prob\": 0.15}\n hparams.noising_use_eval_during_train = 0.25\n return hparams", "docstring": "Replace tokens instead of masking." }, { "code": "def add_group_role(request, role, group, domain=None, project=None):\n manager = keystoneclient(request, admin=True).roles\n return manager.grant(role=role, group=group, domain=domain,\n project=project)", "docstring": "Adds a role for a group on a domain or project." }, { "code": "def register_arguments(cls, parser):\n if hasattr(cls, \"_dont_register_arguments\"):\n return\n prefix = cls.configuration_key_prefix()\n cfgkey = cls.configuration_key\n parser.add_argument(\"--%s-%s\" % (prefix, cfgkey),\n action=\"store_true\",\n dest=\"%s_%s\" % (prefix, cfgkey),\n default=False,\n help=\"%s: %s\" %\n (cls.__name__, cls.help()))\n args = cls.init_argnames()\n defaults = cls._init_argdefaults()\n for arg in args[0:len(args) - len(defaults)]:\n parser.add_argument(\"--%s-%s-%s\" % (prefix, cfgkey, arg),\n dest=\"%s_%s_%s\" % (prefix, cfgkey, arg),\n help=\"\")\n for i, arg in enumerate(args[len(args) - len(defaults):]):\n parser.add_argument(\"--%s-%s-%s\" % (prefix, cfgkey, arg),\n dest=\"%s_%s_%s\" % (prefix, cfgkey, arg),\n default=defaults[i],\n help=\"default: %(default)s\")", "docstring": "Register command line options.\n\n Implement this method for normal options behavior with protection from\n OptionConflictErrors. If you override this method and want the default\n --$name option(s) to be registered, be sure to call super()." }, { "code": "def get_outcome_results(self, course_id, include=None, outcome_ids=None, user_ids=None):\r\n path = {}\r\n data = {}\r\n params = {}\r\n path[\"course_id\"] = course_id\r\n if user_ids is not None:\r\n params[\"user_ids\"] = user_ids\r\n if outcome_ids is not None:\r\n params[\"outcome_ids\"] = outcome_ids\r\n if include is not None:\r\n params[\"include\"] = include\r\n self.logger.debug(\"GET /api/v1/courses/{course_id}/outcome_results with query params: {params} and form data: {data}\".format(params=params, data=data, **path))\r\n return self.generic_request(\"GET\", \"/api/v1/courses/{course_id}/outcome_results\".format(**path), data=data, params=params, no_data=True)", "docstring": "Get outcome results.\r\n\r\n Gets the outcome results for users and outcomes in the specified context." }, { "code": "def read_instance(self, cls, sdmxobj, offset=None, first_only=True):\r\n if offset:\r\n try:\r\n base = self._paths[offset](sdmxobj._elem)[0]\r\n except IndexError:\r\n return None\r\n else:\r\n base = sdmxobj._elem\r\n result = self._paths[cls](base)\r\n if result:\r\n if first_only:\r\n return cls(self, result[0])\r\n else:\r\n return [cls(self, i) for i in result]", "docstring": "If cls in _paths and matches,\r\n return an instance of cls with the first XML element,\r\n or, if first_only is False, a list of cls instances \r\n for all elements found,\r\n If no matches were found, return None." }, { "code": "def search(self, pattern):\n for node in self.nodes.values():\n match, following = pattern.match(self, node)\n if match:\n return match, following\n return [], None", "docstring": "Searches the graph for a sub-graph that matches the given pattern\n and returns the first match it finds." }, { "code": "def _imm_dir(self):\n dir0 = set(dir(self.__class__))\n dir0.update(self.__dict__.keys())\n dir0.update(six.iterkeys(_imm_value_data(self)))\n return sorted(list(dir0))", "docstring": "An immutable object's dir function should list not only its attributes, but also its un-cached\n lazy values." }, { "code": "def pack(self, out: IO):\n out.write(self.access_flags.pack())\n out.write(pack('>HH', self._name_index, self._descriptor_index))\n self.attributes.pack(out)", "docstring": "Write the Field to the file-like object `out`.\n\n .. note::\n\n Advanced usage only. You will typically never need to call this\n method as it will be called for you when saving a ClassFile.\n\n :param out: Any file-like object providing `write()`" }, { "code": "def value(self, value):\n if value not in self.options:\n if len(self.labels) == len(self.options):\n self.options[-1] = value\n else:\n self.options.append(value)\n self._value = value", "docstring": "Setter for value.\n\n :param value: The value.\n :type value: object" }, { "code": "def auto_instantiate(*classes):\n def decorator(f):\n sig = signature(f)\n @wraps(f)\n def _(*args, **kwargs):\n bvals = sig.bind(*args, **kwargs)\n for varname, val in bvals.arguments.items():\n anno = sig.parameters[varname].annotation\n if anno in classes or (len(classes) == 0 and anno != _empty):\n bvals.arguments[varname] = anno(val)\n return f(*bvals.args, **bvals.kwargs)\n return FunctionMaker.create(\n f, 'return _(%(signature)s)', dict(_=_, __wrapped__=f)\n )\n return decorator", "docstring": "Creates a decorator that will instantiate objects based on function\n parameter annotations.\n\n The decorator will check every argument passed into ``f``. If ``f`` has an\n annotation for the specified parameter and the annotation is found in\n ``classes``, the parameter value passed in will be used to construct a new\n instance of the expression that is the annotation.\n\n An example (Python 3):\n\n .. code-block:: python\n\n @auto_instantiate(int)\n def foo(a: int, b: float):\n pass\n\n Any value passed in as ``b`` is left unchanged. Anything passed as the\n parameter for ``a`` will be converted to :class:`int` before calling the\n function.\n\n Since Python 2 does not support annotations, the\n :func:`~data.decorators.annotate` function should can be used:\n\n .. code-block:: python\n\n @auto_instantiate(int)\n @annotate(a=int)\n def foo(a, b):\n pass\n\n\n :param classes: Any number of classes/callables for which\n auto-instantiation should be performed. If empty, perform\n for all.\n\n :note: When dealing with data, it is almost always more convenient to use\n the :func:`~data.decorators.data` decorator instead." }, { "code": "def flatten_all_but_last(a):\n ret = tf.reshape(a, [-1, tf.shape(a)[-1]])\n if not tf.executing_eagerly():\n ret.set_shape([None] + a.get_shape().as_list()[-1:])\n return ret", "docstring": "Flatten all dimensions of a except the last." }, { "code": "def _apply_Create(self, change):\n ar = _AzureRecord(self._resource_group, change.new)\n create = self._dns_client.record_sets.create_or_update\n create(resource_group_name=ar.resource_group,\n zone_name=ar.zone_name,\n relative_record_set_name=ar.relative_record_set_name,\n record_type=ar.record_type,\n parameters=ar.params)\n self.log.debug('* Success Create/Update: {}'.format(ar))", "docstring": "A record from change must be created.\n\n :param change: a change object\n :type change: octodns.record.Change\n\n :type return: void" }, { "code": "def minor_extent(self) -> complex:\n return min((self.max() - self.null, self.null - self.min()))", "docstring": "Minimum deviation from null." }, { "code": "def load_configs(self, conf_file):\n with open(conf_file) as stream:\n lines = itertools.chain((\"[global]\",), stream)\n self._config.read_file(lines)\n return self._config['global']", "docstring": "Assumes that the config file does not have any sections, so throw it all in global" }, { "code": "def run_command(\n host,\n command,\n username=None,\n key_path=None,\n noisy=True\n):\n with HostSession(host, username, key_path, noisy) as s:\n if noisy:\n print(\"\\n{}{} $ {}\\n\".format(shakedown.fchr('>>'), host, command))\n s.run(command)\n ec, output = s.get_result()\n return ec == 0, output", "docstring": "Run a command via SSH, proxied through the mesos master\n\n :param host: host or IP of the machine to execute the command on\n :type host: str\n :param command: the command to execute\n :type command: str\n :param username: SSH username\n :type username: str\n :param key_path: path to the SSH private key to use for SSH authentication\n :type key_path: str\n :return: True if successful, False otherwise\n :rtype: bool\n :return: Output of command\n :rtype: string" }, { "code": "def not_query(expression):\n compiled_expression = compile_query(expression)\n def _not(index, expression=compiled_expression):\n all_keys = index.get_all_keys()\n returned_keys = expression(index)\n return [key for key in all_keys if key not in returned_keys]\n return _not", "docstring": "Apply logical not operator to expression." }, { "code": "def parse_multiple_json(json_file, offset=None):\n json_info_list = []\n if not os.path.exists(json_file):\n return json_info_list\n try:\n with open(json_file, \"r\") as f:\n if offset:\n f.seek(offset)\n for line in f:\n if line[-1] != \"\\n\":\n break\n json_info = json.loads(line)\n json_info_list.append(json_info)\n offset += len(line)\n except BaseException as e:\n logging.error(e.message)\n return json_info_list, offset", "docstring": "Parse multiple json records from the given file.\n\n Seek to the offset as the start point before parsing\n if offset set. return empty list if the json file does\n not exists or exception occurs.\n\n Args:\n json_file (str): File path to be parsed.\n offset (int): Initial seek position of the file.\n\n Returns:\n A dict of json info.\n New offset after parsing." }, { "code": "def flat_map(self, func=None, name=None):\n if func is None:\n func = streamsx.topology.runtime._identity\n if name is None:\n name = 'flatten'\n sl = _SourceLocation(_source_info(), 'flat_map')\n _name = self.topology.graph._requested_name(name, action='flat_map', func=func)\n stateful = self._determine_statefulness(func)\n op = self.topology.graph.addOperator(self.topology.opnamespace+\"::FlatMap\", func, name=_name, sl=sl, stateful=stateful)\n op.addInputPort(outputPort=self.oport)\n streamsx.topology.schema.StreamSchema._fnop_style(self.oport.schema, op, 'pyStyle')\n oport = op.addOutputPort(name=_name)\n return Stream(self.topology, oport)._make_placeable()._layout('FlatMap', name=_name, orig_name=name)", "docstring": "Maps and flatterns each tuple from this stream into 0 or more tuples.\n\n\n For each tuple on this stream ``func(tuple)`` is called.\n If the result is not `None` then the the result is iterated over\n with each value from the iterator that is not `None` will be submitted\n to the return stream.\n\n If the result is `None` or an empty iterable then no tuples are submitted to\n the returned stream.\n \n Args:\n func: A callable that takes a single parameter for the tuple.\n If not supplied then a function equivalent to ``lambda tuple_ : tuple_`` is used.\n This is suitable when each tuple on this stream is an iterable to be flattened.\n \n name(str): Name of the flattened stream, defaults to a generated name.\n\n If invoking ``func`` for a tuple on the stream raises an exception\n then its processing element will terminate. By default the processing\n element will automatically restart though tuples may be lost.\n\n If ``func`` is a callable object then it may suppress exceptions\n by return a true value from its ``__exit__`` method. When an\n exception is suppressed no tuples are submitted to the flattened\n and mapped stream corresponding to the input tuple\n that caused the exception.\n\n Returns:\n Stream: A Stream containing flattened and mapped tuples.\n Raises:\n TypeError: if `func` does not return an iterator nor None\n\n .. versionchanged:: 1.11 `func` is optional." }, { "code": "def unregister_message_handler(self, target_or_handler):\n if isinstance(target_or_handler, str):\n del self._message_handlers[target_or_handler]\n else:\n for key, val in self._message_handlers.items():\n if val == target_or_handler:\n del self._message_handlers[key]", "docstring": "Unregister a mpv script message handler for the given script message target name.\n\n You can also call the ``unregister_mpv_messages`` function attribute set on the handler function when it is\n registered." }, { "code": "def getTokensEndLoc():\r\n import inspect\r\n fstack = inspect.stack()\r\n try:\r\n for f in fstack[2:]:\r\n if f[3] == \"_parseNoCache\":\r\n endloc = f[0].f_locals[\"loc\"]\r\n return endloc\r\n else:\r\n raise ParseFatalException(\"incorrect usage of getTokensEndLoc - may only be called from within a parse action\")\r\n finally:\r\n del fstack", "docstring": "Method to be called from within a parse action to determine the end\r\n location of the parsed tokens." }, { "code": "def respond(self, code):\n resp = HttpResponse(code, self.connection)\n resp.request = self\n if hasattr(self, 'version'):\n resp.version = self.version\n return resp", "docstring": "Starts a response.\n\n ``code`` is an integer standing for standard HTTP status code.\n\n This method will automatically adjust the response to adapt to request\n parameters, such as \"Accept-Encoding\" and \"TE\"." }, { "code": "def packagePlugin(self, dir=os.getcwd(), extraArgs=[]):\n\t\tdistDir = os.path.join(os.path.abspath(dir), 'dist')\n\t\tself.runUAT([\n\t\t\t'BuildPlugin',\n\t\t\t'-Plugin=' + self.getPluginDescriptor(dir),\n\t\t\t'-Package=' + distDir\n\t\t] + extraArgs)", "docstring": "Packages a build of the Unreal plugin in the specified directory, suitable for use as a prebuilt Engine module" }, { "code": "def defaultMachine(use_rpm_default=True):\n if use_rpm_default:\n try:\n rmachine = subprocess.check_output(['rpm', '--eval=%_target_cpu'], shell=False).rstrip()\n rmachine = SCons.Util.to_str(rmachine)\n except Exception as e:\n return defaultMachine(False)\n else:\n rmachine = platform.machine()\n if rmachine in arch_canon:\n rmachine = arch_canon[rmachine][0]\n return rmachine", "docstring": "Return the canonicalized machine name." }, { "code": "def parse_value(cell):\n value = cell.value\n if isinstance(value, string_types):\n value = value.strip()\n if isinstance(value, (datetime)):\n value = value.isoformat()\n return value", "docstring": "Extrae el valor de una celda de Excel como texto." }, { "code": "def _load_rules(self):\n for ruleset in self.active_rulesets:\n section_name = 'sweep_rules_' + ruleset.lower()\n try:\n ruledefs = getattr(self.config, section_name)\n except AttributeError:\n raise error.UserError(\"There is no [{}] section in your configuration\"\n .format(section_name.upper()))\n for ruledef, filtercond in ruledefs.items():\n if ruledef.endswith('.filter'):\n rulename = ruledef.rsplit('.', 1)[0]\n rule = SweepRule(ruleset, rulename,\n int(ruledefs.get(rulename + '.prio', '999')),\n ruledefs.get(rulename + '.order', self.default_order),\n parse_cond(filtercond))\n self.rules.append(rule)\n self.rules.sort(key=lambda x: (x.prio, x.name))\n return self.rules", "docstring": "Load rule definitions from config." }, { "code": "def cookies(self):\n c = Cookie.SimpleCookie(self.getheader('set-cookie'))\n return dict((i.key, i.value) for i in c.values())", "docstring": "Cookies in dict" }, { "code": "def Run(self):\n if not data_store.AFF4Enabled():\n return\n try:\n filestore = aff4.FACTORY.Create(\n FileStore.PATH, FileStore, mode=\"rw\", token=aff4.FACTORY.root_token)\n filestore.Close()\n hash_filestore = aff4.FACTORY.Create(\n HashFileStore.PATH,\n HashFileStore,\n mode=\"rw\",\n token=aff4.FACTORY.root_token)\n hash_filestore.Close()\n nsrl_filestore = aff4.FACTORY.Create(\n NSRLFileStore.PATH,\n NSRLFileStore,\n mode=\"rw\",\n token=aff4.FACTORY.root_token)\n nsrl_filestore.Close()\n except access_control.UnauthorizedAccess:\n pass", "docstring": "Create FileStore and HashFileStore namespaces." }, { "code": "def enable_autocuts(self, option):\n option = option.lower()\n assert(option in self.autocuts_options), \\\n ImageViewError(\"Bad autocuts option '%s': must be one of %s\" % (\n str(self.autocuts_options)))\n self.t_.set(autocuts=option)", "docstring": "Set ``autocuts`` behavior.\n\n Parameters\n ----------\n option : {'on', 'override', 'once', 'off'}\n Option for auto-cut behavior. A list of acceptable options can\n also be obtained by :meth:`get_autocuts_options`.\n\n Raises\n ------\n ginga.ImageView.ImageViewError\n Invalid option." }, { "code": "def readCell(self, row, col):\r\n try:\r\n if self.__sheet is None:\r\n self.openSheet(super(ExcelRead, self).DEFAULT_SHEET)\r\n return self.__sheet.cell(row, col).value\r\n except BaseException as excp:\r\n raise UfException(Errors.UNKNOWN_ERROR, \"Unknown Error in Excellib.readCell %s\" % excp)", "docstring": "read a cell" }, { "code": "def truncate(self, table):\n if isinstance(table, (list, set, tuple)):\n for t in table:\n self._truncate(t)\n else:\n self._truncate(table)", "docstring": "Empty a table by deleting all of its rows." }, { "code": "def is_seq(obj):\n if not hasattr(obj, '__iter__'):\n return False\n if isinstance(obj, basestring):\n return False\n return True", "docstring": "Returns True if object is not a string but is iterable" }, { "code": "def _update_device_from_fs(self, device):\n try:\n directory_entries = listdir(device[\"mount_point\"])\n lowercase_directory_entries = [e.lower() for e in directory_entries]\n if self.MBED_HTM_NAME.lower() in lowercase_directory_entries:\n self._update_device_from_htm(device)\n except (OSError, IOError) as e:\n logger.warning(\n 'Marking device with mount point \"%s\" as unmounted due to the '\n \"following error: %s\",\n device[\"mount_point\"],\n e,\n )\n device[\"mount_point\"] = None", "docstring": "Updates the device information based on files from its 'mount_point'\n @param device Dictionary containing device information" }, { "code": "def add_new_devices_callback(self, callback):\n self._new_devices_callbacks.append(callback)\n _LOGGER.debug('Added new devices callback to %s', callback)", "docstring": "Register as callback for when new devices are added." }, { "code": "def get_absolute_path(cls, roots, path):\n for root in roots:\n abspath = os.path.abspath(os.path.join(root, path))\n if abspath.startswith(root) and os.path.exists(abspath):\n return abspath\n return 'file-not-found'", "docstring": "Returns the absolute location of ``path`` relative to one of\n the ``roots``.\n\n ``roots`` is the path configured for this `StaticFileHandler`\n (in most cases the ``static_path`` `Application` setting)." }, { "code": "def get_learning_objectives(self):\n mgr = self._get_provider_manager('LEARNING')\n lookup_session = mgr.get_objective_lookup_session(proxy=getattr(self, \"_proxy\", None))\n lookup_session.use_federated_objective_bank_view()\n return lookup_session.get_objectives_by_ids(self.get_learning_objective_ids())", "docstring": "This method also mirrors that in the Item." }, { "code": "def init_pipette():\n global session\n pipette_info = set_current_mount(session.adapter, session)\n pipette = pipette_info['pipette']\n res = {}\n if pipette:\n session.current_model = pipette_info['model']\n if not feature_flags.use_protocol_api_v2():\n mount = pipette.mount\n session.current_mount = mount\n else:\n mount = pipette.get('mount')\n session.current_mount = mount_by_name[mount]\n session.pipettes[mount] = pipette\n res = {'mount': mount, 'model': pipette_info['model']}\n log.info(\"Pipette info {}\".format(session.pipettes))\n return res", "docstring": "Finds pipettes attached to the robot currently and chooses the correct one\n to add to the session.\n\n :return: The pipette type and mount chosen for deck calibration" }, { "code": "def namedb_get_all_names( cur, current_block, offset=None, count=None, include_expired=False ):\n unexpired_query = \"\"\n unexpired_args = ()\n if not include_expired:\n unexpired_query, unexpired_args = namedb_select_where_unexpired_names( current_block )\n unexpired_query = 'WHERE {}'.format(unexpired_query)\n query = \"SELECT name FROM name_records JOIN namespaces ON name_records.namespace_id = namespaces.namespace_id \" + unexpired_query + \" ORDER BY name \"\n args = unexpired_args\n offset_count_query, offset_count_args = namedb_offset_count_predicate( offset=offset, count=count )\n query += offset_count_query + \";\"\n args += offset_count_args\n name_rows = namedb_query_execute( cur, query, tuple(args) )\n ret = []\n for name_row in name_rows:\n rec = {}\n rec.update( name_row )\n ret.append( rec['name'] )\n return ret", "docstring": "Get a list of all names in the database, optionally\n paginated with offset and count. Exclude expired names. Include revoked names." }, { "code": "def cat(self, paths, check_crc=False):\n if not isinstance(paths, list):\n raise InvalidInputException(\"Paths should be a list\")\n if not paths:\n raise InvalidInputException(\"cat: no path given\")\n processor = lambda path, node, check_crc=check_crc: self._handle_cat(path, node, check_crc)\n for item in self._find_items(paths, processor, include_toplevel=True,\n include_children=False, recurse=False):\n if item:\n yield item", "docstring": "Fetch all files that match the source file pattern\n and display their content on stdout.\n\n :param paths: Paths to display\n :type paths: list of strings\n :param check_crc: Check for checksum errors\n :type check_crc: boolean\n :returns: a generator that yields strings" }, { "code": "def close_statement(self, connection_id, statement_id):\n request = requests_pb2.CloseStatementRequest()\n request.connection_id = connection_id\n request.statement_id = statement_id\n self._apply(request)", "docstring": "Closes a statement.\n\n :param connection_id:\n ID of the current connection.\n\n :param statement_id:\n ID of the statement to close." }, { "code": "def format(self, fmt):\n val = ''\n for x in fmt:\n if x == 'd':\n val += self._driv\n elif x == 'p':\n val += self._path\n elif x == 'n':\n val += self._name\n elif x == 'x':\n val += self._ext\n elif x == 'z':\n if self._size != None: val += str(self._size)\n elif x == 't':\n if self._time != None: val += str(self._time)\n return val", "docstring": "Returns string representing the items specified in the format string\n\n The format string can contain:\n\n .. code::\n\n d - drive letter\n p - path\n n - name\n x - extension\n z - file size\n t - file time in seconds\n\n And, you can string them together, e.g. `dpnx` returns the fully \n qualified name.\n\n On platforms like Unix, where drive letter doesn't make sense, it's simply\n ignored when used in a format string, making it easy to construct fully\n qualified path names in an os independent manner.\n\n Parameters\n ----------\n fmt : str\n A string representing the elements you want returned.\n\n Returns\n -------\n str\n A string containing the elements of the path requested in `fmt`" }, { "code": "def send(self, **kwargs):\n assert len(kwargs) == 1, \"Must make a single request.\"\n res = self.send_req(sc_pb.Request(**kwargs))\n return getattr(res, list(kwargs.keys())[0])", "docstring": "Create and send a specific request, and return the response.\n\n For example: send(ping=sc_pb.RequestPing()) => sc_pb.ResponsePing\n\n Args:\n **kwargs: A single kwarg with the name and value to fill in to Request.\n\n Returns:\n The Response corresponding to your request." }, { "code": "def unhumanize_class(my_classes):\n result = []\n interval = my_classes[-1] - my_classes[-2]\n min_value = 0\n for max_value in my_classes:\n result.append((format_decimal(interval, min_value),\n format_decimal(interval, max_value)))\n min_value = max_value\n return result", "docstring": "Return class as interval without formatting." }, { "code": "def restore(self):\n if len(list(self.backup.keys())) == 0:\n return\n for key in self.backup.keys():\n if key != 'WCSCDATE':\n self.__dict__[self.wcstrans[key]] = self.orig_wcs[self.backup[key]]\n self.update()", "docstring": "Reset the active WCS keywords to values stored in the\n backup keywords." }, { "code": "def max_repetition_level(self, path):\n max_level = 0\n for part in path:\n element = self.schema_element(part)\n if element.repetition_type == parquet_thrift.FieldRepetitionType.REQUIRED:\n max_level += 1\n return max_level", "docstring": "Get the max repetition level for the given schema path." }, { "code": "def Validate(self, problems=default_problem_reporter):\n found_problem = False\n found_problem = ((not util.ValidateRequiredFieldsAreNotEmpty(\n self, self._REQUIRED_FIELD_NAMES, problems))\n or found_problem)\n found_problem = self.ValidateAgencyUrl(problems) or found_problem\n found_problem = self.ValidateAgencyLang(problems) or found_problem\n found_problem = self.ValidateAgencyTimezone(problems) or found_problem\n found_problem = self.ValidateAgencyFareUrl(problems) or found_problem\n found_problem = self.ValidateAgencyEmail(problems) or found_problem\n return not found_problem", "docstring": "Validate attribute values and this object's internal consistency.\n\n Returns:\n True iff all validation checks passed." }, { "code": "def wrap_passthrough(self, text, multiline=True):\n if not multiline:\n text = text.lstrip()\n if multiline:\n out = \"\\\\\"\n else:\n out = \"\\\\\\\\\"\n out += self.add_ref(\"passthrough\", text) + unwrapper\n if not multiline:\n out += \"\\n\"\n return out", "docstring": "Wrap a passthrough." }, { "code": "def delete_all(self):\n def delete_action_gen():\n scanner = scan(self.es,\n index=self.index_name,\n query={'query': {'match_all':{}}})\n for v in scanner:\n yield { '_op_type': 'delete',\n '_index': self.index_name,\n '_type': v['_type'],\n '_id': v['_id'],\n }\n bulk(self.es, delete_action_gen())", "docstring": "Delete all books from the index" }, { "code": "def capture(self, payment_id, amount, data={}, **kwargs):\n url = \"{}/{}/capture\".format(self.base_url, payment_id)\n data['amount'] = amount\n return self.post_url(url, data, **kwargs)", "docstring": "Capture Payment for given Id\n\n Args:\n payment_id : Id for which payment object has to be retrieved\n Amount : Amount for which the payment has to be retrieved\n\n Returns:\n Payment dict after getting captured" }, { "code": "def scaledBy(self, scale):\n scaled = deepcopy(self)\n if type(scaled.value) in (int, float):\n scaled.value *= scale\n elif isinstance(scaled.value, numbers):\n scaled.value.values = tuple(v * scale for v in scaled.value.values)\n return scaled", "docstring": "Return a new Value scaled by a given number for ints and floats." }, { "code": "def create_wallet(password, api_code, service_url, priv=None, label=None, email=None):\n params = {'password': password, 'api_code': api_code}\n if priv is not None:\n params['priv'] = priv\n if label is not None:\n params['label'] = label\n if email is not None:\n params['email'] = email\n response = util.call_api(\"api/v2/create\", params, base_url=service_url)\n json_response = json.loads(response)\n return CreateWalletResponse(json_response['guid'],\n json_response['address'],\n json_response['label'])", "docstring": "Create a new Blockchain.info wallet. It can be created containing a \n pre-generated private key or will otherwise generate a new private key. \n\n :param str password: password for the new wallet. At least 10 characters.\n :param str api_code: API code with create wallets permission\n :param str service_url: URL to an instance of service-my-wallet-v3 (with trailing slash)\n :param str priv: private key to add to the wallet (optional)\n :param str label: label for the first address in the wallet (optional)\n :param str email: email to associate with the new wallet (optional)\n :return: an instance of :class:`WalletResponse` class" }, { "code": "def is_valid_size(size, chunk_size):\n min_csize = current_app.config['FILES_REST_MULTIPART_CHUNKSIZE_MIN']\n max_size = \\\n chunk_size * current_app.config['FILES_REST_MULTIPART_MAX_PARTS']\n return size > min_csize and size <= max_size", "docstring": "Validate max theoretical size." }, { "code": "def is_ready(self):\n if not self._thread:\n return False\n if not self._ready.is_set():\n return False\n return True", "docstring": "Is thread & ioloop ready.\n\n :returns bool:" }, { "code": "def gid(self):\n if not self._gid:\n if self.controller.config.daemon.group:\n self._gid = grp.getgrnam(self.config.daemon.group).gr_gid\n else:\n self._gid = os.getgid()\n return self._gid", "docstring": "Return the group id that the daemon will run with\n\n :rtype: int" }, { "code": "def extract_patches(images, patch_shape, samples_per_image=40, seed=0,\n cycle=True):\n rs = np.random.RandomState(seed)\n for Xi in itr.cycle(images):\n w, h = [Xi.shape[i]-patch_shape[i] for i in range(2)]\n assert w > 0 and h > 0\n indices = np.asarray(list(itr.product(range(w), range(h))))\n rs.shuffle(indices)\n for x, y in indices[:samples_per_image]:\n yield Xi[x:x+patch_shape[0], y:y+patch_shape[1]]", "docstring": "Takes a set of images and yields randomly chosen patches of specified size.\n\n Parameters\n ----------\n images : iterable\n The images have to be iterable, and each element must be a Numpy array\n with at least two spatial 2 dimensions as the first and second axis.\n patch_shape : tuple, length 2\n The spatial shape of the patches that should be extracted. If the\n images have further dimensions beyond the spatial, the patches will\n copy these too.\n samples_per_image : int\n Samples to extract before moving on to the next image.\n seed : int\n Seed with which to select the patches.\n cycle : bool\n If True, then the function will produce patches indefinitely, by going\n back to the first image when all are done. If False, the iteration will\n stop when there are no more images.\n\n Returns\n -------\n patch_generator\n This function returns a generator that will produce patches.\n\n Examples\n --------\n >>> import deepdish as dd\n >>> import matplotlib.pylab as plt\n >>> import itertools\n >>> images = ag.io.load_example('mnist')\n\n Now, let us say we want to exact patches from the these, where each patch\n has at least some activity.\n\n >>> gen = dd.image.extract_patches(images, (5, 5))\n >>> gen = (x for x in gen if x.mean() > 0.1)\n >>> patches = np.array(list(itertools.islice(gen, 25)))\n >>> patches.shape\n (25, 5, 5)\n >>> dd.plot.images(patches)\n >>> plt.show()" }, { "code": "def mv_normal_cov_like(x, mu, C):\n R\n if len(np.shape(x)) > 1:\n return np.sum([flib.cov_mvnorm(r, mu, C) for r in x])\n else:\n return flib.cov_mvnorm(x, mu, C)", "docstring": "R\"\"\"\n Multivariate normal log-likelihood parameterized by a covariance\n matrix.\n\n .. math::\n f(x \\mid \\pi, C) = \\frac{1}{(2\\pi|C|)^{1/2}} \\exp\\left\\{ -\\frac{1}{2} (x-\\mu)^{\\prime}C^{-1}(x-\\mu) \\right\\}\n\n :Parameters:\n - `x` : (n,k)\n - `mu` : (k) Location parameter.\n - `C` : (k,k) Positive definite covariance matrix.\n\n .. seealso:: :func:`mv_normal_like`, :func:`mv_normal_chol_like`" }, { "code": "def _ApplySudsJurkoAppenderPatch(self):\n def PatchedAppend(self, parent, content):\n obj = content.value\n child = self.node(content)\n parent.append(child)\n for item in obj:\n cont = suds.mx.Content(tag=item[0], value=item[1])\n suds.mx.appender.Appender.append(self, child, cont)\n suds.mx.appender.ObjectAppender.append = PatchedAppend", "docstring": "Appends a Monkey Patch to the suds.mx.appender module.\n\n This resolves an issue where empty objects are ignored and stripped from the\n request output. More details can be found on the suds-jurko issue tracker:\n https://goo.gl/uyYw0C" }, { "code": "def vote(self, direction=0):\n url = self.reddit_session.config['vote']\n data = {'id': self.fullname,\n 'dir': six.text_type(direction)}\n if self.reddit_session.user:\n urls = [urljoin(self.reddit_session.user._url, 'disliked'),\n urljoin(self.reddit_session.user._url, 'liked')]\n self.reddit_session.evict(urls)\n return self.reddit_session.request_json(url, data=data)", "docstring": "Vote for the given item in the direction specified.\n\n Note: votes must be cast by humans. That is, API clients proxying a\n human's action one-for-one are OK, but bots deciding how to vote on\n content or amplifying a human's vote are not. See the reddit rules for\n more details on what constitutes vote cheating.\n\n Source for note: http://www.reddit.com/dev/api#POST_api_vote\n\n :returns: The json response from the server." }, { "code": "def image_to_file(self, path):\n _LOGGER.debug(\"Writing image from %s to %s\", self.name, path)\n response = self._cached_image\n if response.status_code == 200:\n with open(path, 'wb') as imgfile:\n copyfileobj(response.raw, imgfile)\n else:\n _LOGGER.error(\"Cannot write image to file, response %s\",\n response.status_code,\n exc_info=True)", "docstring": "Write image to file.\n\n :param path: Path to write file" }, { "code": "def plotPixel(self, x, y, color=\"black\"):\n p = Point(x, y)\n p.fill(color)\n p.draw(self)\n p.t = lambda v: v\n p.tx = lambda v: v\n p.ty = lambda v: v", "docstring": "Doesn't use coordinant system." }, { "code": "def cli(env, volume_id, replicant_id, immediate):\n block_storage_manager = SoftLayer.BlockStorageManager(env.client)\n success = block_storage_manager.failover_to_replicant(\n volume_id,\n replicant_id,\n immediate\n )\n if success:\n click.echo(\"Failover to replicant is now in progress.\")\n else:\n click.echo(\"Failover operation could not be initiated.\")", "docstring": "Failover a block volume to the given replicant volume." }, { "code": "def precision_at_proportions(self):\n return plot.precision_at_proportions(self.y_true, self.y_score,\n ax=_gen_ax())", "docstring": "Precision at proportions plot" }, { "code": "def encoding(self):\n if hasattr(self, '_encoding'):\n return self._encoding\n if isinstance(self.content, six.text_type):\n return 'unicode'\n encoding = get_encoding(self.headers, self.content)\n if not encoding and chardet is not None:\n encoding = chardet.detect(self.content[:600])['encoding']\n if encoding and encoding.lower() == 'gb2312':\n encoding = 'gb18030'\n self._encoding = encoding or 'utf-8'\n return self._encoding", "docstring": "encoding of Response.content.\n\n if Response.encoding is None, encoding will be guessed\n by header or content or chardet if available." }, { "code": "def update_settings(self, service_id, version_number, settings={}):\n\t\tbody = urllib.urlencode(settings)\n\t\tcontent = self._fetch(\"/service/%s/version/%d/settings\" % (service_id, version_number), method=\"PUT\", body=body)\n\t\treturn FastlySettings(self, content)", "docstring": "Update the settings for a particular service and version." }, { "code": "def localize(self, location=None, latitude=None, longitude=None,\n **kwargs):\n if location is None:\n location = Location(latitude, longitude, **kwargs)\n return LocalizedPVSystem(pvsystem=self, location=location)", "docstring": "Creates a LocalizedPVSystem object using this object\n and location data. Must supply either location object or\n latitude, longitude, and any location kwargs\n\n Parameters\n ----------\n location : None or Location, default None\n latitude : None or float, default None\n longitude : None or float, default None\n **kwargs : see Location\n\n Returns\n -------\n localized_system : LocalizedPVSystem" }, { "code": "def tokens(self):\n spans = self.word_tokenizer.span_tokenize(self.text)\n toks = [Token(\n text=self.text[span[0]:span[1]],\n start=span[0] + self.start,\n end=span[1] + self.start,\n lexicon=self.lexicon\n ) for span in spans]\n return toks", "docstring": "Return a list of token Spans for this sentence." }, { "code": "def add_defaults(self, ctype: ContentType = None) -> \"InstanceNode\":\n val = self.value\n if not (isinstance(val, StructuredValue) and self.is_internal()):\n return self\n res = self\n if isinstance(val, ObjectValue):\n if val:\n for mn in self._member_names():\n m = res._member(mn) if res is self else res.sibling(mn)\n res = m.add_defaults(ctype)\n res = res.up()\n return self.schema_node._add_defaults(res, ctype)\n if not val:\n return res\n en = res[0]\n while True:\n res = en.add_defaults(ctype)\n try:\n en = res.next()\n except NonexistentInstance:\n break\n return res.up()", "docstring": "Return the receiver with defaults added recursively to its value.\n\n Args:\n ctype: Content type of the defaults to be added. If it is\n ``None``, the content type will be the same as receiver's." }, { "code": "def cached(func):\n ret = None\n def call_or_cache(*args, **kwargs):\n nonlocal ret\n if ret is None:\n ret = func(*args, **kwargs)\n return ret\n return call_or_cache", "docstring": "Memoize a function result." }, { "code": "def buy(self, currencyPair, rate, amount, fillOrKill=None,\n immediateOrCancel=None, postOnly=None):\n return self._private('buy', currencyPair=currencyPair, rate=rate,\n amount=amount, fillOrKill=fillOrKill,\n immediateOrCancel=immediateOrCancel,\n postOnly=postOnly)", "docstring": "Places a limit buy order in a given market. Required POST parameters\n are \"currencyPair\", \"rate\", and \"amount\". If successful, the method\n will return the order number.\n You may optionally set \"fillOrKill\", \"immediateOrCancel\", \"postOnly\"\n to 1. A fill-or-kill order will either fill in its entirety or be\n completely aborted. An immediate-or-cancel order can be partially or\n completely filled, but any portion of the order that cannot be filled\n immediately will be canceled rather than left on the order book.\n A post-only order will only be placed if no portion of it fills\n immediately; this guarantees you will never pay the taker fee on any\n part of the order that fills." }, { "code": "def convert_md_to_rst(md_path, rst_temp_path):\n command = \"pandoc --write=rst --output=%s %s\" % (rst_temp_path, md_path)\n print(\"converting with pandoc: %s to %s\\n-->%s\" % (md_path, rst_temp_path,\n command))\n if os.path.exists(rst_temp_path):\n os.remove(rst_temp_path)\n os.system(command)\n if not os.path.exists(rst_temp_path):\n s = (\"Error running: %s\\n\"\n \" Did you install pandoc per the %s docstring?\" % (command,\n __file__))\n sys.exit(s)\n return read(rst_temp_path)", "docstring": "Convert the contents of a file from Markdown to reStructuredText.\n\n Returns the converted text as a Unicode string.\n\n Arguments:\n\n md_path: a path to a UTF-8 encoded Markdown file to convert.\n\n rst_temp_path: a temporary path to which to write the converted contents." }, { "code": "def from_list(cls, values):\n self = cls()\n for value in values:\n self.add(value)\n return self", "docstring": "Construct a tree from a list with paths." }, { "code": "def get_all_filters(self, server_id):\n server = self._get_server(server_id)\n return server.conn.EnumerateInstances('CIM_IndicationFilter',\n namespace=server.interop_ns)", "docstring": "Return all indication filters in a WBEM server.\n\n This function contacts the WBEM server and retrieves the indication\n filters by enumerating the instances of CIM class\n \"CIM_IndicationFilter\" in the Interop namespace of the WBEM server.\n\n Parameters:\n\n server_id (:term:`string`):\n The server ID of the WBEM server, returned by\n :meth:`~pywbem.WBEMSubscriptionManager.add_server`.\n\n Returns:\n\n :class:`py:list` of :class:`~pywbem.CIMInstance`: The indication\n filter instances.\n\n Raises:\n\n Exceptions raised by :class:`~pywbem.WBEMConnection`." }, { "code": "def get_named_by_definition(cls, element_list, string_def):\n try:\n return next(\n (\n st.value\n for st in element_list\n if st.definition == string_def\n )\n )\n except Exception:\n return None", "docstring": "Attempts to get an IOOS definition from a list of xml elements" }, { "code": "def html_init(name):\n result = \"\"\n result += \"\\n\"\n result += \"\\n\"\n result += \"\" + str(name) + \"\\n\"\n result += \"\\n\"\n result += \"\\n\"\n result += '

PyCM Report

'\n return result", "docstring": "Return HTML report file first lines.\n\n :param name: name of file\n :type name : str\n :return: html_init as str" }, { "code": "def add_lambda_permissions(function='',\n statement_id='',\n action='lambda:InvokeFunction',\n principal='',\n source_arn='',\n env='',\n region='us-east-1'):\n session = boto3.Session(profile_name=env, region_name=region)\n lambda_client = session.client('lambda')\n response_action = None\n prefixed_sid = FOREMAST_PREFIX + statement_id\n add_permissions_kwargs = {\n 'FunctionName': function,\n 'StatementId': prefixed_sid,\n 'Action': action,\n 'Principal': principal,\n }\n if source_arn:\n add_permissions_kwargs['SourceArn'] = source_arn\n try:\n lambda_client.add_permission(**add_permissions_kwargs)\n response_action = 'Add permission with Sid: {}'.format(prefixed_sid)\n except boto3.exceptions.botocore.exceptions.ClientError as error:\n LOG.debug('Add permission error: %s', error)\n response_action = \"Did not add permissions\"\n LOG.debug('Related StatementId (SID): %s', prefixed_sid)\n LOG.info(response_action)", "docstring": "Add permission to Lambda for the event trigger.\n\n Args:\n function (str): Lambda function name\n statement_id (str): IAM policy statement (principal) id\n action (str): Lambda action to allow\n principal (str): AWS principal to add permissions\n source_arn (str): ARN of the source of the event. Only needed for S3\n env (str): Environment/account of function\n region (str): AWS region of function" }, { "code": "def upload(self, filepath, service_path, remove=False):\n local = OSFS(os.path.dirname(filepath))\n if self.fs.hassyspath(service_path) and (\n self.fs.getsyspath(service_path) == local.getsyspath(\n os.path.basename(filepath))):\n if remove:\n os.remove(filepath)\n return\n if not self.fs.isdir(fs.path.dirname(service_path)):\n self.fs.makedir(\n fs.path.dirname(service_path),\n recursive=True,\n allow_recreate=True)\n if remove:\n fs.utils.movefile(\n local,\n os.path.basename(filepath),\n self.fs,\n service_path)\n else:\n fs.utils.copyfile(\n local,\n os.path.basename(filepath),\n self.fs,\n service_path)", "docstring": "\"Upload\" a file to a service\n\n This copies a file from the local filesystem into the ``DataService``'s\n filesystem. If ``remove==True``, the file is moved rather than copied.\n\n If ``filepath`` and ``service_path`` paths are the same, ``upload``\n deletes the file if ``remove==True`` and returns.\n\n Parameters\n ----------\n filepath : str\n Relative or absolute path to the file to be uploaded on the user's\n filesystem\n\n service_path: str\n Path to the destination for the file on the ``DataService``'s\n filesystem\n\n remove : bool\n If true, the file is moved rather than copied" }, { "code": "def run(self, *args):\n params = self.parser.parse_args(args)\n sources = params.source\n code = self.autocomplete(sources)\n return code", "docstring": "Autocomplete profile information." }, { "code": "def override_if_not_in_args(flag, argument, args):\n if flag not in args:\n args.extend([flag, argument])", "docstring": "Checks if flags is in args, and if not it adds the flag to args." }, { "code": "def visit_raise(self, node, parent):\n newnode = nodes.Raise(node.lineno, node.col_offset, parent)\n newnode.postinit(\n _visit_or_none(node, \"type\", self, newnode),\n _visit_or_none(node, \"inst\", self, newnode),\n _visit_or_none(node, \"tback\", self, newnode),\n )\n return newnode", "docstring": "visit a Raise node by returning a fresh instance of it" }, { "code": "def _get_cache_key(self, obj):\n if obj is not None:\n return '{}-{}'.format(id(self), obj.pk)\n return \"{}-None\".format(id(self))", "docstring": "Derive cache key for given object." }, { "code": "def resource_update(sender, instance, created=False, **kwargs):\n resource = instance\n try:\n new_configuration = CostTrackingRegister.get_configuration(resource)\n except ResourceNotRegisteredError:\n return\n models.PriceEstimate.update_resource_estimate(\n resource, new_configuration, raise_exception=not _is_in_celery_task())\n if created:\n _create_historical_estimates(resource, new_configuration)", "docstring": "Update resource consumption details and price estimate if its configuration has changed.\n Create estimates for previous months if resource was created not in current month." }, { "code": "def get_tags_from_job(user, job_id):\n job = v1_utils.verify_existence_and_get(job_id, _TABLE)\n if not user.is_in_team(job['team_id']) and not user.is_read_only_user():\n raise dci_exc.Unauthorized()\n JTT = models.JOIN_JOBS_TAGS\n query = (sql.select([models.TAGS])\n .select_from(JTT.join(models.TAGS))\n .where(JTT.c.job_id == job_id))\n rows = flask.g.db_conn.execute(query)\n return flask.jsonify({'tags': rows, '_meta': {'count': rows.rowcount}})", "docstring": "Retrieve all tags attached to a job." }, { "code": "def _pfp__handle_implicit_array(self, name, child):\n existing_child = self._pfp__children_map[name]\n if isinstance(existing_child, Array):\n existing_child.append(child)\n return existing_child\n else:\n cls = child._pfp__class if hasattr(child, \"_pfp__class\") else child.__class__\n ary = Array(0, cls)\n ary._pfp__offset = existing_child._pfp__offset\n ary._pfp__parent = self\n ary._pfp__name = name\n ary.implicit = True\n ary.append(existing_child)\n ary.append(child)\n exist_idx = -1\n for idx,child in enumerate(self._pfp__children):\n if child is existing_child:\n exist_idx = idx\n break\n self._pfp__children[exist_idx] = ary\n self._pfp__children_map[name] = ary\n return ary", "docstring": "Handle inserting implicit array elements" }, { "code": "def _extract(expr, pat, flags=0, group=0):\n return _string_op(expr, Extract, _pat=pat, _flags=flags, _group=group)", "docstring": "Find group in each string in the Series using passed regular expression.\n\n :param expr:\n :param pat: Pattern or regular expression\n :param flags: re module, e.g. re.IGNORECASE\n :param group: if None as group 0\n :return: sequence or scalar" }, { "code": "def _getModules(self):\n modules = {}\n modulesPath = os.path.join(\"application\", \"module\")\n moduleList = os.listdir(modulesPath)\n for moduleName in moduleList:\n modulePath = os.path.join(modulesPath, moduleName, \"module.py\")\n if not os.path.isfile(modulePath):\n continue\n moduleSpec = importlib.util.spec_from_file_location(\n moduleName,\n modulePath\n )\n module = importlib.util.module_from_spec(moduleSpec)\n moduleSpec.loader.exec_module(module)\n moduleInstance = module.Module(self)\n modules[moduleName] = moduleInstance\n return modules", "docstring": "Import and load application modules.\n\n :return: " }, { "code": "def create_check(self, label=None, name=None, check_type=None,\n disabled=False, metadata=None, details=None,\n monitoring_zones_poll=None, timeout=None, period=None,\n target_alias=None, target_hostname=None, target_receiver=None,\n test_only=False, include_debug=False):\n return self._check_manager.create_check(label=label, name=name,\n check_type=check_type, disabled=disabled, metadata=metadata,\n details=details, monitoring_zones_poll=monitoring_zones_poll,\n timeout=timeout, period=period, target_alias=target_alias,\n target_hostname=target_hostname,\n target_receiver=target_receiver, test_only=test_only,\n include_debug=include_debug)", "docstring": "Creates a check on this entity with the specified attributes. The\n 'details' parameter should be a dict with the keys as the option name,\n and the value as the desired setting." }, { "code": "def read(self, size=None):\n if self.closed:\n raise ValueError(\"I/O operation on closed file\")\n buf = b\"\"\n if self.buffer:\n if size is None:\n buf = self.buffer\n self.buffer = b\"\"\n else:\n buf = self.buffer[:size]\n self.buffer = self.buffer[size:]\n if size is None:\n buf += self.fileobj.read()\n else:\n buf += self.fileobj.read(size - len(buf))\n self.position += len(buf)\n return buf", "docstring": "Read at most size bytes from the file. If size is not\n present or None, read all data until EOF is reached." }, { "code": "def raise_error(self, error):\n ex = exc.RPCError('Error calling remote procedure: %s' % error.error['message'])\n if self.raises_errors:\n raise ex\n return ex", "docstring": "Raises the exception in the client.\n\n Called by the client to convert the :py:class:`RPCErrorResponse` into an Exception\n and raise or return it depending on the :py:attr:`raises_errors` attribute.\n\n :param error: The error response received from the server.\n :type error: :py:class:`RPCResponse`\n :rtype: :py:exc:`~tinyrpc.exc.RPCError` when :py:attr:`raises_errors` is False.\n :raises: :py:exc:`~tinyrpc.exc.RPCError` when :py:attr:`raises_errors` is True." }, { "code": "def get_url_distribution(self, after=None, reports='true', limit=1000, timeout=None):\n params = {'apikey': self.api_key, 'after': after, 'reports': reports, 'limit': limit}\n try:\n response = requests.get(self.base + 'url/distribution',\n params=params,\n proxies=self.proxies,\n timeout=timeout)\n except requests.RequestException as e:\n return dict(error=str(e))\n return _return_response_and_status_code(response)", "docstring": "Get a live feed with the lastest URLs submitted to VirusTotal.\n\n Allows you to retrieve a live feed of URLs submitted to VirusTotal, along with their scan reports. This\n call enables you to stay synced with VirusTotal URL submissions and replicate our dataset.\n\n :param after: (optional) Retrieve URLs received after the given timestamp, in timestamp ascending order.\n :param reports: (optional) When set to \"true\" each item retrieved will include the results for each particular\n URL scan (in exactly the same format as the URL scan retrieving API). If the parameter is not specified, each\n item returned will only contain the scanned URL and its detection ratio.\n :param limit: (optional) Retrieve limit file items at most (default: 1000).\n :param timeout: The amount of time in seconds the request should wait before timing out.\n\n :return: JSON response" }, { "code": "def opt(self, x_init, f_fp=None, f=None, fp=None):\n tnc_rcstrings = ['Local minimum', 'Converged', 'XConverged', 'Maximum number of f evaluations reached',\n 'Line search failed', 'Function is constant']\n assert f_fp != None, \"TNC requires f_fp\"\n opt_dict = {}\n if self.xtol is not None:\n opt_dict['xtol'] = self.xtol\n if self.ftol is not None:\n opt_dict['ftol'] = self.ftol\n if self.gtol is not None:\n opt_dict['pgtol'] = self.gtol\n opt_result = optimize.fmin_tnc(f_fp, x_init, messages=self.messages,\n maxfun=self.max_f_eval, **opt_dict)\n self.x_opt = opt_result[0]\n self.f_opt = f_fp(self.x_opt)[0]\n self.funct_eval = opt_result[1]\n self.status = tnc_rcstrings[opt_result[2]]", "docstring": "Run the TNC optimizer" }, { "code": "def main(jlink_serial, device):\n buf = StringIO.StringIO()\n jlink = pylink.JLink(log=buf.write, detailed_log=buf.write)\n jlink.open(serial_no=jlink_serial)\n jlink.set_tif(pylink.enums.JLinkInterfaces.SWD)\n jlink.connect(device, verbose=True)\n sys.stdout.write('ARM Id: %d\\n' % jlink.core_id())\n sys.stdout.write('CPU Id: %d\\n' % jlink.core_cpu())\n sys.stdout.write('Core Name: %s\\n' % jlink.core_name())\n sys.stdout.write('Device Family: %d\\n' % jlink.device_family())", "docstring": "Prints the core's information.\n\n Args:\n jlink_serial (str): the J-Link serial number\n device (str): the target CPU\n\n Returns:\n Always returns ``0``.\n\n Raises:\n JLinkException: on error" }, { "code": "def adapt_meta(self, meta):\n surge = meta.get('surge_confirmation')\n href = surge.get('href')\n surge_id = surge.get('surge_confirmation_id')\n return href, surge_id", "docstring": "Convert meta from error response to href and surge_id attributes." }, { "code": "def average(arr):\n if len(arr) == 0:\n sys.stderr.write(\"ERROR: no content in array to take average\\n\")\n sys.exit()\n if len(arr) == 1: return arr[0]\n return float(sum(arr))/float(len(arr))", "docstring": "average of the values, must have more than 0 entries.\n\n :param arr: list of numbers\n :type arr: number[] a number array\n :return: average\n :rtype: float" }, { "code": "def _get_timethresh_heuristics(self):\n if self.length > 1E5:\n time_thresh = 2.5\n elif self.length > 1E4:\n time_thresh = 2.0\n elif self.length > 1E3:\n time_thresh = 1.0\n else:\n time_thresh = 0.5\n return time_thresh", "docstring": "resonably decent hueristics for how much time to wait before\n updating progress." }, { "code": "def update_spec(self):\n if self.datafile.exists:\n with self.datafile.reader as r:\n self.header_lines = r.info['header_rows']\n self.comment_lines = r.info['comment_rows']\n self.start_line = r.info['data_start_row']\n self.end_line = r.info['data_end_row']", "docstring": "Update the source specification with information from the row intuiter, but only if the spec values\n are not already set." }, { "code": "def image_to_data(image,\n lang=None,\n config='',\n nice=0,\n output_type=Output.STRING):\n if get_tesseract_version() < '3.05':\n raise TSVNotSupported()\n config = '{} {}'.format('-c tessedit_create_tsv=1', config.strip()).strip()\n args = [image, 'tsv', lang, config, nice]\n return {\n Output.BYTES: lambda: run_and_get_output(*(args + [True])),\n Output.DATAFRAME: lambda: get_pandas_output(args + [True]),\n Output.DICT: lambda: file_to_dict(run_and_get_output(*args), '\\t', -1),\n Output.STRING: lambda: run_and_get_output(*args),\n }[output_type]()", "docstring": "Returns string containing box boundaries, confidences,\n and other information. Requires Tesseract 3.05+" }, { "code": "def free(self):\n LOGGER.debug('Connection %s freeing', self.id)\n if self.handle.isexecuting():\n raise ConnectionBusyError(self)\n with self._lock:\n self.used_by = None\n LOGGER.debug('Connection %s freed', self.id)", "docstring": "Remove the lock on the connection if the connection is not active\n\n :raises: ConnectionBusyError" }, { "code": "def addQuickElement(self, name, contents=None, attrs=None, escape=True, cdata=False):\n if attrs is None:\n attrs = {}\n self.startElement(name, attrs)\n if contents is not None:\n self.characters(contents, escape=escape, cdata=cdata)\n self.endElement(name)", "docstring": "Convenience method for adding an element with no children." }, { "code": "def BFS(G, start):\r\n if start not in G.vertices:\r\n raise GraphInsertError(\"Vertex %s doesn't exist.\" % (start,))\r\n color = {}\r\n pred = {}\r\n dist = {}\r\n queue = Queue()\r\n queue.put(start)\r\n for vertex in G.vertices:\r\n color[vertex] = 'white'\r\n pred[vertex] = None\r\n dist[vertex] = 0\r\n while queue.qsize() > 0:\r\n current = queue.get()\r\n for neighbor in G.vertices[current]:\r\n if color[neighbor] == 'white':\r\n color[neighbor] = 'grey'\r\n pred[neighbor] = current\r\n dist[neighbor] = dist[current] + 1\r\n queue.put(neighbor)\r\n color[current] = 'black'\r\n return pred", "docstring": "Algorithm for breadth-first searching the vertices of a graph." }, { "code": "def blobs(self, repository_ids=[], reference_names=[], commit_hashes=[]):\n if not isinstance(repository_ids, list):\n raise Exception(\"repository_ids must be a list\")\n if not isinstance(reference_names, list):\n raise Exception(\"reference_names must be a list\")\n if not isinstance(commit_hashes, list):\n raise Exception(\"commit_hashes must be a list\")\n return BlobsDataFrame(self.__engine.getBlobs(repository_ids,\n reference_names,\n commit_hashes),\n self.session,\n self.__implicits)", "docstring": "Retrieves the blobs of a list of repositories, reference names and commit hashes.\n So the result will be a DataFrame of all the blobs in the given commits that are\n in the given references that belong to the given repositories.\n\n >>> blobs_df = engine.blobs(repo_ids, ref_names, hashes)\n\n Calling this function with no arguments is the same as:\n\n >>> engine.repositories.references.commits.tree_entries.blobs\n\n :param repository_ids: list of repository ids to filter by (optional)\n :type repository_ids: list of strings\n :param reference_names: list of reference names to filter by (optional)\n :type reference_names: list of strings\n :param commit_hashes: list of hashes to filter by (optional)\n :type commit_hashes: list of strings\n :rtype: BlobsDataFrame" }, { "code": "def update_safe(filename: str, **kw: Any) -> Generator[IO, None, None]:\n with tempfile.NamedTemporaryFile(\n dir=os.path.dirname(filename),\n delete=False,\n prefix=f\"{os.path.basename(filename)}.\",\n **kw,\n ) as tf:\n if os.path.exists(filename):\n os.chmod(tf.name, os.stat(filename).st_mode & 0o7777)\n tf.has_changed = False\n yield tf\n if not os.path.exists(tf.name):\n return\n filename_tmp = tf.name\n if os.path.exists(filename) and filecmp.cmp(filename, filename_tmp, shallow=False):\n os.unlink(filename_tmp)\n else:\n os.rename(filename_tmp, filename)\n tf.has_changed = True", "docstring": "Rewrite a file atomically.\n\n Clients are allowed to delete the tmpfile to signal that they don't\n want to have it updated." }, { "code": "def whois_emails(self, emails):\n api_name = 'opendns-whois-emails'\n fmt_url_path = u'whois/emails/{0}'\n return self._multi_get(api_name, fmt_url_path, emails)", "docstring": "Calls WHOIS Email end point\n\n Args:\n emails: An enumerable of string Emails\n Returns:\n A dict of {email: domain_result}" }, { "code": "async def make_response(self, result: ResponseReturnValue) -> Response:\n status_or_headers = None\n headers = None\n status = None\n if isinstance(result, tuple):\n value, status_or_headers, headers = result + (None,) * (3 - len(result))\n else:\n value = result\n if value is None:\n raise TypeError('The response value returned by the view function cannot be None')\n if isinstance(status_or_headers, (dict, list)):\n headers = status_or_headers\n status = None\n elif status_or_headers is not None:\n status = status_or_headers\n if not isinstance(value, Response):\n response = self.response_class(\n value, timeout=self.config['RESPONSE_TIMEOUT'],\n )\n else:\n response = value\n if status is not None:\n response.status_code = status\n if headers is not None:\n response.headers.update(headers)\n return response", "docstring": "Make a Response from the result of the route handler.\n\n The result itself can either be:\n - A Response object (or subclass).\n - A tuple of a ResponseValue and a header dictionary.\n - A tuple of a ResponseValue, status code and a header dictionary.\n\n A ResponseValue is either a Response object (or subclass) or a str." }, { "code": "def cache(horizon):\n def cache_step(func):\n @wraps(func)\n def cached(*args):\n try:\n data = func.__globals__['__data']\n assert cached.cache_t == data['time']()\n assert hasattr(cached, 'cache_val')\n assert cached.cache_val is not None\n except (AssertionError, AttributeError):\n cached.cache_val = func(*args)\n data = func.__globals__['__data']\n cached.cache_t = data['time']()\n return cached.cache_val\n return cached\n def cache_run(func):\n @wraps(func)\n def cached(*args):\n try:\n return cached.cache_val\n except AttributeError:\n cached.cache_val = func(*args)\n return cached.cache_val\n return cached\n if horizon == 'step':\n return cache_step\n elif horizon == 'run':\n return cache_run\n else:\n raise (AttributeError('Bad horizon for cache decorator'))", "docstring": "Put a wrapper around a model function\n\n Decorators with parameters are tricky, you have to\n essentially create a decorator that returns a decorator,\n which itself then returns the function wrapper.\n\n Parameters\n ----------\n horizon: string\n - 'step' means cache just until the next timestep\n - 'run' means cache until the next initialization of the model\n\n Returns\n -------\n new_func: decorated function\n function wrapping the original function, handling caching" }, { "code": "def FromStream(cls, stream):\n if stream.system:\n specifier = DataStreamSelector.MatchSystemOnly\n else:\n specifier = DataStreamSelector.MatchUserOnly\n return DataStreamSelector(stream.stream_type, stream.stream_id, specifier)", "docstring": "Create a DataStreamSelector from a DataStream.\n\n Args:\n stream (DataStream): The data stream that we want to convert." }, { "code": "def login(self, username, password=None, email=None, registry=None, reauth=False, **kwargs):\n response = super(DockerClientWrapper, self).login(username, password, email, registry, reauth=reauth, **kwargs)\n return response.get('Status') == 'Login Succeeded' or response.get('username') == username", "docstring": "Login to a Docker registry server.\n\n :param username: User name for login.\n :type username: unicode | str\n :param password: Login password; may be ``None`` if blank.\n :type password: unicode | str\n :param email: Optional; email address for login.\n :type email: unicode | str\n :param registry: Optional registry URL to log in to. Uses the Docker index by default.\n :type registry: unicode | str\n :param reauth: Re-authenticate, even if the login has been successful before.\n :type reauth: bool\n :param kwargs: Additional kwargs to :meth:`docker.client.Client.login`.\n :return: ``True`` if the login has succeeded, or if it has not been necessary as it succeeded before. ``False``\n otherwise.\n :rtype: bool" }, { "code": "def type(self, s, enter=False, clear=False):\n if clear:\n self.clear_text()\n self._uiauto.send_keys(s)\n if enter:\n self.keyevent('KEYCODE_ENTER')", "docstring": "Input some text, this method has been tested not very stable on some device.\n \"Hi world\" maybe spell into \"H iworld\"\n\n Args:\n - s: string (text to input), better to be unicode\n - enter(bool): input enter at last\n - next(bool): perform editor action Next\n - clear(bool): clear text before type\n - ui_select_kwargs(**): tap then type\n\n The android source code show that\n space need to change to %s\n insteresting thing is that if want to input %s, it is really unconvinent.\n android source code can be found here.\n https://android.googlesource.com/platform/frameworks/base/+/android-4.4.2_r1/cmds/input/src/com/android/commands/input/Input.java#159\n app source see here: https://github.com/openatx/android-unicode" }, { "code": "def delete(self, path):\n return self.session.delete(self._request_url(path),\n auth=self.auth, verify=False)", "docstring": "Call the Infoblox device to delete the ref\n\n :param str ref: The reference id\n :rtype: requests.Response" }, { "code": "def add_child(self, node, callback):\n if node not in self.children:\n self.children.append(ChildNode(node, callback))", "docstring": "Add node and callback to the children set." }, { "code": "def get_all_tasks(conf):\n db = HamsterDB(conf)\n fact_list = db.all_facts_id\n security_days = int(conf.get_option('tasks.security_days'))\n today = datetime.today()\n tasks = {}\n for fact_id in fact_list:\n ht = HamsterTask(fact_id, conf, db)\n if ht.end_time:\n end_time = ht.get_object_dates()[1]\n if today - timedelta(security_days) <= end_time:\n rt = ht.get_remote_task()\n tasks[rt.task_id] = rt\n db.close_connection()\n print 'Obtained %d tasks' % len(tasks)\n return tasks", "docstring": "Returns a list with every task registred on Hamster." }, { "code": "def Rx_matrix(theta):\n return np.array([\n [1, 0, 0],\n [0, np.cos(theta), -np.sin(theta)],\n [0, np.sin(theta), np.cos(theta)]\n ])", "docstring": "Rotation matrix around the X axis" }, { "code": "def getusers(self, userlist):\n userobjs = [User(self, **rawuser) for rawuser in\n self._getusers(names=userlist).get('users', [])]\n ret = []\n for u in userlist:\n for uobj in userobjs[:]:\n if uobj.email == u:\n userobjs.remove(uobj)\n ret.append(uobj)\n break\n ret += userobjs\n return ret", "docstring": "Return a list of Users from .\n\n :userlist: List of usernames to lookup\n :returns: List of User records" }, { "code": "def get_url(url):\n sub = \"{0}.spotilocal.com\".format(\"\".join(choices(ascii_lowercase, k=10)))\n return \"http://{0}:{1}{2}\".format(sub, DEFAULT_PORT, url)", "docstring": "Ranomdly generates a url for use in requests.\n Generates a hostname with the port and the provided suffix url provided\n\n :param url: A url fragment to use in the creation of the master url" }, { "code": "def LoadData(self, data, custom_properties=None):\n self.__data = []\n self.AppendData(data, custom_properties)", "docstring": "Loads new rows to the data table, clearing existing rows.\n\n May also set the custom_properties for the added rows. The given custom\n properties dictionary specifies the dictionary that will be used for *all*\n given rows.\n\n Args:\n data: The rows that the table will contain.\n custom_properties: A dictionary of string to string to set as the custom\n properties for all rows." }, { "code": "def gen_jcc(src, dst):\n return ReilBuilder.build(ReilMnemonic.JCC, src, ReilEmptyOperand(), dst)", "docstring": "Return a JCC instruction." }, { "code": "def get_offset_with_default(cursor=None, default_offset=0):\n if not is_str(cursor):\n return default_offset\n offset = cursor_to_offset(cursor)\n try:\n return int(offset)\n except:\n return default_offset", "docstring": "Given an optional cursor and a default offset, returns the offset\n to use; if the cursor contains a valid offset, that will be used,\n otherwise it will be the default." }, { "code": "def balance(self):\n self.check()\n if not sum(map(lambda x: x.amount, self.src)) == -self.amount:\n raise XnBalanceError(\"Sum of source amounts \"\n \"not equal to transaction amount\")\n if not sum(map(lambda x: x.amount, self.dst)) == self.amount:\n raise XnBalanceError(\"Sum of destination amounts \"\n \"not equal to transaction amount\")\n return True", "docstring": "Check this transaction for correctness" }, { "code": "def get_keys_to_action(self):\n keyword_to_key = {\n \"UP\": ord(\"w\"),\n \"DOWN\": ord(\"s\"),\n \"LEFT\": ord(\"a\"),\n \"RIGHT\": ord(\"d\"),\n \"FIRE\": ord(\" \"),\n }\n keys_to_action = {}\n for action_id, action_meaning in enumerate(self.action_meanings):\n keys_tuple = tuple(sorted([\n key for keyword, key in keyword_to_key.items()\n if keyword in action_meaning]))\n assert keys_tuple not in keys_to_action\n keys_to_action[keys_tuple] = action_id\n keys_to_action[(ord(\"r\"),)] = self.RETURN_DONE_ACTION\n keys_to_action[(ord(\"c\"),)] = self.TOGGLE_WAIT_ACTION\n keys_to_action[(ord(\"n\"),)] = self.WAIT_MODE_NOOP_ACTION\n return keys_to_action", "docstring": "Get mapping from keyboard keys to actions.\n\n Required by gym.utils.play in environment or top level wrapper.\n\n Returns:\n {\n Unicode code point for keyboard key: action (formatted for step()),\n ...\n }" }, { "code": "def read(self, n=4096):\n size = self._next_packet_size(n)\n if size <= 0:\n return\n else:\n data = six.binary_type()\n while len(data) < size:\n nxt = self.stream.read(size - len(data))\n if not nxt:\n return data\n data = data + nxt\n return data", "docstring": "Read up to `n` bytes of data from the Stream, after demuxing.\n\n Less than `n` bytes of data may be returned depending on the available\n payload, but the number of bytes returned will never exceed `n`.\n\n Because demuxing involves scanning 8-byte headers, the actual amount of\n data read from the underlying stream may be greater than `n`." }, { "code": "def AddLabels(self, labels_names, owner=None):\n if owner is None and not self.token:\n raise ValueError(\"Can't set label: No owner specified and \"\n \"no access token available.\")\n if isinstance(labels_names, string_types):\n raise ValueError(\"Label list can't be string.\")\n owner = owner or self.token.username\n current_labels = self.Get(self.Schema.LABELS, self.Schema.LABELS())\n for label_name in labels_names:\n label = rdf_aff4.AFF4ObjectLabel(\n name=label_name, owner=owner, timestamp=rdfvalue.RDFDatetime.Now())\n current_labels.AddLabel(label)\n self.Set(current_labels)", "docstring": "Add labels to the AFF4Object." }, { "code": "def init_db(db_path):\n logger.info(\"Creating database\")\n with closing(connect_database(db_path)) as db:\n with open(SCHEMA, 'r') as f:\n db.cursor().executescript(f.read())\n db.commit()\n return", "docstring": "Build the sqlite database" }, { "code": "def send(dest, msg, transactionid=None):\n transheader = ''\n if transactionid:\n transheader = 'transaction: %s\\n' % transactionid\n return \"SEND\\ndestination: %s\\n%s\\n%s\\x00\\n\" % (dest, transheader, msg)", "docstring": "STOMP send command.\n\n dest:\n This is the channel we wish to subscribe to\n\n msg:\n This is the message body to be sent.\n\n transactionid:\n This is an optional field and is not needed\n by default." }, { "code": "def ways_callback(self, data):\n for way_id, tags, nodes in data:\n if tags:\n self.ways[way_id] = (tags, nodes)", "docstring": "Callback for all ways" }, { "code": "def bm3_p(v, v0, k0, k0p, p_ref=0.0):\n return cal_p_bm3(v, [v0, k0, k0p], p_ref=p_ref)", "docstring": "calculate pressure from 3rd order Birch-Murnathan equation\n\n :param v: volume at different pressures\n :param v0: volume at reference conditions\n :param k0: bulk modulus at reference conditions\n :param k0p: pressure derivative of bulk modulus at different conditions\n :param p_ref: reference pressure (default = 0)\n :return: pressure" }, { "code": "def walk_paths(self,\n base: Optional[pathlib.PurePath] = pathlib.PurePath()) \\\n -> Iterator[pathlib.PurePath]:\n raise NotImplementedError()", "docstring": "Recursively traverse all paths inside this entity, including the entity\n itself.\n\n :param base: The base path to prepend to the entity name.\n :return: An iterator of paths." }, { "code": "def _recursive_matches(self, nodes, count):\n assert self.content is not None\n if count >= self.min:\n yield 0, {}\n if count < self.max:\n for alt in self.content:\n for c0, r0 in generate_matches(alt, nodes):\n for c1, r1 in self._recursive_matches(nodes[c0:], count+1):\n r = {}\n r.update(r0)\n r.update(r1)\n yield c0 + c1, r", "docstring": "Helper to recursively yield the matches." }, { "code": "def recursive_copy(source, dest):\n for root, _, files in salt.utils.path.os_walk(source):\n path_from_source = root.replace(source, '').lstrip(os.sep)\n target_directory = os.path.join(dest, path_from_source)\n if not os.path.exists(target_directory):\n os.makedirs(target_directory)\n for name in files:\n file_path_from_source = os.path.join(source, path_from_source, name)\n target_path = os.path.join(target_directory, name)\n shutil.copyfile(file_path_from_source, target_path)", "docstring": "Recursively copy the source directory to the destination,\n leaving files with the source does not explicitly overwrite.\n\n (identical to cp -r on a unix machine)" }, { "code": "def describe(self):\r\n lines = []\r\n lines.append(\"Symbol = {}\".format(self.name))\r\n if len(self.tags):\r\n tgs = \", \".join(x.tag for x in self.tags)\r\n lines.append(\" tagged = {}\".format(tgs))\r\n if len(self.aliases):\r\n als = \", \".join(x.alias for x in self.aliases)\r\n lines.append(\" aliased = {}\".format(als))\r\n if len(self.feeds):\r\n lines.append(\" feeds:\")\r\n for fed in self.feeds:\r\n lines.append(\" {}. {}\".format(fed.fnum,\r\n fed.ftype))\r\n return \"\\n\".join(lines)", "docstring": "describes a Symbol, returns a string" }, { "code": "def apply_fixes(args, tmpdir):\n invocation = [args.clang_apply_replacements_binary]\n if args.format:\n invocation.append('-format')\n if args.style:\n invocation.append('-style=' + args.style)\n invocation.append(tmpdir)\n subprocess.call(invocation)", "docstring": "Calls clang-apply-fixes on a given directory." }, { "code": "def main():\n from six import StringIO\n import eppy.iddv7 as iddv7\n IDF.setiddname(StringIO(iddv7.iddtxt))\n idf1 = IDF(StringIO(''))\n loopname = \"p_loop\"\n sloop = ['sb0', ['sb1', 'sb2', 'sb3'], 'sb4']\n dloop = ['db0', ['db1', 'db2', 'db3'], 'db4']\n loopname = \"c_loop\"\n sloop = ['sb0', ['sb1', 'sb2', 'sb3'], 'sb4']\n dloop = ['db0', ['db1', 'db2', 'db3'], 'db4']\n loopname = \"a_loop\"\n sloop = ['sb0', ['sb1', 'sb2', 'sb3'], 'sb4']\n dloop = ['zone1', 'zone2', 'zone3']\n makeairloop(idf1, loopname, sloop, dloop)\n idf1.savecopy(\"hh1.idf\")", "docstring": "the main routine" }, { "code": "def unravel_staff(staff_data):\n staff_list = []\n for role, staff_members in staff_data['data'].items():\n for member in staff_members:\n member['role'] = role\n staff_list.append(member)\n return staff_list", "docstring": "Unravels staff role dictionary into flat list of staff\n members with ``role`` set as an attribute.\n\n Args:\n staff_data(dict): Data return from py:method::get_staff\n\n Returns:\n list: Flat list of staff members with ``role`` set to\n role type (i.e. course_admin, instructor, TA, etc)" }, { "code": "def etd_ms_dict2xmlfile(filename, metadata_dict):\n try:\n f = open(filename, 'w')\n f.write(generate_etd_ms_xml(metadata_dict).encode(\"utf-8\"))\n f.close()\n except:\n raise MetadataGeneratorException(\n 'Failed to create an XML file. Filename: %s' % (filename)\n )", "docstring": "Create an ETD MS XML file." }, { "code": "def _get_uniparc_sequences_through_uniprot_ACs(self, mapping_pdb_id, uniprot_ACs, cache_dir):\n m = uniprot_map('ACC', 'UPARC', uniprot_ACs, cache_dir = cache_dir)\n UniParcIDs = []\n for _, v in m.iteritems():\n UniParcIDs.extend(v)\n mapping = {mapping_pdb_id : []}\n for UniParcID in UniParcIDs:\n entry = UniParcEntry(UniParcID, cache_dir = cache_dir)\n mapping[mapping_pdb_id].append(entry)\n return mapping", "docstring": "Get the UniParc sequences associated with the UniProt accession number." }, { "code": "def BLASTcheck(rid,baseURL=\"http://blast.ncbi.nlm.nih.gov\"):\n URL=baseURL+\"/Blast.cgi?\"\n URL=URL+\"FORMAT_OBJECT=SearchInfo&RID=\"+rid+\"&CMD=Get\"\n response=requests.get(url = URL)\n r=response.content.split(\"\\n\")\n try:\n status=[ s for s in r if \"Status=\" in s ][0].split(\"=\")[-1]\n ThereAreHits=[ s for s in r if \"ThereAreHits=\" in s ][0].split(\"=\")[-1]\n except:\n status=None\n ThereAreHits=None\n print(rid, status, ThereAreHits)\n sys.stdout.flush()\n return status, ThereAreHits", "docstring": "Checks the status of a query.\n\n :param rid: BLAST search request identifier. Allowed values: The Request ID (RID) returned when the search was submitted\n :param baseURL: server url. Default=http://blast.ncbi.nlm.nih.gov\n\n :returns status: status for the query.\n :returns therearehist: yes or no for existing hits on a finished query." }, { "code": "def on_source_directory_chooser_clicked(self):\n title = self.tr('Set the source directory for script and scenario')\n self.choose_directory(self.source_directory, title)", "docstring": "Autoconnect slot activated when tbSourceDir is clicked." }, { "code": "def get_template_image(kwargs=None, call=None):\n if call == 'action':\n raise SaltCloudSystemExit(\n 'The get_template_image function must be called with -f or --function.'\n )\n if kwargs is None:\n kwargs = {}\n name = kwargs.get('name', None)\n if name is None:\n raise SaltCloudSystemExit(\n 'The get_template_image function requires a \\'name\\'.'\n )\n try:\n ret = list_templates()[name]['template']['disk']['image']\n except KeyError:\n raise SaltCloudSystemExit(\n 'The image for template \\'{0}\\' could not be found.'.format(name)\n )\n return ret", "docstring": "Returns a template's image from the given template name.\n\n .. versionadded:: 2018.3.0\n\n .. code-block:: bash\n\n salt-cloud -f get_template_image opennebula name=my-template-name" }, { "code": "def calculate_mean(self, pars_for_mean, calculation_type):\n if len(pars_for_mean) == 0:\n return({})\n elif len(pars_for_mean) == 1:\n return ({\"dec\": float(pars_for_mean[0]['dec']), \"inc\": float(pars_for_mean[0]['inc']), \"calculation_type\": calculation_type, \"n\": 1})\n elif calculation_type == 'Fisher':\n mpars = pmag.dolnp(pars_for_mean, 'direction_type')\n elif calculation_type == 'Fisher by polarity':\n mpars = pmag.fisher_by_pol(pars_for_mean)\n for key in list(mpars.keys()):\n mpars[key]['n_planes'] = 0\n mpars[key]['calculation_type'] = 'Fisher'\n mpars['calculation_type'] = calculation_type\n return mpars", "docstring": "Uses pmag.dolnp or pmag.fisher_by_pol to do a fisher mean or fisher\n mean by polarity on the list of dictionaries in pars for mean\n\n Parameters\n ----------\n pars_for_mean : list of dictionaries with all data to average\n calculation_type : type of mean to take (options: Fisher,\n Fisher by polarity)\n\n Returns\n -------\n mpars : dictionary with information of mean or empty dictionary\n\n TODO : put Bingham statistics back in once a method for displaying\n them is figured out" }, { "code": "def arrange(df, *args, **kwargs):\n flat_args = [a for a in flatten(args)]\n series = [df[arg] if isinstance(arg, str) else\n df.iloc[:, arg] if isinstance(arg, int) else\n pd.Series(arg) for arg in flat_args]\n sorter = pd.concat(series, axis=1).reset_index(drop=True)\n sorter = sorter.sort_values(sorter.columns.tolist(), **kwargs)\n return df.iloc[sorter.index, :]", "docstring": "Calls `pandas.DataFrame.sort_values` to sort a DataFrame according to\n criteria.\n\n See:\n http://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.sort_values.html\n\n For a list of specific keyword arguments for sort_values (which will be\n the same in arrange).\n\n Args:\n *args: Symbolic, string, integer or lists of those types indicating\n columns to sort the DataFrame by.\n\n Kwargs:\n **kwargs: Any keyword arguments will be passed through to the pandas\n `DataFrame.sort_values` function." }, { "code": "def max_cation_removal(self):\n oxid_pot = sum(\n [(Element(spec.symbol).max_oxidation_state - spec.oxi_state) * self.comp[spec] for spec\n in self.comp if is_redox_active_intercalation(Element(spec.symbol))])\n oxid_limit = oxid_pot / self.cation_charge\n num_cation = self.comp[Specie(self.cation.symbol, self.cation_charge)]\n return min(oxid_limit, num_cation)", "docstring": "Maximum number of cation A that can be removed while maintaining charge-balance.\n\n Returns:\n integer amount of cation. Depends on cell size (this is an 'extrinsic' function!)" }, { "code": "def spine_to_terminal_wedge(mol):\n for i, a in mol.atoms_iter():\n if mol.neighbor_count(i) == 1:\n ni, nb = list(mol.neighbors(i).items())[0]\n if nb.order == 1 and nb.type in (1, 2) \\\n and ni > i != nb.is_lower_first:\n nb.is_lower_first = not nb.is_lower_first\n nb.type = {1: 2, 2: 1}[nb.type]", "docstring": "Arrange stereo wedge direction from spine to terminal atom" }, { "code": "def copy(self, *, frame=None, form=None):\n new_compl = {}\n for k, v in self.complements.items():\n new_compl[k] = v.copy() if hasattr(v, 'copy') else v\n new_obj = self.__class__(\n self.date, self.base.copy(), self.form,\n self.frame, self.propagator.copy() if self.propagator is not None else None,\n **new_compl\n )\n if frame and frame != self.frame:\n new_obj.frame = frame\n if form and form != self.form:\n new_obj.form = form\n return new_obj", "docstring": "Provide a new instance of the same point in space-time\n\n Keyword Args:\n frame (str or Frame): Frame to convert the new instance into\n form (str or Form): Form to convert the new instance into\n Return:\n Orbit:\n\n Override :py:meth:`numpy.ndarray.copy()` to include additional\n fields" }, { "code": "def _mappingGetValueSet(mapping, keys):\n setUnion = set()\n for k in keys:\n setUnion = setUnion.union(mapping[k])\n return setUnion", "docstring": "Return a combined set of values from the mapping.\n\n :param mapping: dict, for each key contains a set of entries\n\n returns a set of combined entries" }, { "code": "def validate_token_age(callback_token):\n try:\n token = CallbackToken.objects.get(key=callback_token, is_active=True)\n seconds = (timezone.now() - token.created_at).total_seconds()\n token_expiry_time = api_settings.PASSWORDLESS_TOKEN_EXPIRE_TIME\n if seconds <= token_expiry_time:\n return True\n else:\n token.is_active = False\n token.save()\n return False\n except CallbackToken.DoesNotExist:\n return False", "docstring": "Returns True if a given token is within the age expiration limit." }, { "code": "def connections(self):\n self._check_session()\n status, data = self._rest.get_request('connections')\n return data", "docstring": "Get list of connections." }, { "code": "def PLAY(self):\n message = \"PLAY \" + self.session.url + \" RTSP/1.0\\r\\n\"\n message += self.sequence\n message += self.authentication\n message += self.user_agent\n message += self.session_id\n message += '\\r\\n'\n return message", "docstring": "RTSP session is ready to send data." }, { "code": "def add_option(self, parser):\n group = parser.add_argument_group(self.name)\n for stat in self.stats:\n stat.add_option(group)\n group.add_argument(\n \"--{0}\".format(self.option), action=\"store_true\", help=\"All above\")", "docstring": "Add option group and all children options." }, { "code": "def get_scenarios(network_id,**kwargs):\n user_id = kwargs.get('user_id')\n try:\n net_i = db.DBSession.query(Network).filter(Network.id == network_id).one()\n net_i.check_read_permission(user_id=user_id)\n except NoResultFound:\n raise ResourceNotFoundError(\"Network %s not found\"%(network_id))\n return net_i.scenarios", "docstring": "Get all the scenarios in a given network." }, { "code": "def delete_router_by_name(self, rtr_name, tenant_id):\n try:\n routers = self.neutronclient.list_routers()\n rtr_list = routers.get('routers')\n for rtr in rtr_list:\n if rtr_name == rtr['name']:\n self.neutronclient.delete_router(rtr['id'])\n except Exception as exc:\n LOG.error(\"Failed to get and delete router by name %(name)s, \"\n \"Exc %(exc)s\",\n {'name': rtr_name, 'exc': str(exc)})\n return False\n return True", "docstring": "Delete the openstack router and its interfaces given its name.\n\n The interfaces should be already removed prior to calling this\n function." }, { "code": "def add_list_member(self, list_id, user_id):\n return List(tweepy_list_to_json(self._client.add_list_member(list_id=list_id, user_id=user_id)))", "docstring": "Add a user to list\n\n :param list_id: list ID number\n :param user_id: user ID number\n :return: :class:`~responsebot.models.List` object" }, { "code": "def show_pypi_releases(self):\n try:\n hours = int(self.options.show_pypi_releases)\n except ValueError:\n self.logger.error(\"ERROR: You must supply an integer.\")\n return 1\n try:\n latest_releases = self.pypi.updated_releases(hours)\n except XMLRPCFault as err_msg:\n self.logger.error(err_msg)\n self.logger.error(\"ERROR: Couldn't retrieve latest releases.\")\n return 1\n for release in latest_releases:\n print(\"%s %s\" % (release[0], release[1]))\n return 0", "docstring": "Show PyPI releases for the last number of `hours`\n\n @returns: 0 = success or 1 if failed to retrieve from XML-RPC server" }, { "code": "def throw_invalid_quad_params(quad, QUADS, nparams):\n raise InvalidICError(str(quad),\n \"Invalid quad code params for '%s' (expected %i, but got %i)\" %\n (quad, QUADS[quad][0], nparams)\n )", "docstring": "Exception raised when an invalid number of params in the\n quad code has been emmitted." }, { "code": "def _generate_union_class_variant_creators(self, ns, data_type):\n for field in data_type.fields:\n if not is_void_type(field.data_type):\n field_name = fmt_func(field.name)\n field_name_reserved_check = fmt_func(field.name, check_reserved=True)\n if is_nullable_type(field.data_type):\n field_dt = field.data_type.data_type\n else:\n field_dt = field.data_type\n self.emit('@classmethod')\n self.emit('def {}(cls, val):'.format(field_name_reserved_check))\n with self.indent():\n self.emit('\n')\n self.emit(\"return cls('{}', val)\".format(field_name))\n self.emit()", "docstring": "Each non-symbol, non-any variant has a corresponding class method that\n can be used to construct a union with that variant selected." }, { "code": "def urlsplit(url):\n proto, rest = url.split(':', 1)\n host = ''\n if rest[:2] == '//':\n host, rest = rest[2:].split('/', 1)\n rest = '/' + rest\n return proto, host, rest", "docstring": "Split an arbitrary url into protocol, host, rest\n\n The standard urlsplit does not want to provide 'netloc' for arbitrary\n protocols, this works around that.\n\n :param url: The url to split into component parts" }, { "code": "def config_field_type(field, cls):\n return defs.ConfigField(lambda _: isinstance(_, cls),\n lambda: CONFIG_FIELD_TYPE_ERROR.format(field, cls.__name__))", "docstring": "Validate a config field against a type.\n\n Similar functionality to :func:`validate_field_matches_type` but returns :obj:`honeycomb.defs.ConfigField`" }, { "code": "def handleFlaskPostRequest(flaskRequest, endpoint):\n if flaskRequest.method == \"POST\":\n return handleHttpPost(flaskRequest, endpoint)\n elif flaskRequest.method == \"OPTIONS\":\n return handleHttpOptions()\n else:\n raise exceptions.MethodNotAllowedException()", "docstring": "Handles the specified flask request for one of the POST URLS\n Invokes the specified endpoint to generate a response." }, { "code": "def title_prefix(soup):\n \"titlePrefix for article JSON is only articles with certain display_channel values\"\n prefix = None\n display_channel_match_list = ['feature article', 'insight', 'editorial']\n for d_channel in display_channel(soup):\n if d_channel.lower() in display_channel_match_list:\n if raw_parser.sub_display_channel(soup):\n prefix = node_text(first(raw_parser.sub_display_channel(soup)))\n return prefix", "docstring": "titlePrefix for article JSON is only articles with certain display_channel values" }, { "code": "def _delete_horizontal_space(text, pos):\n while pos > 0 and text[pos - 1].isspace():\n pos -= 1\n end_pos = pos\n while end_pos < len(text) and text[end_pos].isspace():\n end_pos += 1\n return text[:pos] + text[end_pos:], pos", "docstring": "Delete all spaces and tabs around pos." }, { "code": "def error_response(self, code, content=''):\n self.send_response(code)\n self.send_header('Content-Type', 'text/xml')\n self.add_compliance_header()\n self.end_headers()\n self.wfile.write(content)", "docstring": "Construct and send error response." }, { "code": "def load_pickle(filename):\n try:\n if pd:\n return pd.read_pickle(filename), None\n else:\n with open(filename, 'rb') as fid:\n data = pickle.load(fid)\n return data, None\n except Exception as err:\n return None, str(err)", "docstring": "Load a pickle file as a dictionary" }, { "code": "def _create_table_and_update_context(node, context):\n schema_type_name = sql_context_helpers.get_schema_type_name(node, context)\n table = context.compiler_metadata.get_table(schema_type_name).alias()\n context.query_path_to_selectable[node.query_path] = table\n return table", "docstring": "Create an aliased table for a SqlNode.\n\n Updates the relevant Selectable global context.\n\n Args:\n node: SqlNode, the current node.\n context: CompilationContext, global compilation state and metadata.\n\n Returns:\n Table, the newly aliased SQLAlchemy table." }, { "code": "def _restore_training_state(self, restore_state):\n self.load_state_dict(restore_state[\"model\"])\n self.optimizer.load_state_dict(restore_state[\"optimizer\"])\n self.lr_scheduler.load_state_dict(restore_state[\"lr_scheduler\"])\n start_iteration = restore_state[\"iteration\"] + 1\n if self.config[\"verbose\"]:\n print(f\"Restored checkpoint to iteration {start_iteration}.\")\n if restore_state[\"best_model_found\"]:\n self.checkpointer.best_model_found = True\n self.checkpointer.best_iteration = restore_state[\"best_iteration\"]\n self.checkpointer.best_score = restore_state[\"best_score\"]\n if self.config[\"verbose\"]:\n print(\n f\"Updated checkpointer: \"\n f\"best_score={self.checkpointer.best_score:.3f}, \"\n f\"best_iteration={self.checkpointer.best_iteration}\"\n )\n return start_iteration", "docstring": "Restores the model and optimizer states\n\n This helper function restores the model's state to a given iteration so\n that a user can resume training at any epoch.\n\n Args:\n restore_state: a state_dict dictionary" }, { "code": "def get_and_check_project(valid_vcs_rules, source_url):\n project_path = match_url_regex(valid_vcs_rules, source_url, match_url_path_callback)\n if project_path is None:\n raise ValueError(\"Unknown repo for source url {}!\".format(source_url))\n project = project_path.split('/')[-1]\n return project", "docstring": "Given vcs rules and a source_url, return the project.\n\n The project is in the path, but is the repo name.\n `releases/mozilla-beta` is the path; `mozilla-beta` is the project.\n\n Args:\n valid_vcs_rules (tuple of frozendicts): the valid vcs rules, per\n ``match_url_regex``.\n source_url (str): the source url to find the project for.\n\n Raises:\n RuntimeError: on failure to find the project.\n\n Returns:\n str: the project." }, { "code": "def data_storage_shape(self):\n if self.data_shape == -1:\n return -1\n else:\n return tuple(self.data_shape[ax]\n for ax in np.argsort(self.data_axis_order))", "docstring": "Shape tuple of the data as stored in the file.\n\n If no header is available (i.e., before it has been initialized),\n or any of the header entries ``'nx', 'ny', 'nz'`` is missing,\n -1 is returned, which makes reshaping a no-op.\n Otherwise, the returned shape is a permutation of `data_shape`,\n i.e., ``(nx, ny, nz)``, according to `data_axis_order` in the\n following way::\n\n data_shape[i] == data_storage_shape[data_axis_order[i]]\n\n See Also\n --------\n data_shape\n data_axis_order" }, { "code": "def __get_response(self, uri, params=None, method=\"get\", stream=False):\n if not hasattr(self, \"session\") or not self.session:\n self.session = requests.Session()\n if self.access_token:\n self.session.headers.update(\n {'Authorization': 'Bearer {}'.format(self.access_token)}\n )\n if params:\n params = {k: v for k, v in params.items() if v is not None}\n kwargs = {\n \"url\": uri,\n \"verify\": True,\n \"stream\": stream\n }\n kwargs[\"params\" if method == \"get\" else \"data\"] = params\n return getattr(self.session, method)(**kwargs)", "docstring": "Creates a response object with the given params and option\n\n Parameters\n ----------\n url : string\n The full URL to request.\n params: dict\n A list of parameters to send with the request. This\n will be sent as data for methods that accept a request\n body and will otherwise be sent as query parameters.\n method : str\n The HTTP method to use.\n stream : bool\n Whether to stream the response.\n\n Returns a requests.Response object." }, { "code": "def visit_continue(self, node, parent):\n return nodes.Continue(\n getattr(node, \"lineno\", None), getattr(node, \"col_offset\", None), parent\n )", "docstring": "visit a Continue node by returning a fresh instance of it" }, { "code": "def _cwl_workflow_template(inputs, top_level=False):\n ready_inputs = []\n for inp in inputs:\n cur_inp = copy.deepcopy(inp)\n for attr in [\"source\", \"valueFrom\", \"wf_duplicate\"]:\n cur_inp.pop(attr, None)\n if top_level:\n cur_inp = workflow._flatten_nested_input(cur_inp)\n cur_inp = _clean_record(cur_inp)\n ready_inputs.append(cur_inp)\n return {\"class\": \"Workflow\",\n \"cwlVersion\": \"v1.0\",\n \"hints\": [],\n \"requirements\": [{\"class\": \"EnvVarRequirement\",\n \"envDef\": [{\"envName\": \"MPLCONFIGDIR\", \"envValue\": \".\"}]},\n {\"class\": \"ScatterFeatureRequirement\"},\n {\"class\": \"SubworkflowFeatureRequirement\"}],\n \"inputs\": ready_inputs,\n \"outputs\": [],\n \"steps\": []}", "docstring": "Retrieve CWL inputs shared amongst different workflows." }, { "code": "def delete(cls, name):\n result = cls.call('hosting.rproxy.delete', cls.usable_id(name))\n cls.echo('Deleting your webaccelerator named %s' % name)\n cls.display_progress(result)\n cls.echo('Webaccelerator have been deleted')\n return result", "docstring": "Delete a webaccelerator" }, { "code": "def contains(cat, key, container):\n hash(key)\n try:\n loc = cat.categories.get_loc(key)\n except KeyError:\n return False\n if is_scalar(loc):\n return loc in container\n else:\n return any(loc_ in container for loc_ in loc)", "docstring": "Helper for membership check for ``key`` in ``cat``.\n\n This is a helper method for :method:`__contains__`\n and :class:`CategoricalIndex.__contains__`.\n\n Returns True if ``key`` is in ``cat.categories`` and the\n location of ``key`` in ``categories`` is in ``container``.\n\n Parameters\n ----------\n cat : :class:`Categorical`or :class:`categoricalIndex`\n key : a hashable object\n The key to check membership for.\n container : Container (e.g. list-like or mapping)\n The container to check for membership in.\n\n Returns\n -------\n is_in : bool\n True if ``key`` is in ``self.categories`` and location of\n ``key`` in ``categories`` is in ``container``, else False.\n\n Notes\n -----\n This method does not check for NaN values. Do that separately\n before calling this method." }, { "code": "def get_client_info(self):\n iq = aioxmpp.IQ(\n to=self.client.local_jid.bare().replace(localpart=None),\n type_=aioxmpp.IQType.GET,\n payload=xso.Query()\n )\n reply = (yield from self.client.send(iq))\n return reply", "docstring": "A query is sent to the server to obtain the client's data stored at the\n server.\n\n :return: :class:`~aioxmpp.ibr.Query`" }, { "code": "def assert_pks_uniqueness(self, pks, exclude, value):\n pks = list(set(pks))\n if len(pks) > 1:\n raise UniquenessError(\n \"Multiple values indexed for unique field %s.%s: %s\" % (\n self.model.__name__, self.field.name, pks\n )\n )\n elif len(pks) == 1 and (not exclude or pks[0] != exclude):\n self.connection.delete(self.field.key)\n raise UniquenessError(\n 'Value \"%s\" already indexed for unique field %s.%s (for instance %s)' % (\n self.normalize_value(value), self.model.__name__, self.field.name, pks[0]\n )\n )", "docstring": "Check uniqueness of pks\n\n Parameters\n -----------\n pks: iterable\n The pks to check for uniqueness. If more than one different,\n it will raise. If only one and different than `exclude`, it will\n raise too.\n exclude: str\n The pk that we accept to be the only one in `pks`. For example\n the pk of the instance we want to check for uniqueness: we don't\n want to raise if the value is the one already set for this instance\n value: any\n Only to be displayed in the error message.\n\n Raises\n ------\n UniquenessError\n - If at least two different pks\n - If only one pk that is not the `exclude` one" }, { "code": "def timestamps(self, use_current=True):\n if use_current:\n self.timestamp(\"created_at\").use_current()\n self.timestamp(\"updated_at\").use_current()\n else:\n self.timestamp(\"created_at\")\n self.timestamp(\"updated_at\")", "docstring": "Create creation and update timestamps to the table.\n\n :rtype: Fluent" }, { "code": "def prepare_amazon_algorithm_estimator(estimator, inputs, mini_batch_size=None):\n if isinstance(inputs, list):\n for record in inputs:\n if isinstance(record, amazon_estimator.RecordSet) and record.channel == 'train':\n estimator.feature_dim = record.feature_dim\n break\n elif isinstance(inputs, amazon_estimator.RecordSet):\n estimator.feature_dim = inputs.feature_dim\n else:\n raise TypeError('Training data must be represented in RecordSet or list of RecordSets')\n estimator.mini_batch_size = mini_batch_size", "docstring": "Set up amazon algorithm estimator, adding the required `feature_dim` hyperparameter from training data.\n\n Args:\n estimator (sagemaker.amazon.amazon_estimator.AmazonAlgorithmEstimatorBase):\n An estimator for a built-in Amazon algorithm to get information from and update.\n inputs: The training data.\n * (sagemaker.amazon.amazon_estimator.RecordSet) - A collection of\n Amazon :class:~`Record` objects serialized and stored in S3.\n For use with an estimator for an Amazon algorithm.\n * (list[sagemaker.amazon.amazon_estimator.RecordSet]) - A list of\n :class:~`sagemaker.amazon.amazon_estimator.RecordSet` objects, where each instance is\n a different channel of training data." }, { "code": "def send_request(self, *args, **kwargs):\n try:\n return super(JSHost, self).send_request(*args, **kwargs)\n except RequestsConnectionError as e:\n if (\n self.manager and\n self.has_connected and\n self.logfile and\n 'unsafe' not in kwargs\n ):\n raise ProcessError(\n '{} appears to have crashed, you can inspect the log file at {}'.format(\n self.get_name(),\n self.logfile,\n )\n )\n raise six.reraise(RequestsConnectionError, RequestsConnectionError(*e.args), sys.exc_info()[2])", "docstring": "Intercept connection errors which suggest that a managed host has\n crashed and raise an exception indicating the location of the log" }, { "code": "def _storage_list_keys(bucket, pattern):\n data = [{'Name': item.metadata.name,\n 'Type': item.metadata.content_type,\n 'Size': item.metadata.size,\n 'Updated': item.metadata.updated_on}\n for item in _storage_get_keys(bucket, pattern)]\n return datalab.utils.commands.render_dictionary(data, ['Name', 'Type', 'Size', 'Updated'])", "docstring": "List all storage keys in a specified bucket that match a pattern." }, { "code": "def render(self, *args, **kwargs):\n env = {}; stdout = []\n for dictarg in args: env.update(dictarg)\n env.update(kwargs)\n self.execute(stdout, env)\n return ''.join(stdout)", "docstring": "Render the template using keyword arguments as local variables." }, { "code": "def rouge_2(hypotheses, references):\n rouge_2 = [\n rouge_n([hyp], [ref], 2) for hyp, ref in zip(hypotheses, references)\n ]\n rouge_2_f, _, _ = map(np.mean, zip(*rouge_2))\n return rouge_2_f", "docstring": "Calculate ROUGE-2 F1, precision, recall scores" }, { "code": "def register_module(self, module, url_prefix):\n module._plugin = self\n module._url_prefix = url_prefix\n for func in module._register_funcs:\n func(self, url_prefix)", "docstring": "Registers a module with a plugin. Requires a url_prefix that\n will then enable calls to url_for.\n\n :param module: Should be an instance `xbmcswift2.Module`.\n :param url_prefix: A url prefix to use for all module urls,\n e.g. '/mymodule'" }, { "code": "def tabModificationStateChanged(self, tab):\n\t\tif tab == self.currentTab:\n\t\t\tchanged = tab.editBox.document().isModified()\n\t\t\tif self.autoSaveActive(tab):\n\t\t\t\tchanged = False\n\t\t\tself.actionSave.setEnabled(changed)\n\t\t\tself.setWindowModified(changed)", "docstring": "Perform all UI state changes that need to be done when the\n\t\tmodification state of the current tab has changed." }, { "code": "def increment_title(title):\n count = re.search('\\d+$', title).group(0)\n new_title = title[:-(len(count))] + str(int(count)+1)\n return new_title", "docstring": "Increments a string that ends in a number" }, { "code": "def _remove_unused_nodes(self):\n nodes, wf_remove_node = self.nodes, self.workflow.remove_node\n add_visited, succ = self._visited.add, self.workflow.succ\n for n in (set(self._wf_pred) - set(self._visited)):\n node_type = nodes[n]['type']\n if node_type == 'data':\n continue\n if node_type == 'dispatcher' and succ[n]:\n add_visited(n)\n i = self.index + nodes[n]['index']\n self.sub_sol[i]._remove_unused_nodes()\n continue\n wf_remove_node(n)", "docstring": "Removes unused function and sub-dispatcher nodes." }, { "code": "def _create_clock(self):\n trading_o_and_c = self.trading_calendar.schedule.ix[\n self.sim_params.sessions]\n market_closes = trading_o_and_c['market_close']\n minutely_emission = False\n if self.sim_params.data_frequency == 'minute':\n market_opens = trading_o_and_c['market_open']\n minutely_emission = self.sim_params.emission_rate == \"minute\"\n execution_opens = \\\n self.trading_calendar.execution_time_from_open(market_opens)\n execution_closes = \\\n self.trading_calendar.execution_time_from_close(market_closes)\n else:\n execution_closes = \\\n self.trading_calendar.execution_time_from_close(market_closes)\n execution_opens = execution_closes\n before_trading_start_minutes = days_at_time(\n self.sim_params.sessions,\n time(8, 45),\n \"US/Eastern\"\n )\n return MinuteSimulationClock(\n self.sim_params.sessions,\n execution_opens,\n execution_closes,\n before_trading_start_minutes,\n minute_emission=minutely_emission,\n )", "docstring": "If the clock property is not set, then create one based on frequency." }, { "code": "def _get_struct_clipactions(self):\n obj = _make_object(\"ClipActions\")\n clipeventflags_size = 2 if self._version <= 5 else 4\n clipactionend_size = 2 if self._version <= 5 else 4\n all_zero = b\"\\x00\" * clipactionend_size\n assert unpack_ui16(self._src) == 0\n obj.AllEventFlags = self._src.read(clipeventflags_size)\n obj.ClipActionRecords = records = []\n while True:\n next_bytes = self._src.read(clipactionend_size)\n if next_bytes == all_zero:\n return\n record = _make_object(\"ClipActionRecord\")\n records.append(record)\n record.EventFlags = next_bytes\n record.ActionRecordSize = unpack_ui32(self._src)\n record.TheRestTODO = self._src.read(record.ActionRecordSize)\n return obj", "docstring": "Get the several CLIPACTIONRECORDs." }, { "code": "def transform(transform_func):\n def decorator(func):\n @wraps(func)\n def f(*args, **kwargs):\n return transform_func(\n func(*args, **kwargs)\n )\n return f\n return decorator", "docstring": "Apply a transformation to a functions return value" }, { "code": "def translation_generator(\n variant_sequences,\n reference_contexts,\n min_transcript_prefix_length,\n max_transcript_mismatches,\n include_mismatches_after_variant,\n protein_sequence_length=None):\n for reference_context in reference_contexts:\n for variant_sequence in variant_sequences:\n translation = Translation.from_variant_sequence_and_reference_context(\n variant_sequence=variant_sequence,\n reference_context=reference_context,\n min_transcript_prefix_length=min_transcript_prefix_length,\n max_transcript_mismatches=max_transcript_mismatches,\n include_mismatches_after_variant=include_mismatches_after_variant,\n protein_sequence_length=protein_sequence_length)\n if translation is not None:\n yield translation", "docstring": "Given all detected VariantSequence objects for a particular variant\n and all the ReferenceContext objects for that locus, translate\n multiple protein sequences, up to the number specified by the argument\n max_protein_sequences_per_variant.\n\n Parameters\n ----------\n variant_sequences : list of VariantSequence objects\n Variant sequences overlapping a single original variant\n\n reference_contexts : list of ReferenceContext objects\n Reference sequence contexts from the same variant as the variant_sequences\n\n min_transcript_prefix_length : int\n Minimum number of nucleotides before the variant to test whether\n our variant sequence can use the reading frame from a reference\n transcript.\n\n max_transcript_mismatches : int\n Maximum number of mismatches between coding sequence before variant\n and reference transcript we're considering for determing the reading\n frame.\n\n include_mismatches_after_variant : bool\n If true, mismatches occurring after the variant locus will also count\n toward max_transcript_mismatches filtering.\n\n protein_sequence_length : int, optional\n Truncate protein to be at most this long.\n\n Yields a sequence of Translation objects." }, { "code": "def _second_column(self):\n if self._A[1, 1] == 0 and self._A[2, 1] != 0:\n self._swap_rows(1, 2)\n if self._A[2, 1] != 0:\n self._zero_second_column()", "docstring": "Right-low 2x2 matrix\n\n Assume elements in first row and column are all zero except for A[0,0]." }, { "code": "def get_worker_build_info(workflow, platform):\n workspace = workflow.plugin_workspace[OrchestrateBuildPlugin.key]\n return workspace[WORKSPACE_KEY_BUILD_INFO][platform]", "docstring": "Obtain worker build information for a given platform" }, { "code": "def entropy(data):\n if len(data) == 0:\n return None\n n = sum(data)\n _op = lambda f: f * math.log(f)\n return - sum(_op(float(i) / n) for i in data)", "docstring": "Compute the Shannon entropy, a measure of uncertainty." }, { "code": "def set_value(self, instance, value, parent=None):\n self.resolve_base(instance)\n value = self.deserialize(value, parent)\n instance.values[self.alias] = value\n self._trigger_changed(instance, value)", "docstring": "Set prop value\n\n :param instance:\n :param value:\n :param parent:\n :return:" }, { "code": "def resolve_identifiers(self, subject_context):\n session = subject_context.session\n identifiers = subject_context.resolve_identifiers(session)\n if (not identifiers):\n msg = (\"No identity (identifier_collection) found in the \"\n \"subject_context. Looking for a remembered identity.\")\n logger.debug(msg)\n identifiers = self.get_remembered_identity(subject_context)\n if identifiers:\n msg = (\"Found remembered IdentifierCollection. Adding to the \"\n \"context to be used for subject construction.\")\n logger.debug(msg)\n subject_context.identifiers = identifiers\n subject_context.remembered = True\n else:\n msg = (\"No remembered identity found. Returning original \"\n \"context.\")\n logger.debug(msg)\n return subject_context", "docstring": "ensures that a subject_context has identifiers and if it doesn't will\n attempt to locate them using heuristics" }, { "code": "def _specialize(self, reconfigure=False):\n for manifest in [self.source, self.target]:\n context_dict = {}\n if manifest:\n for s in manifest.formula_sections():\n context_dict[\"%s:root_dir\" % s] = self.directory.install_directory(s)\n context_dict['config:root_dir'] = self.directory.root_dir\n context_dict['config:node'] = system.NODE\n manifest.add_additional_context(context_dict)\n self._validate_manifest()\n for feature in self.features.run_order:\n if not reconfigure:\n self.run_action(feature, 'resolve')\n instance = self.features[feature]\n if instance.target:\n self.run_action(feature, 'prompt')", "docstring": "Add variables and specialize contexts" }, { "code": "def set_var(self, vardef):\n if not(vardef.default and self.cache['ctx'].get(vardef.name)):\n self.cache['ctx'][vardef.name] = vardef.expression.value", "docstring": "Set variable to global stylesheet context." }, { "code": "def rule_expand(component, text):\n global rline_mpstate\n if component[0] == '<' and component[-1] == '>':\n return component[1:-1].split('|')\n if component in rline_mpstate.completion_functions:\n return rline_mpstate.completion_functions[component](text)\n return [component]", "docstring": "expand one rule component" }, { "code": "def create_environment_vip(self):\n return EnvironmentVIP(\n self.networkapi_url,\n self.user,\n self.password,\n self.user_ldap)", "docstring": "Get an instance of environment_vip services facade." }, { "code": "def check_token(self, respond):\n if respond.status_code == 401:\n self.credential.obtain_token(config=self.config)\n return False\n return True", "docstring": "Check is the user's token is valid" }, { "code": "def wrap_get_channel(cls, response):\n json = response.json()\n c = cls.wrap_json(json)\n return c", "docstring": "Wrap the response from getting a channel into an instance\n and return it\n\n :param response: The response from getting a channel\n :type response: :class:`requests.Response`\n :returns: the new channel instance\n :rtype: :class:`list` of :class:`channel`\n :raises: None" }, { "code": "def _preprocess_Y(self, Y, k):\n Y = Y.clone()\n if Y.dim() == 1 or Y.shape[1] == 1:\n Y = pred_to_prob(Y.long(), k=k)\n return Y", "docstring": "Convert Y to prob labels if necessary" }, { "code": "def SegmentProd(a, ids):\n func = lambda idxs: reduce(np.multiply, a[idxs])\n return seg_map(func, a, ids),", "docstring": "Segmented prod op." }, { "code": "def get_list_database(self):\n url = \"db\"\n response = self.request(\n url=url,\n method='GET',\n expected_response_code=200\n )\n return response.json()", "docstring": "Get the list of databases." }, { "code": "def normalize_path(path, filetype=FILE):\n if not path:\n raise ValueError('\"{0}\" is not a valid path.'.format(path))\n if not os.path.exists(path):\n raise ValueError('\"{0}\" does not exist.'.format(path))\n if filetype == FILE and not os.path.isfile(path):\n raise ValueError('\"{0}\" is not a file.'.format(path))\n elif filetype == DIR and not os.path.isdir(path):\n raise ValueError('\"{0}\" is not a dir.'.format(path))\n return os.path.abspath(path)", "docstring": "Takes a path and a filetype, verifies existence and type, and\n returns absolute path." }, { "code": "def remove_item_languages(self, item, languages):\n qs = TransLanguage.objects.filter(code__in=languages)\n remove_langs = [lang for lang in qs]\n if not remove_langs:\n return\n ct_item = ContentType.objects.get_for_model(item)\n item_lan, created = TransItemLanguage.objects.get_or_create(content_type_id=ct_item.id, object_id=item.id)\n for lang in remove_langs:\n item_lan.languages.remove(lang)\n if item_lan.languages.count() == 0:\n item_lan.delete()", "docstring": "delete the selected languages from the TransItemLanguage model\n\n :param item:\n :param languages:\n :return:" }, { "code": "def queueStream(self, rdds, oneAtATime=True, default=None):\n if default and not isinstance(default, RDD):\n default = self._sc.parallelize(default)\n if not rdds and default:\n rdds = [rdds]\n if rdds and not isinstance(rdds[0], RDD):\n rdds = [self._sc.parallelize(input) for input in rdds]\n self._check_serializers(rdds)\n queue = self._jvm.PythonDStream.toRDDQueue([r._jrdd for r in rdds])\n if default:\n default = default._reserialize(rdds[0]._jrdd_deserializer)\n jdstream = self._jssc.queueStream(queue, oneAtATime, default._jrdd)\n else:\n jdstream = self._jssc.queueStream(queue, oneAtATime)\n return DStream(jdstream, self, rdds[0]._jrdd_deserializer)", "docstring": "Create an input stream from a queue of RDDs or list. In each batch,\n it will process either one or all of the RDDs returned by the queue.\n\n .. note:: Changes to the queue after the stream is created will not be recognized.\n\n @param rdds: Queue of RDDs\n @param oneAtATime: pick one rdd each time or pick all of them once.\n @param default: The default rdd if no more in rdds" }, { "code": "def update():\n assert request.method == \"POST\", \"POST request expected received {}\".format(request.method)\n if request.method == 'POST':\n selected_run = request.form['selected_run']\n variable_names = utils.get_variables(selected_run).items()\n if len(current_index) < 1:\n for _, v_n in variable_names:\n current_index[v_n] = 0\n logging.info(\"Current index: {}\".format(current_index))\n data = utils.get_variable_update_dicts(current_index, variable_names, selected_run)\n return jsonify(data)", "docstring": "Called by XMLHTTPrequest function periodically to get new graph data.\n\n Usage description:\n This function queries the database and returns all the newly added values.\n\n :return: JSON Object, passed on to the JS script." }, { "code": "def after_sample(analysis_request):\n analysis_request.setDateSampled(DateTime())\n idxs = ['getDateSampled']\n for analysis in analysis_request.getAnalyses(full_objects=True):\n analysis.reindexObject(idxs=idxs)", "docstring": "Method triggered after \"sample\" transition for the Analysis Request\n passed in is performed" }, { "code": "def _data(self, received_data):\n if self.listener.on_data(received_data) is False:\n self.stop()\n raise ListenerError(self.listener.connection_id, received_data)", "docstring": "Sends data to listener, if False is returned; socket\n is closed.\n\n :param received_data: Decoded data received from socket." }, { "code": "def create(self, ogpgs):\n data = {'ogpgs': ogpgs}\n return super(ApiObjectGroupPermissionGeneral, self).post('api/v3/object-group-perm-general/', data)", "docstring": "Method to create object group permissions general\n\n :param ogpgs: List containing vrf desired to be created on database\n :return: None" }, { "code": "def write(self, f):\n if isinstance(f, str):\n f = io.open(f, 'w', encoding='utf-8')\n if not hasattr(f, 'read'):\n raise AttributeError(\"Wrong type of file: {0}\".format(type(f)))\n NS_LOGGER.info('Write to `{0}`'.format(f.name))\n for section in self.sections.keys():\n f.write('[{0}]\\n'.format(section))\n for k, v in self[section].items():\n f.write('{0:15}= {1}\\n'.format(k, v))\n f.write('\\n')\n f.close()", "docstring": "Write namespace as INI file.\n\n :param f: File object or path to file." }, { "code": "def radio_button(g, l, fn):\n w = urwid.RadioButton(g, l, False, on_state_change=fn)\n w = urwid.AttrWrap(w, 'button normal', 'button select')\n return w", "docstring": "Inheriting radio button of urwid" }, { "code": "def enqueue_command(self, command, data):\n if command == CommandType.TrialEnd or (command == CommandType.ReportMetricData and data['type'] == 'PERIODICAL'):\n self.assessor_command_queue.put((command, data))\n else:\n self.default_command_queue.put((command, data))\n qsize = self.default_command_queue.qsize()\n if qsize >= QUEUE_LEN_WARNING_MARK:\n _logger.warning('default queue length: %d', qsize)\n qsize = self.assessor_command_queue.qsize()\n if qsize >= QUEUE_LEN_WARNING_MARK:\n _logger.warning('assessor queue length: %d', qsize)", "docstring": "Enqueue command into command queues" }, { "code": "def delete_vpc_peering_connection(conn_id=None, conn_name=None, region=None,\n key=None, keyid=None, profile=None, dry_run=False):\n if not _exactly_one((conn_id, conn_name)):\n raise SaltInvocationError('Exactly one of conn_id or '\n 'conn_name must be provided.')\n conn = _get_conn3(region=region, key=key, keyid=keyid, profile=profile)\n if conn_name:\n conn_id = _vpc_peering_conn_id_for_name(conn_name, conn)\n if not conn_id:\n raise SaltInvocationError(\"Couldn't resolve VPC peering connection \"\n \"{0} to an ID\".format(conn_name))\n try:\n log.debug('Trying to delete vpc peering connection')\n conn.delete_vpc_peering_connection(DryRun=dry_run, VpcPeeringConnectionId=conn_id)\n return {'msg': 'VPC peering connection deleted.'}\n except botocore.exceptions.ClientError as err:\n e = __utils__['boto.get_error'](err)\n log.error('Failed to delete VPC peering %s: %s', conn_name or conn_id, e)\n return {'error': e}", "docstring": "Delete a VPC peering connection.\n\n .. versionadded:: 2016.11.0\n\n conn_id\n The connection ID to check. Exclusive with conn_name.\n\n conn_name\n The connection name to check. Exclusive with conn_id.\n\n region\n Region to connect to.\n\n key\n Secret key to be used.\n\n keyid\n Access key to be used.\n\n profile\n A dict with region, key and keyid, or a pillar key (string) that\n contains a dict with region, key and keyid.\n\n dry_run\n If True, skip application and simply return projected status.\n\n CLI Example:\n\n .. code-block:: bash\n\n # Create a named VPC peering connection\n salt myminion boto_vpc.delete_vpc_peering_connection conn_name=salt-vpc\n # Specify a region\n salt myminion boto_vpc.delete_vpc_peering_connection conn_name=salt-vpc region=us-west-2\n # specify an id\n salt myminion boto_vpc.delete_vpc_peering_connection conn_id=pcx-8a8939e3" }, { "code": "def get_context(self,\n name,\n retry=google.api_core.gapic_v1.method.DEFAULT,\n timeout=google.api_core.gapic_v1.method.DEFAULT,\n metadata=None):\n if 'get_context' not in self._inner_api_calls:\n self._inner_api_calls[\n 'get_context'] = google.api_core.gapic_v1.method.wrap_method(\n self.transport.get_context,\n default_retry=self._method_configs['GetContext'].retry,\n default_timeout=self._method_configs['GetContext'].timeout,\n client_info=self._client_info,\n )\n request = context_pb2.GetContextRequest(name=name, )\n return self._inner_api_calls['get_context'](\n request, retry=retry, timeout=timeout, metadata=metadata)", "docstring": "Retrieves the specified context.\n\n Example:\n >>> import dialogflow_v2\n >>>\n >>> client = dialogflow_v2.ContextsClient()\n >>>\n >>> name = client.context_path('[PROJECT]', '[SESSION]', '[CONTEXT]')\n >>>\n >>> response = client.get_context(name)\n\n Args:\n name (str): Required. The name of the context. Format:\n ``projects//agent/sessions//contexts/``.\n retry (Optional[google.api_core.retry.Retry]): A retry object used\n to retry requests. If ``None`` is specified, requests will not\n be retried.\n timeout (Optional[float]): The amount of time, in seconds, to wait\n for the request to complete. Note that if ``retry`` is\n specified, the timeout applies to each individual attempt.\n metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata\n that is provided to the method.\n\n Returns:\n A :class:`~google.cloud.dialogflow_v2.types.Context` instance.\n\n Raises:\n google.api_core.exceptions.GoogleAPICallError: If the request\n failed for any reason.\n google.api_core.exceptions.RetryError: If the request failed due\n to a retryable error and retry attempts failed.\n ValueError: If the parameters are invalid." }, { "code": "def cells(self):\n n = 0\n for (order, cells) in self:\n n += len(cells)\n return n", "docstring": "The number of cells in the MOC.\n\n This gives the total number of cells at all orders,\n with cells from every order counted equally.\n\n >>> m = MOC(0, (1, 2))\n >>> m.cells\n 2" }, { "code": "def _pull_content_revision_parent(self):\n if self._revision_id is None:\n query_params = {\n \"prop\": \"extracts|revisions\",\n \"explaintext\": \"\",\n \"rvprop\": \"ids\",\n }\n query_params.update(self.__title_query_param())\n request = self.mediawiki.wiki_request(query_params)\n page_info = request[\"query\"][\"pages\"][self.pageid]\n self._content = page_info[\"extract\"]\n self._revision_id = page_info[\"revisions\"][0][\"revid\"]\n self._parent_id = page_info[\"revisions\"][0][\"parentid\"]\n return self._content, self._revision_id, self._parent_id", "docstring": "combine the pulling of these three properties" }, { "code": "def getBottomLeft(self):\n x1 = float(self.get_x1())\n x2 = float(self.get_x2())\n y1 = float(self.get_y1())\n y2 = float(self.get_y2())\n if x1 < x2:\n if y1 < y2:\n return (x1, y1)\n else:\n return (x1, y2)\n else:\n if y1 < y2:\n return (x2, y1)\n else:\n return (x2, y2)", "docstring": "Retrieves the the bottom left coordinate of the line as tuple.\n Coordinates must be numbers." }, { "code": "def getExtensions(self, extname='SCI', section=None):\n if section is None:\n numext = 0\n section = []\n for hdu in self._image:\n if 'extname' in hdu.header and hdu.header['extname'] == extname:\n section.append(hdu.header['extver'])\n else:\n if not isinstance(section,list):\n section = [section]\n return section", "docstring": "Return the list of EXTVER values for extensions with name specified\n in extname." }, { "code": "def simple_swap(ins: Instruction) -> Instruction:\n try:\n rule = ins.details['transform']['simple_swap']\n except KeyError:\n return ins\n replacement_ins = opcode_table[rule['op']]\n return Instruction(\n replacement_ins['mnemonic'],\n replacement_ins['op'],\n [Operand(\n replacement_ins['operands'][i][1],\n r\n ) for i, r in enumerate(rule['operands'])],\n ins.pos\n )", "docstring": "Replaces one instruction with another based on the transform rules in\n the bytecode definitions. This can help simplify your code as it reduces\n the overall number of instructions. For example, `aload_0` will become\n `aload 0`.\n\n :param ins: Instruction to potentially modify.\n :return: Potentially modified instruction." }, { "code": "def get_jvm_options(self):\n ret = []\n for opt in self.get_options().options:\n ret.extend(safe_shlex_split(opt))\n if (self.get_options().debug or\n self.get_options().is_flagged('debug_port') or\n self.get_options().is_flagged('debug_args')):\n debug_port = self.get_options().debug_port\n ret.extend(arg.format(debug_port=debug_port) for arg in self.get_options().debug_args)\n return ret", "docstring": "Return the options to run this JVM with.\n\n These are options to the JVM itself, such as -Dfoo=bar, -Xmx=1g, -XX:-UseParallelGC and so on.\n\n Thus named because get_options() already exists (and returns this object's Pants options)." }, { "code": "def find_experiment_export(app_id):\n cwd = os.getcwd()\n data_filename = \"{}-data.zip\".format(app_id)\n path_to_data = os.path.join(cwd, \"data\", data_filename)\n if os.path.exists(path_to_data):\n try:\n Data(path_to_data)\n except IOError:\n from dallinger import logger\n logger.exception(\n \"Error reading local data file {}, checking remote.\".format(\n path_to_data\n )\n )\n else:\n return path_to_data\n path_to_data = os.path.join(tempfile.mkdtemp(), data_filename)\n buckets = [user_s3_bucket(), dallinger_s3_bucket()]\n for bucket in buckets:\n try:\n bucket.download_file(data_filename, path_to_data)\n except botocore.exceptions.ClientError:\n pass\n else:\n return path_to_data", "docstring": "Attempt to find a zipped export of an experiment with the ID provided\n and return its path. Returns None if not found.\n\n Search order:\n 1. local \"data\" subdirectory\n 2. user S3 bucket\n 3. Dallinger S3 bucket" }, { "code": "def isidentifier(s, dotted=False):\n if dotted:\n return all(isidentifier(a) for a in s.split('.'))\n if PY3:\n return s.isidentifier()\n else:\n import re\n _name_re = re.compile(r\"[a-zA-Z_][a-zA-Z0-9_]*$\")\n return bool(_name_re.match(s))", "docstring": "A function equivalent to the str.isidentifier method on Py3" }, { "code": "def minWidth(self):\n frags = self.frags\n nFrags = len(frags)\n if not nFrags: return 0\n if nFrags == 1:\n f = frags[0]\n fS = f.fontSize\n fN = f.fontName\n words = hasattr(f, 'text') and split(f.text, ' ') or f.words\n func = lambda w, fS=fS, fN=fN: stringWidth(w, fN, fS)\n else:\n words = _getFragWords(frags)\n func = lambda x: x[0]\n return max(map(func, words))", "docstring": "Attempt to determine a minimum sensible width" }, { "code": "def nested_update(d, u):\n for k, v in list(u.items()):\n if isinstance(v, collections.Mapping):\n r = nested_update(d.get(k, {}), v)\n d[k] = r\n else:\n d[k] = u[k]\n return d", "docstring": "Merge two nested dicts.\n\n Nested dicts are sometimes used for representing various recursive structures. When\n updating such a structure, it may be convenient to present the updated data as a\n corresponding recursive structure. This function will then apply the update.\n\n Args:\n d: dict\n dict that will be updated in-place. May or may not contain nested dicts.\n\n u: dict\n dict with contents that will be merged into ``d``. May or may not contain\n nested dicts." }, { "code": "def scope(self, key):\n if self.name is None:\n return key\n return '{:s}/{:s}'.format(self.name, key)", "docstring": "Apply the name scope to a key\n\n Parameters\n ----------\n key : string\n\n Returns\n -------\n `name/key` if `name` is not `None`;\n otherwise, `key`." }, { "code": "def props_to_image(regionprops, shape, prop):\n r\n im = sp.zeros(shape=shape)\n for r in regionprops:\n if prop == 'convex':\n mask = r.convex_image\n else:\n mask = r.image\n temp = mask * r[prop]\n s = bbox_to_slices(r.bbox)\n im[s] += temp\n return im", "docstring": "r\"\"\"\n Creates an image with each region colored according the specified ``prop``,\n as obtained by ``regionprops_3d``.\n\n Parameters\n ----------\n regionprops : list\n This is a list of properties for each region that is computed\n by PoreSpy's ``regionprops_3D`` or Skimage's ``regionsprops``.\n\n shape : array_like\n The shape of the original image for which ``regionprops`` was obtained.\n\n prop : string\n The region property of interest. Can be a scalar item such as 'volume'\n in which case the the regions will be colored by their respective\n volumes, or can be an image-type property such as 'border' or\n 'convex_image', which will return an image composed of the sub-images.\n\n Returns\n -------\n image : ND-array\n An ND-image the same size as the original image, with each region\n represented by the values specified in ``prop``.\n\n See Also\n --------\n props_to_DataFrame\n regionprops_3d" }, { "code": "def href(self):\n url = self.session.base_url + str(self.path)\n if self.path.is_collection and not self.path.is_root:\n return url + 's'\n return url", "docstring": "Return URL of the resource\n\n :rtype: str" }, { "code": "def mean(self, only_valid=True) -> ErrorValue:\n if not only_valid:\n intensity = self.intensity\n error = self.error\n else:\n intensity = self.intensity[self.mask]\n error = self.error[self.mask]\n return ErrorValue(intensity.mean(),\n (error ** 2).mean() ** 0.5)", "docstring": "Calculate the mean of the pixels, not counting the masked ones if only_valid is True." }, { "code": "def Recv(self):\n size = struct.unpack(_STRUCT_FMT, self._ReadN(_STRUCT_LEN))[0]\n if size > MAX_SIZE:\n raise ProtocolError(\"Expected size to be at most %d, got %d\" % (MAX_SIZE,\n size))\n with self._read_lock:\n buf = self._ReadN(size)\n self._ReadMagic()\n res = common_pb2.Message()\n res.ParseFromString(buf)\n return res, len(buf)", "docstring": "Accept a message from Fleetspeak.\n\n Returns:\n A tuple (common_pb2.Message, size of the message in bytes).\n Raises:\n ProtocolError: If we receive unexpected data from Fleetspeak." }, { "code": "def is_field_visible(self, field):\n context = self.context\n fieldname = field.getName()\n if fieldname == \"Client\" and context.portal_type in (\"Client\", ):\n return False\n if fieldname == \"Batch\" and context.portal_type in (\"Batch\", ):\n return False\n return True", "docstring": "Check if the field is visible" }, { "code": "def qteIsMiniApplet(self, obj):\n try:\n ret = obj._qteAdmin.isMiniApplet\n except AttributeError:\n ret = False\n return ret", "docstring": "Test if instance ``obj`` is a mini applet.\n\n |Args|\n\n * ``obj`` (**object**): object to test.\n\n |Returns|\n\n * **bool**: whether or not ``obj`` is the mini applet.\n\n |Raises|\n\n * **None**" }, { "code": "async def try_sending(self,msg,timeout_secs, max_attempts):\n if timeout_secs is None:\n timeout_secs = self.timeout\n if max_attempts is None:\n max_attempts = self.retry_count\n attempts = 0\n while attempts < max_attempts:\n if msg.seq_num not in self.message: return\n event = aio.Event()\n self.message[msg.seq_num][1]= event\n attempts += 1\n if self.transport:\n self.transport.sendto(msg.packed_message)\n try:\n myresult = await aio.wait_for(event.wait(),timeout_secs)\n break\n except Exception as inst:\n if attempts >= max_attempts:\n if msg.seq_num in self.message:\n callb = self.message[msg.seq_num][2]\n if callb:\n callb(self, None)\n del(self.message[msg.seq_num])\n self.unregister()", "docstring": "Coroutine used to send message to the device when a response or ack is needed.\n\n This coroutine will try to send up to max_attempts time the message, waiting timeout_secs\n for an answer. If no answer is received, it will consider that the device is no longer\n accessible and will unregister it.\n\n :param msg: The message to send\n :type msg: aiolifx.Message\n :param timeout_secs: Number of seconds to wait for a response or ack\n :type timeout_secs: int\n :param max_attempts: .\n :type max_attempts: int\n :returns: a coroutine to be scheduled\n :rtype: coroutine" }, { "code": "def pull(self):\n if not os.path.exists(self.repo_dir):\n yield from self.initialize_repo()\n else:\n yield from self.update()", "docstring": "Pull selected repo from a remote git repository,\n while preserving user changes" }, { "code": "def clean_start_time(self):\n start = self.cleaned_data.get('start_time')\n if not start:\n return start\n active_entries = self.user.timepiece_entries.filter(\n start_time__gte=start, end_time__isnull=True)\n for entry in active_entries:\n output = ('The start time is on or before the current entry: '\n '%s - %s starting at %s' % (entry.project, entry.activity,\n entry.start_time.strftime('%H:%M:%S')))\n raise forms.ValidationError(output)\n return start", "docstring": "Make sure that the start time doesn't come before the active entry" }, { "code": "def render(file):\n fp = file.open()\n content = fp.read()\n fp.close()\n notebook = nbformat.reads(content.decode('utf-8'), as_version=4)\n html_exporter = HTMLExporter()\n html_exporter.template_file = 'basic'\n (body, resources) = html_exporter.from_notebook_node(notebook)\n return body, resources", "docstring": "Generate the result HTML." }, { "code": "def blend(self, other, ratio=0.5):\n keep = 1.0 - ratio\n if not self.space == other.space:\n raise Exception(\"Colors must belong to the same color space.\")\n values = tuple(((u * keep) + (v * ratio)\n for u, v in zip(self.values, other.values)))\n return self.__class__(self.space, *values)", "docstring": "Blend this color with another color in the same color space.\n\n By default, blends the colors half-and-half (ratio: 0.5).\n\n :param Color other: The color to blend.\n :param float ratio: How much to blend (0 -> 1).\n\n :rtype: Color\n :returns: A new spectra.Color" }, { "code": "def build_wheel(source_dir, wheel_dir, config_settings=None):\n if config_settings is None:\n config_settings = {}\n requires, backend = _load_pyproject(source_dir)\n hooks = Pep517HookCaller(source_dir, backend)\n with BuildEnvironment() as env:\n env.pip_install(requires)\n reqs = hooks.get_requires_for_build_wheel(config_settings)\n env.pip_install(reqs)\n return hooks.build_wheel(wheel_dir, config_settings)", "docstring": "Build a wheel from a source directory using PEP 517 hooks.\n\n :param str source_dir: Source directory containing pyproject.toml\n :param str wheel_dir: Target directory to create wheel in\n :param dict config_settings: Options to pass to build backend\n\n This is a blocking function which will run pip in a subprocess to install\n build requirements." }, { "code": "def generate_docs(self):\n if self.dst.style['out'] == 'numpydoc' and self.dst.numpydoc.first_line is not None:\n self.first_line = self.dst.numpydoc.first_line\n self._set_desc()\n self._set_params()\n self._set_return()\n self._set_raises()\n self._set_other()\n self._set_raw()\n self.generated_docs = True", "docstring": "Generates the output docstring" }, { "code": "def save_cPkl(fpath, data, verbose=None, n=None):\n verbose = _rectify_verb_write(verbose)\n if verbose:\n print('[util_io] * save_cPkl(%r, data)' % (util_path.tail(fpath, n=n),))\n with open(fpath, 'wb') as file_:\n pickle.dump(data, file_, protocol=2)", "docstring": "Saves data to a pickled file with optional verbosity" }, { "code": "def usable_id(cls, id):\n try:\n qry_id = int(id)\n except Exception:\n qry_id = None\n if not qry_id:\n msg = 'unknown identifier %s' % id\n cls.error(msg)\n return qry_id", "docstring": "Retrieve id from input which can be num or id." }, { "code": "def raw_response(self, cursor_id=None):\n if self.flags & 1:\n if cursor_id is None:\n raise ProtocolError(\"No cursor id for getMore operation\")\n msg = \"Cursor not found, cursor id: %d\" % (cursor_id,)\n errobj = {\"ok\": 0, \"errmsg\": msg, \"code\": 43}\n raise CursorNotFound(msg, 43, errobj)\n elif self.flags & 2:\n error_object = bson.BSON(self.documents).decode()\n error_object.setdefault(\"ok\", 0)\n if error_object[\"$err\"].startswith(\"not master\"):\n raise NotMasterError(error_object[\"$err\"], error_object)\n elif error_object.get(\"code\") == 50:\n raise ExecutionTimeout(error_object.get(\"$err\"),\n error_object.get(\"code\"),\n error_object)\n raise OperationFailure(\"database error: %s\" %\n error_object.get(\"$err\"),\n error_object.get(\"code\"),\n error_object)\n return [self.documents]", "docstring": "Check the response header from the database, without decoding BSON.\n\n Check the response for errors and unpack.\n\n Can raise CursorNotFound, NotMasterError, ExecutionTimeout, or\n OperationFailure.\n\n :Parameters:\n - `cursor_id` (optional): cursor_id we sent to get this response -\n used for raising an informative exception when we get cursor id not\n valid at server response." }, { "code": "def list_feeds(self):\n feeds = configparser.ConfigParser()\n feeds.read(self.data_filename)\n return feeds.sections()", "docstring": "Output a list of all feed names" }, { "code": "def link_files(files: set, workspace_src_dir: str,\n common_parent: str, conf):\n norm_dir = normpath(workspace_src_dir)\n base_dir = ''\n if common_parent:\n common_parent = normpath(common_parent)\n base_dir = commonpath(list(files) + [common_parent])\n if base_dir != common_parent:\n raise ValueError('{} is not the common parent of all target '\n 'sources and data'.format(common_parent))\n logger.debug(\n 'Rebasing files in image relative to common parent dir {}',\n base_dir)\n num_linked = 0\n for src in files:\n abs_src = join(conf.project_root, src)\n abs_dest = join(conf.project_root, workspace_src_dir,\n relpath(src, base_dir))\n link_node(abs_src, abs_dest, conf.builders_workspace_dir in src)\n num_linked += 1\n return num_linked", "docstring": "Sync the list of files and directories in `files` to destination\n directory specified by `workspace_src_dir`.\n\n \"Sync\" in the sense that every file given in `files` will be\n hard-linked under `workspace_src_dir` after this function returns, and no\n other files will exist under `workspace_src_dir`.\n\n For directories in `files`, hard-links of contained files are\n created recursively.\n\n All paths in `files`, and the `workspace_src_dir`, must be relative\n to `conf.project_root`.\n\n If `common_parent` is given, and it is a common parent directory of all\n `files`, then the `commonm_parent` part is truncated from the\n sync'ed files destination path under `workspace_src_dir`.\n\n :raises FileNotFoundError: If `files` contains files or directories\n that do not exist.\n\n :raises ValueError: If `common_parent` is given (not `None`), but is *NOT*\n a common parent of all `files`." }, { "code": "def _is_flag_group(obj):\n return (\n isinstance(obj, h5py.Group) and\n isinstance(obj.get(\"active\"), h5py.Dataset) and\n isinstance(obj.get(\"known\"), h5py.Dataset)\n )", "docstring": "Returns `True` if `obj` is an `h5py.Group` that looks like\n if contains a flag" }, { "code": "def fetch_new_id(self, ):\n parent = self.get_parent()\n if parent:\n others = parent._children\n else:\n others = [r for r in self.get_root()._reftracks if r.get_parent() is None]\n others = [r for r in others\n if r != self\n and r.get_typ() == self.get_typ()\n and r.get_element() == self.get_element()]\n highest = -1\n for r in others:\n identifier = r.get_id()\n if identifier > highest:\n highest = identifier\n return highest + 1", "docstring": "Return a new id for the given reftrack to be set on the refobject\n\n The id can identify reftracks that share the same parent, type and element.\n\n :returns: A new id\n :rtype: int\n :raises: None" }, { "code": "def _finish_transaction_with_retry(self, command_name, explict_retry):\n try:\n return self._finish_transaction(command_name, explict_retry)\n except ServerSelectionTimeoutError:\n raise\n except ConnectionFailure as exc:\n try:\n return self._finish_transaction(command_name, True)\n except ServerSelectionTimeoutError:\n raise exc\n except OperationFailure as exc:\n if exc.code not in _RETRYABLE_ERROR_CODES:\n raise\n try:\n return self._finish_transaction(command_name, True)\n except ServerSelectionTimeoutError:\n raise exc", "docstring": "Run commit or abort with one retry after any retryable error.\n\n :Parameters:\n - `command_name`: Either \"commitTransaction\" or \"abortTransaction\".\n - `explict_retry`: True when this is an explict commit retry attempt,\n ie the application called session.commit_transaction() twice." }, { "code": "def host_report_msg(hostname, module_name, result, oneline):\n failed = utils.is_failed(result)\n msg = ''\n if module_name in [ 'command', 'shell', 'raw' ] and 'ansible_job_id' not in result and result.get('parsed',True) != False:\n if not failed:\n msg = command_generic_msg(hostname, result, oneline, 'success')\n else:\n msg = command_generic_msg(hostname, result, oneline, 'FAILED')\n else:\n if not failed:\n msg = regular_generic_msg(hostname, result, oneline, 'success')\n else:\n msg = regular_generic_msg(hostname, result, oneline, 'FAILED')\n return msg", "docstring": "summarize the JSON results for a particular host" }, { "code": "def get_values (feature, properties):\n if feature[0] != '<':\n feature = '<' + feature + '>'\n result = []\n for p in properties:\n if get_grist (p) == feature:\n result.append (replace_grist (p, ''))\n return result", "docstring": "Returns all values of the given feature specified by the given property set." }, { "code": "def get_all_queues(self):\n resp = self._call('getAllQueues', proto.Empty())\n return [Queue.from_protobuf(q) for q in resp.queues]", "docstring": "Get information about all queues in the cluster.\n\n Returns\n -------\n queues : list of Queue\n\n Examples\n --------\n >>> client.get_all_queues()\n [Queue,\n Queue,\n Queue,\n Queue]" }, { "code": "def sort2groups(array, gpat=['_R1','_R2']):\n groups = [REGroup(gp) for gp in gpat]\n unmatched = []\n for item in array:\n matched = False\n for m in groups:\n if m.match(item):\n matched = True\n break\n if not matched: unmatched.append(item)\n return [sorted(m.list) for m in groups], sorted(unmatched)", "docstring": "Sort an array of strings to groups by patterns" }, { "code": "def maybe_start_recording(tokens, index):\n if _is_really_comment(tokens, index):\n return _CommentedLineRecorder(index, tokens[index].line)\n return None", "docstring": "Return a new _CommentedLineRecorder when it is time to record." }, { "code": "def create(self, edgeList=None, excludeEdges=None, networkName=None, nodeList=None, source=None, verbose=False):\n network=check_network(self,source, verbose=verbose)\n PARAMS=set_param([\"edgeList\",\"excludeEdges\",\"networkName\",\"nodeList\",\"source\"], \\\n [edgeList,excludeEdges,networkName,nodeList,network])\n response=api(url=self.__url+\"/create\", PARAMS=PARAMS, method=\"POST\", verbose=verbose)\n return response", "docstring": "Create a new network from a list of nodes and edges in an existing source network.\n The SUID of the network and view are returned.\n\n :param edgeList (string, optional): Specifies a list of edges. The keywords\n all, selected, or unselected can be used to specify edges by their\n selection state. The pattern COLUMN:VALUE sets this parameter to any\n rows that contain the specified column value; if the COLUMN prefix is\n not used, the NAME column is matched by default. A list of COLUMN:VALUE\n pairs of the format COLUMN1:VALUE1,COLUMN2:VALUE2,... can be used to\n match multiple values.\n :param excludeEdges (string, optional): Unless this is set to true, edges\n that connect nodes in the nodeList are implicitly included\n :param networkName (string, optional):\n :param nodeList (string, optional): Specifies a list of nodes. The keywords\n all, selected, or unselected can be used to specify nodes by their\n selection state. The pattern COLUMN:VALUE sets this parameter to any\n rows that contain the specified column value; if the COLUMN prefix is\n not used, the NAME column is matched by default. A list of COLUMN:VALUE\n pairs of the format COLUMN1:VALUE1,COLUMN2:VALUE2,... can be used to\n match multiple values.\n :param source (string, optional): Specifies a network by name, or by SUID\n if the prefix SUID: is used. The keyword CURRENT, or a blank value can\n also be used to specify the current network.\n :param verbose: print more\n\n :returns: { netowrk, view }" }, { "code": "def start_single(self, typ, scol):\n self.starting_single = True\n single = self.single = Single(typ=typ, group=self, indent=(scol - self.level))\n self.singles.append(single)\n return single", "docstring": "Start a new single" }, { "code": "def log_value(self, name, value, step=None):\n if isinstance(value, six.string_types):\n raise TypeError('\"value\" should be a number, got {}'\n .format(type(value)))\n value = float(value)\n self._check_step(step)\n tf_name = self._ensure_tf_name(name)\n summary = self._scalar_summary(tf_name, value, step)\n self._log_summary(tf_name, summary, value, step=step)", "docstring": "Log new value for given name on given step.\n\n Args:\n name (str): name of the variable (it will be converted to a valid\n tensorflow summary name).\n value (float): this is a real number to be logged as a scalar.\n step (int): non-negative integer used for visualization: you can\n log several different variables on one step, but should not log\n different values of the same variable on the same step (this is\n not checked)." }, { "code": "def services(namespace='default', **kwargs):\n cfg = _setup_conn(**kwargs)\n try:\n api_instance = kubernetes.client.CoreV1Api()\n api_response = api_instance.list_namespaced_service(namespace)\n return [srv['metadata']['name'] for srv in api_response.to_dict().get('items')]\n except (ApiException, HTTPError) as exc:\n if isinstance(exc, ApiException) and exc.status == 404:\n return None\n else:\n log.exception(\n 'Exception when calling '\n 'CoreV1Api->list_namespaced_service'\n )\n raise CommandExecutionError(exc)\n finally:\n _cleanup(**cfg)", "docstring": "Return a list of kubernetes services defined in the namespace\n\n CLI Examples::\n\n salt '*' kubernetes.services\n salt '*' kubernetes.services namespace=default" }, { "code": "def call(self, name, request=None, **params):\n if name not in self.resources:\n raise exceptions.HttpError(\n 'Unknown method \\'%s\\'' % name,\n status=status.HTTP_501_NOT_IMPLEMENTED)\n request = request or HttpRequest()\n resource = self.resources[name]\n view = resource.as_view(api=self)\n return view(request, **params)", "docstring": "Call resource by ``Api`` name.\n\n :param name: The resource's name (short form)\n :param request: django.http.Request instance\n :param **params: Params for a resource's call\n\n :return object: Result of resource's execution" }, { "code": "def dtype_repr(dtype):\n dtype = np.dtype(dtype)\n if dtype == np.dtype(int):\n return \"'int'\"\n elif dtype == np.dtype(float):\n return \"'float'\"\n elif dtype == np.dtype(complex):\n return \"'complex'\"\n elif dtype.shape:\n return \"('{}', {})\".format(dtype.base, dtype.shape)\n else:\n return \"'{}'\".format(dtype)", "docstring": "Stringify ``dtype`` for ``repr`` with default for int and float." }, { "code": "def path_dwim(basedir, given):\n if given.startswith(\"/\"):\n return given\n elif given.startswith(\"~/\"):\n return os.path.expanduser(given)\n else:\n return os.path.join(basedir, given)", "docstring": "make relative paths work like folks expect." }, { "code": "def get_valid_location(location):\n if location is not None and cellular_components.get(location) is None:\n loc = cellular_components_reverse.get(location)\n if loc is None:\n raise InvalidLocationError(location)\n else:\n return loc\n return location", "docstring": "Check if the given location represents a valid cellular component." }, { "code": "def check_for_local_repos(repo):\n repos_dict = Repo().default_repository()\n if repo in repos_dict:\n repo_url = repos_dict[repo]\n if repo_url.startswith(\"file:///\"):\n return True", "docstring": "Check if repository is local" }, { "code": "def speak(self, text):\n if not self.is_valid_string(text):\n raise Exception(\"%s is not ISO-8859-1 compatible.\" % (text))\n if len(text) > 1023:\n lines = self.word_wrap(text, width=1023)\n for line in lines:\n self.queue.put(\"S%s\" % (line))\n else:\n self.queue.put(\"S%s\" % (text))", "docstring": "The main function to convert text into speech." }, { "code": "def generate_accounts(seeds):\n return {\n seed: {\n 'privatekey': encode_hex(sha3(seed)),\n 'address': encode_hex(privatekey_to_address(sha3(seed))),\n }\n for seed in seeds\n }", "docstring": "Create private keys and addresses for all seeds." }, { "code": "def check_yamls(cls, dap):\n problems = list()\n for yaml in dap.assistants_and_snippets:\n path = yaml + '.yaml'\n parsed_yaml = YamlLoader.load_yaml_by_path(dap._get_file(path, prepend=True))\n if parsed_yaml:\n try:\n yaml_checker.check(path, parsed_yaml)\n except YamlError as e:\n problems.append(DapProblem(exc_as_decoded_string(e), level=logging.ERROR))\n else:\n problems.append(DapProblem('Empty YAML ' + path, level=logging.WARNING))\n return problems", "docstring": "Check that all assistants and snippets are valid.\n\n Return list of DapProblems." }, { "code": "def add_json(self, json_obj, **kwargs):\n return self.add_bytes(encoding.Json().encode(json_obj), **kwargs)", "docstring": "Adds a json-serializable Python dict as a json file to IPFS.\n\n .. code-block:: python\n\n >>> c.add_json({'one': 1, 'two': 2, 'three': 3})\n 'QmVz9g7m5u3oHiNKHj2CJX1dbG1gtismRS3g9NaPBBLbob'\n\n Parameters\n ----------\n json_obj : dict\n A json-serializable Python dictionary\n\n Returns\n -------\n str : Hash of the added IPFS object" }, { "code": "def flux_up(self, fluxUpBottom, emission=None):\n if emission is None:\n emission = np.zeros_like(self.absorptivity)\n E = np.concatenate((emission, np.atleast_1d(fluxUpBottom)), axis=-1)\n return np.squeeze(matrix_multiply(self.Tup, E[..., np.newaxis]))", "docstring": "Compute downwelling radiative flux at interfaces between layers.\n\n Inputs:\n\n * fluxDownTop: flux down at top\n * emission: emission from atmospheric levels (N)\n defaults to zero if not given\n\n Returns:\n\n * vector of downwelling radiative flux between levels (N+1)\n element 0 is the flux down to the surface." }, { "code": "def get_name(self, **values) -> str:\n if not values and self.name:\n return self.name\n if values:\n for ck, cvs in _sorted_items(self.compounds):\n if ck in cvs and ck in values:\n continue\n comp_values = [values.pop(cv, getattr(self, cv)) for cv in cvs]\n if None not in comp_values:\n values[ck] = ''.join(rf'{v}' for v in comp_values)\n return self._get_nice_name(**values)", "docstring": "Get a new name string from this object's name values.\n\n :param values: Variable keyword arguments where the **key** should refer to a field on this object that will\n use the provided **value** to build the new name." }, { "code": "def read_data_from_bin_file(fileName):\n with open(fileName, mode='rb') as file:\n fileContent = file.read()\n (ChannelData, LenOf1Channel,\n NumOfChannels, SampleTime) = read_data_from_bytes(fileContent)\n return ChannelData, LenOf1Channel, NumOfChannels, SampleTime", "docstring": "Loads the binary data stored in the a binary file and extracts the \n data for each channel that was saved, along with the sample rate and length\n of the data array.\n\n Parameters\n ----------\n fileContent : bytes \n bytes object containing the data from a .bin file exported from\n the saleae data logger.\n \n Returns\n -------\n ChannelData : list\n List containing a list which contains the data from each channel\n LenOf1Channel : int\n The length of the data in each channel\n NumOfChannels : int\n The number of channels saved\n SampleTime : float\n The time between samples (in seconds)\n SampleRate : float\n The sample rate (in Hz)" }, { "code": "def tickerId(self, contract_identifier):\n symbol = contract_identifier\n if isinstance(symbol, Contract):\n symbol = self.contractString(symbol)\n for tickerId in self.tickerIds:\n if symbol == self.tickerIds[tickerId]:\n return tickerId\n else:\n tickerId = len(self.tickerIds)\n self.tickerIds[tickerId] = symbol\n return tickerId", "docstring": "returns the tickerId for the symbol or\n sets one if it doesn't exits" }, { "code": "def disqus_sso_script(context):\n settings = context[\"settings\"]\n public_key = getattr(settings, \"COMMENTS_DISQUS_API_PUBLIC_KEY\", \"\")\n secret_key = getattr(settings, \"COMMENTS_DISQUS_API_SECRET_KEY\", \"\")\n user = context[\"request\"].user\n if public_key and secret_key and user.is_authenticated():\n context[\"public_key\"] = public_key\n context[\"sso_data\"] = _get_disqus_sso(user, public_key, secret_key)\n return context", "docstring": "Provides a generic context variable which adds single-sign-on\n support to DISQUS if ``COMMENTS_DISQUS_API_PUBLIC_KEY`` and\n ``COMMENTS_DISQUS_API_SECRET_KEY`` are specified." }, { "code": "def is_bytes(string):\n if six.PY3 and isinstance(string, (bytes, memoryview, bytearray)):\n return True\n elif six.PY2 and isinstance(string, (buffer, bytearray)):\n return True\n return False", "docstring": "Check if a string is a bytes instance\n\n :param Union[str, bytes] string: A string that may be string or bytes like\n :return: Whether the provided string is a bytes type or not\n :rtype: bool" }, { "code": "def __process_acl(self, load, auth_list):\n if 'eauth' not in load:\n return auth_list\n fstr = '{0}.process_acl'.format(load['eauth'])\n if fstr not in self.auth:\n return auth_list\n try:\n return self.auth[fstr](auth_list, self.opts)\n except Exception as e:\n log.debug('Authentication module threw %s', e)\n return auth_list", "docstring": "Allows eauth module to modify the access list right before it'll be applied to the request.\n For example ldap auth module expands entries" }, { "code": "def get_db(cls):\n if cls._db:\n return getattr(cls._client, cls._db)\n return cls._client.get_default_database()", "docstring": "Return the database for the collection" }, { "code": "def divide(x1, x2, output_shape=None, name=None):\n output_shape = convert_to_shape(output_shape)\n if not isinstance(x2, Tensor):\n return ScalarMultiplyOperation(x1, 1.0 / x2).outputs[0]\n with tf.name_scope(name, default_name=\"divide\"):\n x1, x2 = binary_arguments_to_tensors(x1, x2)\n return multiply(x1, reciprocal(x2), output_shape=output_shape)", "docstring": "Binary division with broadcasting.\n\n Args:\n x1: a Tensor\n x2: a Tensor\n output_shape: an optional Shape\n name: an optional string\n Returns:\n a Tensor" }, { "code": "def is_valid_data(obj):\n if obj:\n try:\n tmp = json.dumps(obj, default=datetime_encoder)\n del tmp\n except (TypeError, UnicodeDecodeError):\n return False\n return True", "docstring": "Check if data is JSON serializable." }, { "code": "def human_readable(self, dense_repr: Sequence[Sequence[int]]) -> List[List[str]]:\n transcripts = []\n for dense_r in dense_repr:\n non_empty_phonemes = [phn_i for phn_i in dense_r if phn_i != 0]\n transcript = self.corpus.indices_to_labels(non_empty_phonemes)\n transcripts.append(transcript)\n return transcripts", "docstring": "Returns a human readable version of a dense representation of\n either or reference to facilitate simple manual inspection." }, { "code": "def get_config(config, default_config):\n if not config:\n logging.warning('Using default config: %s', default_config)\n config = default_config\n try:\n with open(config, 'r') as config_file:\n return yaml.load(config_file)\n except (yaml.reader.ReaderError,\n yaml.parser.ParserError,\n yaml.scanner.ScannerError) as e:\n raise ConfigError('Invalid yaml file: \\n %s' % str(e))", "docstring": "Load configuration from file if in config, else use default" }, { "code": "def clean_email(self):\n if get_user_model().objects.filter(\n Q(email__iexact=self.cleaned_data['email']) |\n Q(email_unconfirmed__iexact=self.cleaned_data['email'])):\n raise forms.ValidationError(_(u'This email address is already '\n 'in use. Please supply a different email.'))\n return self.cleaned_data['email']", "docstring": "Validate that the email address is unique." }, { "code": "def totalNumberOfTiles(self, minZoom=None, maxZoom=None):\n \"Return the total number of tiles for this instance extent\"\n nbTiles = 0\n minZoom = minZoom or 0\n if maxZoom:\n maxZoom = maxZoom + 1\n else:\n maxZoom = len(self.RESOLUTIONS)\n for zoom in xrange(minZoom, maxZoom):\n nbTiles += self.numberOfTilesAtZoom(zoom)\n return nbTiles", "docstring": "Return the total number of tiles for this instance extent" }, { "code": "def _check(peers):\n if not isinstance(peers, list):\n return False\n for peer in peers:\n if not isinstance(peer, six.string_types):\n return False\n if not HAS_NETADDR:\n return True\n ip_only_peers = []\n for peer in peers:\n try:\n ip_only_peers.append(six.text_type(IPAddress(peer)))\n except AddrFormatError:\n if not HAS_DNSRESOLVER:\n continue\n dns_reply = []\n try:\n dns_reply = dns.resolver.query(peer)\n except dns.resolver.NoAnswer:\n return False\n for dns_ip in dns_reply:\n ip_only_peers.append(six.text_type(dns_ip))\n peers = ip_only_peers\n return True", "docstring": "Checks whether the input is a valid list of peers and transforms domain names into IP Addresses" }, { "code": "def x_runtime(f, *args, **kwargs):\n _t0 = now()\n r = f(*args, **kwargs)\n _t1 = now()\n r.headers['X-Runtime'] = '{0}s'.format(Decimal(str(_t1 - _t0)))\n return r", "docstring": "X-Runtime Flask Response Decorator." }, { "code": "def found(self):\n if 'ids' in self.kwargs:\n cid = self.kwargs['query']['collection']['eq']\n return len(self.items_by_id(self.kwargs['ids'], cid))\n kwargs = {\n 'page': 1,\n 'limit': 0\n }\n kwargs.update(self.kwargs)\n results = self.query(**kwargs)\n return results['meta']['found']", "docstring": "Small query to determine total number of hits" }, { "code": "def locate_private_alleles(*acs):\n acs = [asarray_ndim(ac, 2) for ac in acs]\n check_dim0_aligned(*acs)\n acs = ensure_dim1_aligned(*acs)\n pac = np.dstack(acs)\n npa = np.sum(pac > 0, axis=2)\n loc_pa = npa == 1\n return loc_pa", "docstring": "Locate alleles that are found only in a single population.\n\n Parameters\n ----------\n *acs : array_like, int, shape (n_variants, n_alleles)\n Allele counts arrays from each population.\n\n Returns\n -------\n loc : ndarray, bool, shape (n_variants, n_alleles)\n Boolean array where elements are True if allele is private to a\n single population.\n\n Examples\n --------\n\n >>> import allel\n >>> g = allel.GenotypeArray([[[0, 0], [0, 0], [1, 1], [1, 1]],\n ... [[0, 1], [0, 1], [0, 1], [0, 1]],\n ... [[0, 1], [0, 1], [1, 1], [1, 1]],\n ... [[0, 0], [0, 0], [1, 1], [2, 2]],\n ... [[0, 0], [-1, -1], [1, 1], [-1, -1]]])\n >>> ac1 = g.count_alleles(subpop=[0, 1])\n >>> ac2 = g.count_alleles(subpop=[2])\n >>> ac3 = g.count_alleles(subpop=[3])\n >>> loc_private_alleles = allel.locate_private_alleles(ac1, ac2, ac3)\n >>> loc_private_alleles\n array([[ True, False, False],\n [False, False, False],\n [ True, False, False],\n [ True, True, True],\n [ True, True, False]])\n >>> loc_private_variants = np.any(loc_private_alleles, axis=1)\n >>> loc_private_variants\n array([ True, False, True, True, True])" }, { "code": "def gradfunc(self, p):\n self._set_stochastics(p)\n for i in xrange(self.len):\n self.grad[i] = self.diff(i)\n return -1 * self.grad", "docstring": "The gradient-computing function that gets passed to the optimizers,\n if needed." }, { "code": "def function_call_with_timeout(fun_name, fun_args, secs=5):\n from multiprocessing import Process, Queue\n p = Process(target=fun_name, args=tuple(fun_args))\n p.start()\n curr_secs = 0\n no_timeout = False\n if secs == 0: no_timeout = True\n else: timeout = secs\n while p.is_alive() and not no_timeout:\n if curr_secs > timeout:\n print(\"Process time has exceeded timeout, terminating it.\")\n p.terminate()\n return False\n time.sleep(0.1)\n curr_secs += 0.1\n p.join()\n return True", "docstring": "Run a Python function with a timeout. No interprocess communication or\n return values are handled. Setting secs to 0 gives infinite timeout." }, { "code": "def __flush(self, async=True):\n rh = self.rh\n messages = list(self.messages)\n stream_notices = list(self.stream_notices)\n self.stream_notices = []\n self.messages = []\n args = (rh, messages, stream_notices)\n if async:\n self.hub.threadPool.execute_named(self.__inner_flush,\n '%s __inner__flush' % self.hub.l.name, *args)\n else:\n self.__inner_flush(*args)\n self.rh = None\n self._set_timeout(int(time.time() + self.hub.timeout))", "docstring": "Flushes messages through current HttpRequest and closes it.\n It assumes a current requesthandler and requires a lock\n on self.lock" }, { "code": "def recv_exit_status(self, command, timeout=10, get_pty=False):\n status = None\n self.last_command = command\n stdin, stdout, stderr = self.cli.exec_command(command, get_pty=get_pty)\n if stdout and stderr and stdin:\n for _ in range(timeout):\n if stdout.channel.exit_status_ready():\n status = stdout.channel.recv_exit_status()\n break\n time.sleep(1)\n self.last_stdout = stdout.read()\n self.last_stderr = stderr.read()\n stdin.close()\n stdout.close()\n stderr.close()\n return status", "docstring": "Execute a command and get its return value\n\n @param command: command to execute\n @type command: str\n\n @param timeout: command execution timeout\n @type timeout: int\n\n @param get_pty: get pty\n @type get_pty: bool\n\n @return: the exit code of the process or None in case of timeout\n @rtype: int or None" }, { "code": "def has_object_permission(self, request, view, obj):\n if not self.object_permissions:\n return True\n serializer_class = view.get_serializer_class()\n model_class = serializer_class.Meta.model\n action_method_name = None\n if hasattr(view, 'action'):\n action = self._get_action(view.action)\n action_method_name = \"has_object_{action}_permission\".format(action=action)\n if hasattr(obj, action_method_name):\n return getattr(obj, action_method_name)(request)\n if request.method in permissions.SAFE_METHODS:\n assert hasattr(obj, 'has_object_read_permission'), \\\n self._get_error_message(model_class, 'has_object_read_permission', action_method_name)\n return obj.has_object_read_permission(request)\n else:\n assert hasattr(obj, 'has_object_write_permission'), \\\n self._get_error_message(model_class, 'has_object_write_permission', action_method_name)\n return obj.has_object_write_permission(request)", "docstring": "Overrides the standard function and figures out methods to call for object permissions." }, { "code": "def parse_if(self):\n node = result = nodes.If(lineno=self.stream.expect('name:if').lineno)\n while 1:\n node.test = self.parse_tuple(with_condexpr=False)\n node.body = self.parse_statements(('name:elif', 'name:else',\n 'name:endif'))\n node.elif_ = []\n node.else_ = []\n token = next(self.stream)\n if token.test('name:elif'):\n node = nodes.If(lineno=self.stream.current.lineno)\n result.elif_.append(node)\n continue\n elif token.test('name:else'):\n result.else_ = self.parse_statements(('name:endif',),\n drop_needle=True)\n break\n return result", "docstring": "Parse an if construct." }, { "code": "def get_user_if_exists(strategy, details, user=None, *args, **kwargs):\n if user:\n return {'is_new': False}\n try:\n username = details.get('username')\n return {\n 'is_new': False,\n 'user': User.objects.get(username=username)\n }\n except User.DoesNotExist:\n pass\n return {}", "docstring": "Return a User with the given username iff the User exists." }, { "code": "def get_next_invalid_time_from_t(self, timestamp):\n if not self.is_time_valid(timestamp):\n return timestamp\n t_day = self.get_next_invalid_day(timestamp)\n if timestamp < t_day:\n sec_from_morning = self.get_next_future_timerange_invalid(t_day)\n else:\n sec_from_morning = self.get_next_future_timerange_invalid(timestamp)\n if t_day is not None and sec_from_morning is not None:\n return t_day + sec_from_morning + 1\n if t_day is not None and sec_from_morning is None:\n return t_day\n timestamp = get_day(timestamp) + 86400\n t_day2 = self.get_next_invalid_day(timestamp)\n sec_from_morning = self.get_next_future_timerange_invalid(t_day2)\n if t_day2 is not None and sec_from_morning is not None:\n return t_day2 + sec_from_morning + 1\n if t_day2 is not None and sec_from_morning is None:\n return t_day2\n return None", "docstring": "Get next invalid time for time range\n\n :param timestamp: time we compute from\n :type timestamp: int\n :return: timestamp of the next invalid time (LOCAL TIME)\n :rtype: int" }, { "code": "def stelab(pobj, vobs):\n pobj = stypes.toDoubleVector(pobj)\n vobs = stypes.toDoubleVector(vobs)\n appobj = stypes.emptyDoubleVector(3)\n libspice.stelab_c(pobj, vobs, appobj)\n return stypes.cVectorToPython(appobj)", "docstring": "Correct the apparent position of an object for stellar\n aberration.\n\n http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/stelab_c.html\n\n :param pobj: Position of an object with respect to the observer.\n :type pobj: 3-Element Array of floats\n :param vobs:\n Velocity of the observer with respect\n to the Solar System barycenter.\n :type vobs: 3-Element Array of floats\n :return:\n Apparent position of the object with respect to\n the observer, corrected for stellar aberration.\n :rtype: 3-Element Array of floats" }, { "code": "def configure(self, **configs):\n configs = self._deprecate_configs(**configs)\n self._config = {}\n for key in self.DEFAULT_CONFIG:\n self._config[key] = configs.pop(key, self.DEFAULT_CONFIG[key])\n if configs:\n raise KafkaConfigurationError('Unknown configuration key(s): ' +\n str(list(configs.keys())))\n if self._config['auto_commit_enable']:\n if not self._config['group_id']:\n raise KafkaConfigurationError(\n 'KafkaConsumer configured to auto-commit '\n 'without required consumer group (group_id)'\n )\n if self._config['auto_commit_enable']:\n logger.info(\"Configuring consumer to auto-commit offsets\")\n self._reset_auto_commit()\n if not self._config['bootstrap_servers']:\n raise KafkaConfigurationError(\n 'bootstrap_servers required to configure KafkaConsumer'\n )\n self._client = KafkaClient(\n self._config['bootstrap_servers'],\n client_id=self._config['client_id'],\n timeout=(self._config['socket_timeout_ms'] / 1000.0)\n )", "docstring": "Configure the consumer instance\n\n Configuration settings can be passed to constructor,\n otherwise defaults will be used:\n\n Keyword Arguments:\n bootstrap_servers (list): List of initial broker nodes the consumer\n should contact to bootstrap initial cluster metadata. This does\n not have to be the full node list. It just needs to have at\n least one broker that will respond to a Metadata API Request.\n client_id (str): a unique name for this client. Defaults to\n 'kafka.consumer.kafka'.\n group_id (str): the name of the consumer group to join,\n Offsets are fetched / committed to this group name.\n fetch_message_max_bytes (int, optional): Maximum bytes for each\n topic/partition fetch request. Defaults to 1024*1024.\n fetch_min_bytes (int, optional): Minimum amount of data the server\n should return for a fetch request, otherwise wait up to\n fetch_wait_max_ms for more data to accumulate. Defaults to 1.\n fetch_wait_max_ms (int, optional): Maximum time for the server to\n block waiting for fetch_min_bytes messages to accumulate.\n Defaults to 100.\n refresh_leader_backoff_ms (int, optional): Milliseconds to backoff\n when refreshing metadata on errors (subject to random jitter).\n Defaults to 200.\n socket_timeout_ms (int, optional): TCP socket timeout in\n milliseconds. Defaults to 30*1000.\n auto_offset_reset (str, optional): A policy for resetting offsets on\n OffsetOutOfRange errors. 'smallest' will move to the oldest\n available message, 'largest' will move to the most recent. Any\n ofther value will raise the exception. Defaults to 'largest'.\n deserializer_class (callable, optional): Any callable that takes a\n raw message value and returns a deserialized value. Defaults to\n lambda msg: msg.\n auto_commit_enable (bool, optional): Enabling auto-commit will cause\n the KafkaConsumer to periodically commit offsets without an\n explicit call to commit(). Defaults to False.\n auto_commit_interval_ms (int, optional): If auto_commit_enabled,\n the milliseconds between automatic offset commits. Defaults to\n 60 * 1000.\n auto_commit_interval_messages (int, optional): If\n auto_commit_enabled, a number of messages consumed between\n automatic offset commits. Defaults to None (disabled).\n consumer_timeout_ms (int, optional): number of millisecond to throw\n a timeout exception to the consumer if no message is available\n for consumption. Defaults to -1 (dont throw exception).\n\n Configuration parameters are described in more detail at\n http://kafka.apache.org/documentation.html#highlevelconsumerapi" }, { "code": "def create_shared(self, name, ref):\n if self._shared is not None:\n raise RuntimeError('Can only set_shared once.')\n self._shared = GLShared(name, ref)", "docstring": "For the app backends to create the GLShared object.\n\n Parameters\n ----------\n name : str\n The name.\n ref : object\n The reference." }, { "code": "def compute_fw_at_frac_max_1d_simple(Y, xc, X=None, f=0.5):\n yy = np.asarray(Y)\n if yy.ndim != 1:\n raise ValueError('array must be 1-d')\n if yy.size == 0:\n raise ValueError('array is empty')\n if X is None:\n xx = np.arange(yy.shape[0])\n else:\n xx = X\n xpix = coor_to_pix_1d(xc - xx[0])\n try:\n peak = yy[xpix]\n except IndexError:\n raise ValueError('peak is out of array')\n fwhm_x, _codex, _msgx = compute_fwhm_1d(xx, yy - f * peak, xc, xpix)\n return peak, fwhm_x", "docstring": "Compute the full width at fraction f of the maximum" }, { "code": "def upload(self, filename, filedata=None, filepath=None, **kwargs):\n if filepath is None and filedata is None:\n raise GitlabUploadError(\"No file contents or path specified\")\n if filedata is not None and filepath is not None:\n raise GitlabUploadError(\"File contents and file path specified\")\n if filepath is not None:\n with open(filepath, \"rb\") as f:\n filedata = f.read()\n url = ('/projects/%(id)s/uploads' % {\n 'id': self.id,\n })\n file_info = {\n 'file': (filename, filedata),\n }\n data = self.manager.gitlab.http_post(url, files=file_info)\n return {\n \"alt\": data['alt'],\n \"url\": data['url'],\n \"markdown\": data['markdown']\n }", "docstring": "Upload the specified file into the project.\n\n .. note::\n\n Either ``filedata`` or ``filepath`` *MUST* be specified.\n\n Args:\n filename (str): The name of the file being uploaded\n filedata (bytes): The raw data of the file being uploaded\n filepath (str): The path to a local file to upload (optional)\n\n Raises:\n GitlabConnectionError: If the server cannot be reached\n GitlabUploadError: If the file upload fails\n GitlabUploadError: If ``filedata`` and ``filepath`` are not\n specified\n GitlabUploadError: If both ``filedata`` and ``filepath`` are\n specified\n\n Returns:\n dict: A ``dict`` with the keys:\n * ``alt`` - The alternate text for the upload\n * ``url`` - The direct url to the uploaded file\n * ``markdown`` - Markdown for the uploaded file" }, { "code": "def updateColormap(self):\n if self.imgArgs['lut'] is not None:\n self.img.setLookupTable(self.imgArgs['lut'])\n self.img.setLevels(self.imgArgs['levels'])", "docstring": "Updates the currently colormap accoring to stored settings" }, { "code": "def _resume_ssl_session(\n server_info: ServerConnectivityInfo,\n ssl_version_to_use: OpenSslVersionEnum,\n ssl_session: Optional[nassl._nassl.SSL_SESSION] = None,\n should_enable_tls_ticket: bool = False\n ) -> nassl._nassl.SSL_SESSION:\n ssl_connection = server_info.get_preconfigured_ssl_connection(override_ssl_version=ssl_version_to_use)\n if not should_enable_tls_ticket:\n ssl_connection.ssl_client.disable_stateless_session_resumption()\n if ssl_session:\n ssl_connection.ssl_client.set_session(ssl_session)\n try:\n ssl_connection.connect()\n new_session = ssl_connection.ssl_client.get_session()\n finally:\n ssl_connection.close()\n return new_session", "docstring": "Connect to the server and returns the session object that was assigned for that connection.\n If ssl_session is given, tries to resume that session." }, { "code": "def create(self, networkipv4s):\n data = {'networks': networkipv4s}\n return super(ApiNetworkIPv4, self).post('api/v3/networkv4/', data)", "docstring": "Method to create network-ipv4's\n\n :param networkipv4s: List containing networkipv4's desired to be created on database\n :return: None" }, { "code": "def remover(self, id_groupl3):\n if not is_valid_int_param(id_groupl3):\n raise InvalidParameterError(\n u'The identifier of Group L3 is invalid or was not informed.')\n url = 'groupl3/' + str(id_groupl3) + '/'\n code, xml = self.submit(None, 'DELETE', url)\n return self.response(code, xml)", "docstring": "Remove Group L3 from by the identifier.\n\n :param id_groupl3: Identifier of the Group L3. Integer value and greater than zero.\n\n :return: None\n\n :raise InvalidParameterError: The identifier of Group L3 is null and invalid.\n :raise GrupoL3NaoExisteError: Group L3 not registered.\n :raise DataBaseError: Networkapi failed to access the database.\n :raise XMLError: Networkapi failed to generate the XML response." }, { "code": "def to_dict(self, properties=True):\n nodes = {}\n for node in self.nodes():\n nd = {\n 'label': node.pred.short_form(),\n 'edges': self.edges(node.nodeid)\n }\n if node.lnk is not None:\n nd['lnk'] = {'from': node.cfrom, 'to': node.cto}\n if properties:\n if node.cvarsort is not None:\n nd['type'] = node.cvarsort\n props = node.properties\n if props:\n nd['properties'] = props\n if node.carg is not None:\n nd['carg'] = node.carg\n nodes[node.nodeid] = nd\n return {'top': self.top, 'nodes': nodes}", "docstring": "Encode the Eds as a dictionary suitable for JSON serialization." }, { "code": "def axis(self) -> Callable[[Any], Any]:\n axis_func = hist_axis_func(\n axis_type = self.axis_type\n )\n return axis_func", "docstring": "Determine the axis to return based on the hist type." }, { "code": "def _forceInt(x,y,z,dens,b2,c2,i,glx=None,glw=None):\n def integrand(s):\n t= 1/s**2.-1.\n return dens(numpy.sqrt(x**2./(1.+t)+y**2./(b2+t)+z**2./(c2+t)))\\\n *(x/(1.+t)*(i==0)+y/(b2+t)*(i==1)+z/(c2+t)*(i==2))\\\n /numpy.sqrt((1.+(b2-1.)*s**2.)*(1.+(c2-1.)*s**2.))\n if glx is None:\n return integrate.quad(integrand,0.,1.)[0] \n else:\n return numpy.sum(glw*integrand(glx))", "docstring": "Integral that gives the force in x,y,z" }, { "code": "def _calculate_solar_time(self, hour, eq_of_time, is_solar_time):\n if is_solar_time:\n return hour\n return (\n (hour * 60 + eq_of_time + 4 * math.degrees(self._longitude) -\n 60 * self.time_zone) % 1440) / 60", "docstring": "Calculate Solar time for an hour." }, { "code": "def fromLatex(tex, *args, **kwargs):\n source = TexSoup(tex)\n return TOC('[document]', source=source,\n descendants=list(source.descendants), *args, **kwargs)", "docstring": "Creates abstraction using Latex\n\n :param str tex: Latex\n :return: TreeOfContents object" }, { "code": "def remove_overlap(self, begin, end=None):\n hitlist = self.at(begin) if end is None else self.overlap(begin, end)\n for iv in hitlist:\n self.remove(iv)", "docstring": "Removes all intervals overlapping the given point or range.\n\n Completes in O((r+m)*log n) time, where:\n * n = size of the tree\n * m = number of matches\n * r = size of the search range (this is 1 for a point)" }, { "code": "def str_deps(self):\n lines = []\n app = lines.append\n app(\"Dependencies of node %s:\" % str(self))\n for i, dep in enumerate(self.deps):\n app(\"%d) %s, status=%s\" % (i, dep.info, str(dep.status)))\n return \"\\n\".join(lines)", "docstring": "Return the string representation of the dependencies of the node." }, { "code": "async def execute(self, keys=[], args=[], client=None):\n \"Execute the script, passing any required ``args``\"\n if client is None:\n client = self.registered_client\n args = tuple(keys) + tuple(args)\n if isinstance(client, BasePipeline):\n client.scripts.add(self)\n try:\n return await client.evalsha(self.sha, len(keys), *args)\n except NoScriptError:\n self.sha = await client.script_load(self.script)\n return await client.evalsha(self.sha, len(keys), *args)", "docstring": "Execute the script, passing any required ``args``" }, { "code": "def pubmed_url(args=sys.argv[1:], resolve_doi=True, out=sys.stdout):\n parser = argparse.ArgumentParser(\n description='Get a publication URL using a PubMed ID or PubMed URL')\n parser.add_argument('query', help='PubMed ID or PubMed URL')\n parser.add_argument(\n '-d', '--doi', action='store_false', help='get DOI URL')\n parser.add_argument(\n '-e', '--email', action='store', help='set user email', default='')\n args = parser.parse_args(args=args)\n lookup = PubMedLookup(args.query, args.email)\n publication = Publication(lookup, resolve_doi=args.doi)\n out.write(publication.url + '\\n')", "docstring": "Get a publication URL via the command line using a PubMed ID or PubMed URL" }, { "code": "def geo(self):\n out = dict(zip(['xmin', 'xres', 'rotation_x', 'ymax', 'rotation_y', 'yres'],\n self.raster.GetGeoTransform()))\n out['xmax'] = out['xmin'] + out['xres'] * self.cols\n out['ymin'] = out['ymax'] + out['yres'] * self.rows\n return out", "docstring": "General image geo information.\n\n Returns\n -------\n dict\n a dictionary with keys `xmin`, `xmax`, `xres`, `rotation_x`, `ymin`, `ymax`, `yres`, `rotation_y`" }, { "code": "def cyvcf_add_filter(rec, name):\n if rec.FILTER:\n filters = rec.FILTER.split(\";\")\n else:\n filters = []\n if name not in filters:\n filters.append(name)\n rec.FILTER = filters\n return rec", "docstring": "Add a FILTER value to a cyvcf2 record" }, { "code": "def cache_hash(*a, **kw):\n def cache_str(o):\n if isinstance(o, (types.FunctionType, types.BuiltinFunctionType,\n types.MethodType, types.BuiltinMethodType,\n types.UnboundMethodType)):\n return getattr(o, 'func_name', 'func')\n if isinstance(o, dict):\n o = [k + ':' + cache_str(v) for k, v in o.items()]\n if isinstance(o, (list, tuple, set)):\n o = sorted(map(cache_str, o))\n o = '|'.join(o)\n if isinstance(o, basestring):\n return o\n if hasattr(o, 'updated_at'):\n return cache_str((repr(o), o.updated_at))\n return repr(o)\n hash = cache_str((a, kw)).encode('utf-8')\n return sha1(hash).hexdigest()", "docstring": "Try to hash an arbitrary object for caching." }, { "code": "def get_soql_fields(soql):\n soql_fields = re.search('(?<=select)(?s)(.*)(?=from)', soql, re.IGNORECASE)\n soql_fields = re.sub(' ', '', soql_fields.group())\n soql_fields = re.sub('\\t', '', soql_fields)\n fields = re.split(',|\\n|\\r|', soql_fields)\n fields = [field for field in fields if field != '']\n return fields", "docstring": "Gets queried columns names." }, { "code": "def _one_hidden(self, l:int)->Tensor:\n \"Return one hidden state.\"\n nh = (self.n_hid if l != self.n_layers - 1 else self.emb_sz) // self.n_dir\n return one_param(self).new(1, self.bs, nh).zero_()", "docstring": "Return one hidden state." }, { "code": "def read(self):\n found = Client.read(self)\n if self.needs_distribute_ready():\n self.distribute_ready()\n return found", "docstring": "Read some number of messages" }, { "code": "def visualize(\n logdir, outdir, num_agents, num_episodes, checkpoint=None,\n env_processes=True):\n config = utility.load_config(logdir)\n with tf.device('/cpu:0'):\n batch_env = utility.define_batch_env(\n lambda: _create_environment(config, outdir),\n num_agents, env_processes)\n graph = utility.define_simulation_graph(\n batch_env, config.algorithm, config)\n total_steps = num_episodes * config.max_length\n loop = _define_loop(graph, total_steps)\n saver = utility.define_saver(\n exclude=(r'.*_temporary.*', r'global_step'))\n sess_config = tf.ConfigProto(allow_soft_placement=True)\n sess_config.gpu_options.allow_growth = True\n with tf.Session(config=sess_config) as sess:\n utility.initialize_variables(\n sess, saver, config.logdir, checkpoint, resume=True)\n for unused_score in loop.run(sess, saver, total_steps):\n pass\n batch_env.close()", "docstring": "Recover checkpoint and render videos from it.\n\n Args:\n logdir: Logging directory of the trained algorithm.\n outdir: Directory to store rendered videos in.\n num_agents: Number of environments to simulate in parallel.\n num_episodes: Total number of episodes to simulate.\n checkpoint: Checkpoint name to load; defaults to most recent.\n env_processes: Whether to step environments in separate processes." }, { "code": "def _load_properties(property_name, config_option, set_default=False, default=None):\n if not property_name:\n log.debug(\"No property specified in function, trying to load from salt configuration\")\n try:\n options = __salt__['config.option']('cassandra')\n except BaseException as e:\n log.error(\"Failed to get cassandra config options. Reason: %s\", e)\n raise\n loaded_property = options.get(config_option)\n if not loaded_property:\n if set_default:\n log.debug('Setting default Cassandra %s to %s', config_option, default)\n loaded_property = default\n else:\n log.error('No cassandra %s specified in the configuration or passed to the module.', config_option)\n raise CommandExecutionError(\"ERROR: Cassandra {0} cannot be empty.\".format(config_option))\n return loaded_property\n return property_name", "docstring": "Load properties for the cassandra module from config or pillar.\n\n :param property_name: The property to load.\n :type property_name: str or list of str\n :param config_option: The name of the config option.\n :type config_option: str\n :param set_default: Should a default be set if not found in config.\n :type set_default: bool\n :param default: The default value to be set.\n :type default: str or int\n :return: The property fetched from the configuration or default.\n :rtype: str or list of str" }, { "code": "def join(self, timeout=None):\n if self.__wait_for_finishing_thread:\n if not timeout:\n while True:\n self.__wait_for_finishing_thread.join(0.5)\n if not self.__wait_for_finishing_thread.isAlive():\n break\n else:\n self.__wait_for_finishing_thread.join(timeout)\n return not self.__wait_for_finishing_thread.is_alive()\n else:\n logger.warning(\"Cannot join as state machine was not started yet.\")\n return False", "docstring": "Blocking wait for the execution to finish\n\n :param float timeout: Maximum time to wait or None for infinitely\n :return: True if the execution finished, False if no state machine was started or a timeout occurred\n :rtype: bool" }, { "code": "def _unpack_model(self, om):\n buses = om.case.connected_buses\n branches = om.case.online_branches\n gens = om.case.online_generators\n cp = om.get_cost_params()\n return buses, branches, gens, cp", "docstring": "Returns data from the OPF model." }, { "code": "def info_hash(self):\n info = self._struct.get('info')\n if not info:\n return None\n return sha1(Bencode.encode(info)).hexdigest()", "docstring": "Hash of torrent file info section. Also known as torrent hash." }, { "code": "def fetchItem(self, ekey, cls=None, **kwargs):\n if isinstance(ekey, int):\n ekey = '/library/metadata/%s' % ekey\n for elem in self._server.query(ekey):\n if self._checkAttrs(elem, **kwargs):\n return self._buildItem(elem, cls, ekey)\n clsname = cls.__name__ if cls else 'None'\n raise NotFound('Unable to find elem: cls=%s, attrs=%s' % (clsname, kwargs))", "docstring": "Load the specified key to find and build the first item with the\n specified tag and attrs. If no tag or attrs are specified then\n the first item in the result set is returned.\n\n Parameters:\n ekey (str or int): Path in Plex to fetch items from. If an int is passed\n in, the key will be translated to /library/metadata/. This allows\n fetching an item only knowing its key-id.\n cls (:class:`~plexapi.base.PlexObject`): If you know the class of the\n items to be fetched, passing this in will help the parser ensure\n it only returns those items. By default we convert the xml elements\n with the best guess PlexObjects based on tag and type attrs.\n etag (str): Only fetch items with the specified tag.\n **kwargs (dict): Optionally add attribute filters on the items to fetch. For\n example, passing in viewCount=0 will only return matching items. Filtering\n is done before the Python objects are built to help keep things speedy.\n Note: Because some attribute names are already used as arguments to this\n function, such as 'tag', you may still reference the attr tag byappending\n an underscore. For example, passing in _tag='foobar' will return all items\n where tag='foobar'. Also Note: Case very much matters when specifying kwargs\n -- Optionally, operators can be specified by append it\n to the end of the attribute name for more complex lookups. For example,\n passing in viewCount__gte=0 will return all items where viewCount >= 0.\n Available operations include:\n\n * __contains: Value contains specified arg.\n * __endswith: Value ends with specified arg.\n * __exact: Value matches specified arg.\n * __exists (bool): Value is or is not present in the attrs.\n * __gt: Value is greater than specified arg.\n * __gte: Value is greater than or equal to specified arg.\n * __icontains: Case insensative value contains specified arg.\n * __iendswith: Case insensative value ends with specified arg.\n * __iexact: Case insensative value matches specified arg.\n * __in: Value is in a specified list or tuple.\n * __iregex: Case insensative value matches the specified regular expression.\n * __istartswith: Case insensative value starts with specified arg.\n * __lt: Value is less than specified arg.\n * __lte: Value is less than or equal to specified arg.\n * __regex: Value matches the specified regular expression.\n * __startswith: Value starts with specified arg." }, { "code": "def filesys_decode(path):\n if isinstance(path, six.text_type):\n return path\n fs_enc = sys.getfilesystemencoding() or 'utf-8'\n candidates = fs_enc, 'utf-8'\n for enc in candidates:\n try:\n return path.decode(enc)\n except UnicodeDecodeError:\n continue", "docstring": "Ensure that the given path is decoded,\n NONE when no expected encoding works" }, { "code": "def get_events_attendees(self, event_ids):\n query = urllib.urlencode({'key': self._api_key,\n 'event_id': ','.join(event_ids)})\n url = '{0}?{1}'.format(RSVPS_URL, query)\n data = self._http_get_json(url)\n rsvps = data['results']\n return [(rsvp['event']['id'], parse_member_from_rsvp(rsvp))\n for rsvp in rsvps\n if rsvp['response'] != \"no\"]", "docstring": "Get the attendees of the identified events.\n\n Parameters\n ----------\n event_ids\n List of IDs of events to get attendees for.\n\n Returns\n -------\n List of tuples of (event id, ``pythonkc_meetups.types.MeetupMember``).\n\n Exceptions\n ----------\n * PythonKCMeetupsBadJson\n * PythonKCMeetupsBadResponse\n * PythonKCMeetupsMeetupDown\n * PythonKCMeetupsNotJson\n * PythonKCMeetupsRateLimitExceeded" }, { "code": "def status_message(self):\n msg = None\n if self.last_ddns_response in response_messages.keys():\n return response_messages.get(self.last_ddns_response)\n if 'good' in self.last_ddns_response:\n ip = re.search(r'(\\d{1,3}\\.?){4}', self.last_ddns_response).group()\n msg = \"SUCCESS: DNS hostname IP (%s) successfully updated.\" % ip\n elif 'nochg' in self.last_ddns_response:\n ip = re.search(r'(\\d{1,3}\\.?){4}', self.last_ddns_response).group()\n msg = \"SUCCESS: IP address (%s) is up to date, nothing was changed. \" \\\n \"Additional 'nochg' updates may be considered abusive.\" % ip\n else:\n msg = \"ERROR: Ooops! Something went wrong !!!\"\n return msg", "docstring": "Return friendly response from API based on response code." }, { "code": "def get_objgrpwr(self, goea_results):\n sortobj = self.get_sortobj(goea_results)\n return GrpWr(sortobj, self.pval_fld, ver_list=self.ver_list)", "docstring": "Get a GrpWr object to write grouped GOEA results." }, { "code": "def provider(cls, note, provider=None, name=False):\n def decorator(provider):\n if inspect.isgeneratorfunction(provider):\n provider = cls.generator_provider.bind(\n provider, support_name=name)\n return decorator(provider)\n cls.register(note, provider)\n return provider\n if provider is not None:\n decorator(provider)\n else:\n return decorator", "docstring": "Register a provider, either a Provider class or a generator.\n\n Provider class::\n\n from jeni import Injector as BaseInjector\n from jeni import Provider\n\n class Injector(BaseInjector):\n pass\n\n @Injector.provider('hello')\n class HelloProvider(Provider):\n def get(self, name=None):\n if name is None:\n name = 'world'\n return 'Hello, {}!'.format(name)\n\n Simple generator::\n\n @Injector.provider('answer')\n def answer():\n yield 42\n\n If a generator supports get with a name argument::\n\n @Injector.provider('spam', name=True)\n def spam():\n count_str = yield 'spam'\n while True:\n count_str = yield 'spam' * int(count_str)\n\n Registration can be a decorator or a direct method call::\n\n Injector.provider('hello', HelloProvider)" }, { "code": "def get_primary_mac_address():\n log = logging.getLogger(mod_logger + '.get_primary_mac_address')\n log.debug('Attempting to determine the MAC address for eth0...')\n try:\n mac_address = netifaces.ifaddresses('eth0')[netifaces.AF_LINK][0]['addr']\n except Exception:\n _, ex, trace = sys.exc_info()\n msg = '{n}: Unable to determine the eth0 mac address for this system:\\n{e}'.format(\n n=ex.__class__.__name__, e=str(ex))\n raise AWSMetaDataError, msg, trace\n return mac_address", "docstring": "Determines the MAC address to use for querying the AWS\n meta data service for network related queries\n\n :return: (str) MAC address for the eth0 interface\n :raises: AWSMetaDataError" }, { "code": "def create_filter(self, name=None, description=None,\n jql=None, favourite=None):\n data = {}\n if name is not None:\n data['name'] = name\n if description is not None:\n data['description'] = description\n if jql is not None:\n data['jql'] = jql\n if favourite is not None:\n data['favourite'] = favourite\n url = self._get_url('filter')\n r = self._session.post(\n url, data=json.dumps(data))\n raw_filter_json = json_loads(r)\n return Filter(self._options, self._session, raw=raw_filter_json)", "docstring": "Create a new filter and return a filter Resource for it.\n\n :param name: name of the new filter\n :type name: str\n :param description: useful human readable description of the new filter\n :type description: str\n :param jql: query string that defines the filter\n :type jql: str\n :param favourite: whether to add this filter to the current user's favorites\n :type favourite: bool\n :rtype: Filter" }, { "code": "def show_explorer(self):\r\n if self.dockwidget is not None:\r\n if self.dockwidget.isHidden():\r\n self.dockwidget.show()\r\n self.dockwidget.raise_()\r\n self.dockwidget.update()", "docstring": "Show the explorer" }, { "code": "def solvePerfForesight(solution_next,DiscFac,LivPrb,CRRA,Rfree,PermGroFac):\n solver = ConsPerfForesightSolver(solution_next,DiscFac,LivPrb,CRRA,Rfree,PermGroFac)\n solution = solver.solve()\n return solution", "docstring": "Solves a single period consumption-saving problem for a consumer with perfect foresight.\n\n Parameters\n ----------\n solution_next : ConsumerSolution\n The solution to next period's one period problem.\n DiscFac : float\n Intertemporal discount factor for future utility.\n LivPrb : float\n Survival probability; likelihood of being alive at the beginning of\n the succeeding period.\n CRRA : float\n Coefficient of relative risk aversion.\n Rfree : float\n Risk free interest factor on end-of-period assets.\n PermGroFac : float\n Expected permanent income growth factor at the end of this period.\n\n Returns\n -------\n solution : ConsumerSolution\n The solution to this period's problem." }, { "code": "def A(self, ID):\n obj = self.chart.getObject(ID).antiscia()\n ID = 'A_%s' % (ID)\n return self.G(ID, obj.lat, obj.lon)", "docstring": "Returns the Antiscia of an object." }, { "code": "def cwd(self, newdir):\n logger.debug('Sending FTP cwd command. New Workding Directory: {}'.format(newdir))\n self.client.cwd(newdir)\n self.state['current_dir'] = self.client.pwd()", "docstring": "Send the FTP CWD command\n\n :param newdir: Directory to change to" }, { "code": "def merge_contextual(self, other):\n for k in self.keys():\n for item in self[k]:\n for other_item in other.get(k, []):\n if isinstance(other_item, six.text_type):\n continue\n for otherk in other_item.keys():\n if isinstance(other_item[otherk], list):\n if len(other_item[otherk]) > 0 and len(item[otherk]) > 0:\n other_nested_item = other_item[otherk][0]\n for othernestedk in other_nested_item.keys():\n for nested_item in item[otherk]:\n if not nested_item[othernestedk]:\n nested_item[othernestedk] = other_nested_item[othernestedk]\n elif not item[otherk]:\n item[otherk] = other_item[otherk]\n log.debug('Result: %s' % self.serialize())\n return self", "docstring": "Merge in contextual info from a template Compound." }, { "code": "def prj_add_dep(self, *args, **kwargs):\n if not self.cur_prj:\n return\n dialog = DepAdderDialog(project=self.cur_prj)\n dialog.exec_()\n deps = dialog.deps\n for dep in deps:\n depdata = djitemdata.DepartmentItemData(dep)\n treemodel.TreeItem(depdata, self.prj_dep_model.root)", "docstring": "Add more departments to the project.\n\n :returns: None\n :rtype: None\n :raises: None" }, { "code": "def kdf(size, password, salt,\n opslimit=OPSLIMIT_SENSITIVE,\n memlimit=MEMLIMIT_SENSITIVE,\n encoder=nacl.encoding.RawEncoder):\n return encoder.encode(\n nacl.bindings.crypto_pwhash_alg(size, password, salt,\n opslimit, memlimit,\n ALG)\n )", "docstring": "Derive a ``size`` bytes long key from a caller-supplied\n ``password`` and ``salt`` pair using the argon2i\n memory-hard construct.\n\n the enclosing module provides the constants\n\n - :py:const:`.OPSLIMIT_INTERACTIVE`\n - :py:const:`.MEMLIMIT_INTERACTIVE`\n - :py:const:`.OPSLIMIT_MODERATE`\n - :py:const:`.MEMLIMIT_MODERATE`\n - :py:const:`.OPSLIMIT_SENSITIVE`\n - :py:const:`.MEMLIMIT_SENSITIVE`\n\n as a guidance for correct settings.\n\n :param size: derived key size, must be between\n :py:const:`.BYTES_MIN` and\n :py:const:`.BYTES_MAX`\n :type size: int\n :param password: password used to seed the key derivation procedure;\n it length must be between\n :py:const:`.PASSWD_MIN` and\n :py:const:`.PASSWD_MAX`\n :type password: bytes\n :param salt: **RANDOM** salt used in the key derivation procedure;\n its length must be exactly :py:const:`.SALTBYTES`\n :type salt: bytes\n :param opslimit: the time component (operation count)\n of the key derivation procedure's computational cost;\n it must be between\n :py:const:`.OPSLIMIT_MIN` and\n :py:const:`.OPSLIMIT_MAX`\n :type opslimit: int\n :param memlimit: the memory occupation component\n of the key derivation procedure's computational cost;\n it must be between\n :py:const:`.MEMLIMIT_MIN` and\n :py:const:`.MEMLIMIT_MAX`\n :type memlimit: int\n :rtype: bytes\n\n .. versionadded:: 1.2" }, { "code": "def login(self):\n resp = super(CookieSession, self).request(\n 'POST',\n self._session_url,\n data={'name': self._username, 'password': self._password},\n )\n resp.raise_for_status()", "docstring": "Perform cookie based user login." }, { "code": "def make_ascii(word):\n if sys.version_info < (3, 0, 0):\n word = unicode(word)\n else:\n word = str(word)\n normalized = unicodedata.normalize('NFKD', word)\n return normalized.encode('ascii', 'ignore').decode('utf-8')", "docstring": "Converts unicode-specific characters to their equivalent ascii" }, { "code": "def getCellStr(self, x, y):\n c = self.board.getCell(x, y)\n if c == 0:\n return '.' if self.__azmode else ' .'\n elif self.__azmode:\n az = {}\n for i in range(1, int(math.log(self.board.goal(), 2))):\n az[2 ** i] = chr(i + 96)\n if c not in az:\n return '?'\n s = az[c]\n elif c == 1024:\n s = ' 1k'\n elif c == 2048:\n s = ' 2k'\n else:\n s = '%3d' % c\n return self.__colors.get(c, Fore.RESET) + s + Style.RESET_ALL", "docstring": "return a string representation of the cell located at x,y." }, { "code": "def floating_point(\n element_name,\n attribute=None,\n required=True,\n alias=None,\n default=0.0,\n omit_empty=False,\n hooks=None\n):\n value_parser = _number_parser(float)\n return _PrimitiveValue(\n element_name,\n value_parser,\n attribute,\n required,\n alias,\n default,\n omit_empty,\n hooks\n )", "docstring": "Create a processor for floating point values.\n\n See also :func:`declxml.boolean`" }, { "code": "def __get_switch_arr(work_sheet, row_num):\n u_dic = []\n for col_idx in FILTER_COLUMNS:\n cell_val = work_sheet['{0}{1}'.format(col_idx, row_num)].value\n if cell_val in [1, '1']:\n u_dic.append(work_sheet['{0}1'.format(col_idx)].value.strip().split(',')[0])\n return u_dic", "docstring": "if valud of the column of the row is `1`, it will be added to the array." }, { "code": "def get_parser(description, input_desc):\n parser = ArgumentParser(description=description)\n parser.add_argument(\n dest='input_file',\n help=input_desc\n )\n parser.add_argument(\n '-r', '--readers',\n choices=['reach', 'sparser', 'trips'],\n help='List of readers to be used.',\n nargs='+'\n )\n parser.add_argument(\n '-n', '--num_procs',\n dest='n_proc',\n help='Select the number of processes to use.',\n type=int,\n default=1\n )\n parser.add_argument(\n '-s', '--sample',\n dest='n_samp',\n help='Read a random sample of size N_SAMP of the inputs.',\n type=int\n )\n parser.add_argument(\n '-I', '--in_range',\n dest='range_str',\n help='Only read input lines in the range given as :.'\n )\n parser.add_argument(\n '-v', '--verbose',\n help='Include output from the readers.',\n action='store_true'\n )\n parser.add_argument(\n '-q', '--quiet',\n help='Suppress most output. Overrides -v and -d options.',\n action='store_true'\n )\n parser.add_argument(\n '-d', '--debug',\n help='Set the logging to debug level.',\n action='store_true'\n )\n return parser", "docstring": "Get a parser that is generic to reading scripts.\n\n Parameters\n ----------\n description : str\n A description of the tool, usually about one line long.\n input_desc: str\n A string describing the nature of the input file used by the reading\n tool.\n\n Returns\n -------\n parser : argparse.ArgumentParser instance\n An argument parser object, to which further arguments can be added." }, { "code": "def get_sessions(self, app_path=None):\n if app_path is not None:\n return self._tornado.get_sessions(app_path)\n all_sessions = []\n for path in self._tornado.app_paths:\n all_sessions += self._tornado.get_sessions(path)\n return all_sessions", "docstring": "Gets all currently active sessions for applications.\n\n Args:\n app_path (str, optional) :\n The configured application path for the application to return\n sessions for. If None, return active sessions for all\n applications. (default: None)\n\n Returns:\n list[ServerSession]" }, { "code": "def get_remote_member(self, member=None):\n cluster_params = self.get_standby_cluster_config()\n if cluster_params:\n name = member.name if member else 'remote_master:{}'.format(uuid.uuid1())\n data = {k: v for k, v in cluster_params.items() if k in RemoteMember.allowed_keys()}\n data['no_replication_slot'] = 'primary_slot_name' not in cluster_params\n conn_kwargs = member.conn_kwargs() if member else \\\n {k: cluster_params[k] for k in ('host', 'port') if k in cluster_params}\n if conn_kwargs:\n data['conn_kwargs'] = conn_kwargs\n return RemoteMember(name, data)", "docstring": "In case of standby cluster this will tel us from which remote\n master to stream. Config can be both patroni config or\n cluster.config.data" }, { "code": "def get_number_unit(number):\n n = str(float(number))\n mult, submult = n.split('.')\n if float(submult) != 0:\n unit = '0.' + (len(submult)-1)*'0' + '1'\n return float(unit)\n else:\n return float(1)", "docstring": "get the unit of number" }, { "code": "def _create_drawables(self, tokensource):\n lineno = charno = maxcharno = 0\n for ttype, value in tokensource:\n while ttype not in self.styles:\n ttype = ttype.parent\n style = self.styles[ttype]\n value = value.expandtabs(4)\n lines = value.splitlines(True)\n for i, line in enumerate(lines):\n temp = line.rstrip('\\n')\n if temp:\n self._draw_text(\n self._get_text_pos(charno, lineno),\n temp,\n font = self._get_style_font(style),\n fill = self._get_text_color(style)\n )\n charno += len(temp)\n maxcharno = max(maxcharno, charno)\n if line.endswith('\\n'):\n charno = 0\n lineno += 1\n self.maxcharno = maxcharno\n self.maxlineno = lineno", "docstring": "Create drawables for the token content." }, { "code": "def get_protocol_from_name(name):\n cls = protocol_map.get(name)\n if not cls:\n raise ValueError('Unsupported protocol \"%s\".' % name)\n return cls", "docstring": "Returns the protocol class for the protocol with the given name.\n\n :type name: str\n :param name: The name of the protocol.\n :rtype: Protocol\n :return: The protocol class." }, { "code": "def _get_sqla_coltype_class_from_str(coltype: str,\n dialect: Dialect) -> Type[TypeEngine]:\n ischema_names = dialect.ischema_names\n try:\n return ischema_names[coltype.upper()]\n except KeyError:\n return ischema_names[coltype.lower()]", "docstring": "Returns the SQLAlchemy class corresponding to a particular SQL column\n type in a given dialect.\n\n Performs an upper- and lower-case search.\n For example, the SQLite dialect uses upper case, and the\n MySQL dialect uses lower case." }, { "code": "def sam2fastq(line):\n fastq = []\n fastq.append('@%s' % line[0])\n fastq.append(line[9])\n fastq.append('+%s' % line[0])\n fastq.append(line[10])\n return fastq", "docstring": "print fastq from sam" }, { "code": "def hasmethod(obj, meth):\n if hasattr(obj, meth):\n return callable(getattr(obj,meth))\n return False", "docstring": "Checks if an object, obj, has a callable method, meth\n \n return True or False" }, { "code": "def index_model(index_name, adapter):\n model = adapter.model\n log.info('Indexing {0} objects'.format(model.__name__))\n qs = model.objects\n if hasattr(model.objects, 'visible'):\n qs = qs.visible()\n if adapter.exclude_fields:\n qs = qs.exclude(*adapter.exclude_fields)\n docs = iter_qs(qs, adapter)\n docs = iter_for_index(docs, index_name)\n for ok, info in streaming_bulk(es.client, docs, raise_on_error=False):\n if not ok:\n log.error('Unable to index %s \"%s\": %s', model.__name__,\n info['index']['_id'], info['index']['error'])", "docstring": "Indel all objects given a model" }, { "code": "def eq(self, r1, r2):\n if not is_register(r1) or not is_register(r2):\n return False\n if self.regs[r1] is None or self.regs[r2] is None:\n return False\n return self.regs[r1] == self.regs[r2]", "docstring": "True if values of r1 and r2 registers are equal" }, { "code": "def create(self, name, type, mains=None, libs=None, description=None,\n interface=None, is_public=None, is_protected=None):\n data = {\n 'name': name,\n 'type': type\n }\n self._copy_if_defined(data, description=description, mains=mains,\n libs=libs, interface=interface,\n is_public=is_public, is_protected=is_protected)\n return self._create('/jobs', data, 'job')", "docstring": "Create a Job." }, { "code": "def process_task(self):\n if _debug: ServerSSM._debug(\"process_task\")\n if self.state == SEGMENTED_REQUEST:\n self.segmented_request_timeout()\n elif self.state == AWAIT_RESPONSE:\n self.await_response_timeout()\n elif self.state == SEGMENTED_RESPONSE:\n self.segmented_response_timeout()\n elif self.state == COMPLETED:\n pass\n elif self.state == ABORTED:\n pass\n else:\n if _debug: ServerSSM._debug(\"invalid state\")\n raise RuntimeError(\"invalid state\")", "docstring": "This function is called when the client has failed to send all of the\n segments of a segmented request, the application has taken too long to\n complete the request, or the client failed to ack the segments of a\n segmented response." }, { "code": "def git_status_all_repos(cat, hard=True, origin=False, clean=True):\n log = cat.log\n log.debug(\"gitter.git_status_all_repos()\")\n all_repos = cat.PATHS.get_all_repo_folders()\n for repo_name in all_repos:\n log.info(\"Repo in: '{}'\".format(repo_name))\n sha_beg = get_sha(repo_name)\n log.debug(\"Current SHA: '{}'\".format(sha_beg))\n log.info(\"Fetching\")\n fetch(repo_name, log=cat.log)\n git_comm = [\"git\", \"status\"]\n _call_command_in_repo(\n git_comm, repo_name, cat.log, fail=True, log_flag=True)\n sha_end = get_sha(repo_name)\n if sha_end != sha_beg:\n log.info(\"Updated SHA: '{}'\".format(sha_end))\n return", "docstring": "Perform a 'git status' in each data repository." }, { "code": "def setup(self, environ):\n request = wsgi_request(environ)\n cfg = request.cache.cfg\n loop = request.cache._loop\n self.store = create_store(cfg.data_store, loop=loop)\n pubsub = self.store.pubsub(protocol=Protocol())\n channel = '%s_webchat' % self.name\n ensure_future(pubsub.subscribe(channel), loop=loop)\n return WsgiHandler([Router('/', get=self.home_page),\n WebSocket('/message', Chat(pubsub, channel)),\n Router('/rpc', post=Rpc(pubsub, channel),\n response_content_types=JSON_CONTENT_TYPES)],\n [AsyncResponseMiddleware,\n GZipMiddleware(min_length=20)])", "docstring": "Called once only to setup the WSGI application handler.\n\n Check :ref:`lazy wsgi handler `\n section for further information." }, { "code": "def _linkToParent(self, feature, parentName):\n parentParts = self.byFeatureName.get(parentName)\n if parentParts is None:\n raise GFF3Exception(\n \"Parent feature does not exist: {}\".format(parentName),\n self.fileName)\n for parentPart in parentParts:\n feature.parents.add(parentPart)\n parentPart.children.add(feature)", "docstring": "Link a feature with its children" }, { "code": "def error_cutout_ma(self):\n if self._error is None:\n return None\n else:\n return np.ma.masked_array(self._error[self._slice],\n mask=self._total_mask)", "docstring": "A 2D `~numpy.ma.MaskedArray` cutout from the input ``error``\n image.\n\n The mask is `True` for pixels outside of the source segment\n (labeled region of interest), masked pixels from the ``mask``\n input, or any non-finite ``data`` values (e.g. NaN or inf).\n\n If ``error`` is `None`, then ``error_cutout_ma`` is also `None`." }, { "code": "def words(self, quantity: int = 5) -> List[str]:\n words = self._data['words'].get('normal')\n words_list = [self.random.choice(words) for _ in range(quantity)]\n return words_list", "docstring": "Generate lis of the random words.\n\n :param quantity: Quantity of words. Default is 5.\n :return: Word list.\n\n :Example:\n [science, network, god, octopus, love]" }, { "code": "def optimize(self, sess, batch_index):\n feed_dict = {\n self._batch_index: batch_index,\n self._per_device_batch_size: self._loaded_per_device_batch_size,\n self._max_seq_len: self._loaded_max_seq_len,\n }\n for tower in self._towers:\n feed_dict.update(tower.loss_graph.extra_compute_grad_feed_dict())\n fetches = {\"train\": self._train_op}\n for tower in self._towers:\n fetches.update(tower.loss_graph.extra_compute_grad_fetches())\n return sess.run(fetches, feed_dict=feed_dict)", "docstring": "Run a single step of SGD.\n\n Runs a SGD step over a slice of the preloaded batch with size given by\n self._loaded_per_device_batch_size and offset given by the batch_index\n argument.\n\n Updates shared model weights based on the averaged per-device\n gradients.\n\n Args:\n sess: TensorFlow session.\n batch_index: Offset into the preloaded data. This value must be\n between `0` and `tuples_per_device`. The amount of data to\n process is at most `max_per_device_batch_size`.\n\n Returns:\n The outputs of extra_ops evaluated over the batch." }, { "code": "def rotateAroundVector(v1, w, theta_deg):\n ct = np.cos(np.radians(theta_deg))\n st = np.sin(np.radians(theta_deg))\n term1 = v1*ct\n term2 = np.cross(w, v1) * st\n term3 = np.dot(w, v1)\n term3 = w * term3 * (1-ct)\n return term1 + term2 + term3", "docstring": "Rotate vector v1 by an angle theta around w\n\n Taken from https://en.wikipedia.org/wiki/Axis%E2%80%93angle_representation\n (see Section \"Rotating a vector\")\n\n Notes:\n Rotating the x axis 90 degrees about the y axis gives -z\n Rotating the x axis 90 degrees about the z axis gives +y" }, { "code": "def in_tree(self, name):\n r\n if self._validate_node_name(name):\n raise RuntimeError(\"Argument `name` is not valid\")\n return name in self._db", "docstring": "r\"\"\"\n Test if a node is in the tree.\n\n :param name: Node name to search for\n :type name: :ref:`NodeName`\n\n :rtype: boolean\n\n :raises: RuntimeError (Argument \\`name\\` is not valid)" }, { "code": "def _get(self, locator, expected_condition, params=None, timeout=None, error_msg=\"\", driver=None, **kwargs):\n from selenium.webdriver.support.ui import WebDriverWait\n if not isinstance(locator, WebElement):\n error_msg += \"\\nLocator of type <{}> with selector <{}> with params <{params}>\".format(\n *locator, params=params)\n locator = self.__class__.get_compliant_locator(*locator, params=params)\n _driver = driver or self.driver\n exp_cond = expected_condition(locator, **kwargs)\n if timeout == 0:\n try:\n return exp_cond(_driver)\n except NoSuchElementException:\n return None\n if timeout is None:\n timeout = self._explicit_wait\n error_msg += \"\\nExpected condition: {}\" \\\n \"\\nTimeout: {}\".format(expected_condition, timeout)\n return WebDriverWait(_driver, timeout).until(exp_cond, error_msg)", "docstring": "Get elements based on locator with optional parameters.\n\n Uses selenium.webdriver.support.expected_conditions to determine the state of the element(s).\n\n :param locator: element identifier\n :param expected_condition: expected condition of element (ie. visible, clickable, etc)\n :param params: (optional) locator parameters\n :param timeout: (optional) time to wait for element (default: self._explicit_wait)\n :param error_msg: (optional) customized error message\n :param driver: (optional) alternate Webdriver instance (example: parent-element)\n :param kwargs: optional arguments to expected conditions\n :return: WebElement instance, list of WebElements, or None" }, { "code": "def get_schema_version_from_xml(xml):\n if isinstance(xml, six.string_types):\n xml = StringIO(xml)\n try:\n tree = ElementTree.parse(xml)\n except ParseError:\n return None\n root = tree.getroot()\n return root.attrib.get('schemaVersion', None)", "docstring": "Get schemaVersion attribute from OpenMalaria scenario file\n xml - open file or content of xml document to be processed" }, { "code": "def dataset_path(cache=None, cachefile=\"~/.io3d_cache.yaml\", get_root=False):\n local_data_dir = local_dir\n if cachefile is not None:\n cache = cachef.CacheFile(cachefile)\n if cache is not None:\n local_data_dir = cache.get_or_save_default(\"local_dataset_dir\", local_dir)\n if get_root:\n local_data_dir\n else:\n logger.warning(\"Parameter\")\n local_data_dir = op.join(local_data_dir, \"medical\", \"orig\")\n return op.expanduser(local_data_dir)", "docstring": "Get dataset path.\n\n :param cache: CacheFile object\n :param cachefile: cachefile path, default '~/.io3d_cache.yaml'\n :return: path to dataset" }, { "code": "def get_track_by_mbid(self, mbid):\n params = {\"mbid\": mbid}\n doc = _Request(self, \"track.getInfo\", params).execute(True)\n return Track(_extract(doc, \"name\", 1), _extract(doc, \"name\"), self)", "docstring": "Looks up a track by its MusicBrainz ID" }, { "code": "def clear_ddata(self):\n self._ddata = dict.fromkeys(self._get_keys_ddata())\n self._ddata['uptodate'] = False", "docstring": "Clear the working copy of data\n\n Harmless, as it preserves the reference copy and the treatment dict\n Use only to free some memory" }, { "code": "def toDict(self):\n return {\n 'titleAlignments': [titleAlignment.toDict()\n for titleAlignment in self],\n 'subjectTitle': self.subjectTitle,\n 'subjectLength': self.subjectLength,\n }", "docstring": "Get information about the title's alignments as a dictionary.\n\n @return: A C{dict} representation of the title's aligments." }, { "code": "def resolve_one(self, correlation_id, key):\n connection = None\n for item in self._items:\n if item.key == key and item.connection != None:\n connection = item.connection\n break\n return connection", "docstring": "Resolves a single connection parameters by its key.\n\n :param correlation_id: (optional) transaction id to trace execution through call chain.\n\n :param key: a key to uniquely identify the connection.\n\n :return: a resolved connection." }, { "code": "def _u_distance_correlation_sqr_naive(x, y, exponent=1):\n return _distance_sqr_stats_naive_generic(\n x, y,\n matrix_centered=_u_distance_matrix,\n product=u_product,\n exponent=exponent).correlation_xy", "docstring": "Bias-corrected distance correlation estimator between two matrices." }, { "code": "def make_key_hippie(obj, typed=True):\n ftype = type if typed else lambda o: None\n if is_hashable(obj):\n return obj, ftype(obj)\n if isinstance(obj, set):\n obj = sorted(obj)\n if isinstance(obj, (list, tuple)):\n return tuple(make_key_hippie(e, typed) for e in obj)\n if isinstance(obj, dict):\n return tuple(sorted(((make_key_hippie(k, typed),\n make_key_hippie(v, typed))\n for k, v in obj.items())))\n raise ValueError(\n \"%r can not be hashed. Try providing a custom key function.\"\n % obj)", "docstring": "Return hashable structure from non-hashable structure using hippie means\n\n dict and set are sorted and their content subjected to same hippie means.\n\n Note that the key identifies the current content of the structure." }, { "code": "def read_whole_packet(self):\n self._read_packet()\n return readall(self, self._size - _header.size)", "docstring": "Reads single packet and returns bytes payload of the packet\n\n Can only be called when transport's read pointer is at the beginning\n of the packet." }, { "code": "def samaccountname(self, base_dn, distinguished_name):\n mappings = self.samaccountnames(base_dn, [distinguished_name])\n try:\n return mappings[distinguished_name]\n except KeyError:\n logging.info(\"%s - unable to retrieve object from AD by DistinguishedName\",\n distinguished_name)", "docstring": "Retrieve the sAMAccountName for a specific DistinguishedName\n\n :param str base_dn: The base DN to search within\n :param list distinguished_name: The base DN to search within\n :param list attributes: Object attributes to populate, defaults to all\n\n :return: A populated ADUser object\n :rtype: ADUser" }, { "code": "def datetime_match(data, dts):\n dts = dts if islistable(dts) else [dts]\n if any([not isinstance(i, datetime.datetime) for i in dts]):\n error_msg = (\n \"`time` can only be filtered by datetimes\"\n )\n raise TypeError(error_msg)\n return data.isin(dts)", "docstring": "matching of datetimes in time columns for data filtering" }, { "code": "def load(self):\n private = self.is_private()\n with open_tls_file(self.file_path, 'r', private=private) as fh:\n if private:\n self.x509 = crypto.load_privatekey(self.encoding, fh.read())\n else:\n self.x509 = crypto.load_certificate(self.encoding, fh.read())\n return self.x509", "docstring": "Load from a file and return an x509 object" }, { "code": "def all_methods(cls):\n def name(fn):\n return fn.__get__(cls).__name__.replace(\"_\", \"-\")\n return sorted(name(f) for f in cls.__dict__.values()\n if isinstance(f, staticmethod))", "docstring": "Return the names of all available binning methods" }, { "code": "def segment(self, value=None, scope=None, metric_scope=None, **selection):\n SCOPES = {\n 'hits': 'perHit',\n 'sessions': 'perSession',\n 'users': 'perUser',\n }\n segments = self.meta.setdefault('segments', [])\n if value and len(selection):\n raise ValueError(\"Cannot specify a filter string and a filter keyword selection at the same time.\")\n elif value:\n value = [self.api.segments.serialize(value)]\n elif len(selection):\n if not scope:\n raise ValueError(\"Scope is required. Choose from: users, sessions.\")\n if metric_scope:\n metric_scope = SCOPES[metric_scope]\n value = select(self.api.columns, selection)\n value = [[scope, 'condition', metric_scope, condition] for condition in value]\n value = ['::'.join(filter(None, condition)) for condition in value]\n segments.append(value)\n self.raw['segment'] = utils.paste(segments, ',', ';')\n return self", "docstring": "Return a new query, limited to a segment of all users or sessions.\n\n Accepts segment objects, filtered segment objects and segment names:\n\n ```python\n query.segment(account.segments['browser'])\n query.segment('browser')\n query.segment(account.segments['browser'].any('Chrome', 'Firefox'))\n ```\n\n Segment can also accept a segment expression when you pass\n in a `type` argument. The type argument can be either `users`\n or `sessions`. This is pretty close to the metal.\n\n ```python\n # will be translated into `users::condition::perUser::ga:sessions>10`\n query.segment('condition::perUser::ga:sessions>10', type='users')\n ```\n\n See the [Google Analytics dynamic segments documentation][segments]\n\n You can also use the `any`, `all`, `followed_by` and\n `immediately_followed_by` functions in this module to\n chain together segments.\n\n Everything about how segments get handled is still in flux.\n Feel free to propose ideas for a nicer interface on\n the [GitHub issues page][issues]\n\n [segments]: https://developers.google.com/analytics/devguides/reporting/core/v3/segments#reference\n [issues]: https://github.com/debrouwere/google-analytics/issues" }, { "code": "def _validate_recurse_directive_types(current_schema_type, field_schema_type, context):\n type_hints = context['type_equivalence_hints'].get(field_schema_type)\n type_hints_inverse = context['type_equivalence_hints_inverse'].get(field_schema_type)\n allowed_current_types = {field_schema_type}\n if type_hints and isinstance(type_hints, GraphQLUnionType):\n allowed_current_types.update(type_hints.types)\n if type_hints_inverse and isinstance(type_hints_inverse, GraphQLUnionType):\n allowed_current_types.update(type_hints_inverse.types)\n current_scope_is_allowed = current_schema_type in allowed_current_types\n is_implemented_interface = (\n isinstance(field_schema_type, GraphQLInterfaceType) and\n isinstance(current_schema_type, GraphQLObjectType) and\n field_schema_type in current_schema_type.interfaces\n )\n if not any((current_scope_is_allowed, is_implemented_interface)):\n raise GraphQLCompilationError(u'Edges expanded with a @recurse directive must either '\n u'be of the same type as their enclosing scope, a supertype '\n u'of the enclosing scope, or be of an interface type that is '\n u'implemented by the type of their enclosing scope. '\n u'Enclosing scope type: {}, edge type: '\n u'{}'.format(current_schema_type, field_schema_type))", "docstring": "Perform type checks on the enclosing type and the recursed type for a recurse directive.\n\n Args:\n current_schema_type: GraphQLType, the schema type at the current location\n field_schema_type: GraphQLType, the schema type at the inner scope\n context: dict, various per-compilation data (e.g. declared tags, whether the current block\n is optional, etc.). May be mutated in-place in this function!" }, { "code": "def parse_instruction(string, location, tokens):\n mnemonic_str = tokens.get(\"mnemonic\")\n operands = [op for op in tokens.get(\"operands\", [])]\n instr = ArmInstruction(\n string,\n mnemonic_str[\"ins\"],\n operands,\n arch_info.architecture_mode\n )\n if \"cc\" in mnemonic_str:\n instr.condition_code = cc_mapper[mnemonic_str[\"cc\"]]\n if \"uf\" in mnemonic_str:\n instr.update_flags = True\n if \"ldm_stm_addr_mode\" in mnemonic_str:\n instr.ldm_stm_addr_mode = ldm_stm_am_mapper[mnemonic_str[\"ldm_stm_addr_mode\"]]\n return instr", "docstring": "Parse an ARM instruction." }, { "code": "def slurp(path, encoding='UTF-8'):\n with io.open(path, 'r', encoding=encoding) as f:\n return f.read()", "docstring": "Reads file `path` and returns the entire contents as a unicode string\n\n By default assumes the file is encoded as UTF-8\n\n Parameters\n ----------\n path : str\n File path to file on disk\n encoding : str, default `UTF-8`, optional\n Encoding of the file\n\n Returns\n -------\n\n The txt read from the file as a unicode string" }, { "code": "def sort_by_tag(self, tag):\n return AmpalContainer(sorted(self, key=lambda x: x.tags[tag]))", "docstring": "Sorts the `AmpalContainer` by a tag on the component objects.\n\n Parameters\n ----------\n tag : str\n Key of tag used for sorting." }, { "code": "def categorical__int(self, column_name, output_column_prefix):\n return [_ColumnFunctionTransformation(\n features = [column_name],\n output_column_prefix = output_column_prefix,\n transform_function = lambda col: col.astype(str),\n transform_function_name = \"astype(str)\")]", "docstring": "Interprets an integer column as a categorical variable." }, { "code": "def get_config(self, service, setting):\n try:\n return self.get_service(service)[setting]\n except KeyError:\n return getattr(self, setting + '_DEFAULT')", "docstring": "Access the configuration for a given service and setting. If the\n service is not found, return a default value." }, { "code": "def TransposeTable(table):\n transposed = []\n rows = len(table)\n cols = max(len(row) for row in table)\n for x in range(cols):\n transposed.append([])\n for y in range(rows):\n if x < len(table[y]):\n transposed[x].append(table[y][x])\n else:\n transposed[x].append(None)\n return transposed", "docstring": "Transpose a list of lists, using None to extend all input lists to the\n same length.\n\n For example:\n >>> TransposeTable(\n [ [11, 12, 13],\n [21, 22],\n [31, 32, 33, 34]])\n\n [ [11, 21, 31],\n [12, 22, 32],\n [13, None, 33],\n [None, None, 34]]" }, { "code": "def add_zone(self, spatial_unit, container_id, name='', description='', visible=True, reuse=0, drop_behavior_type=None):\n if not isinstance(spatial_unit, abc_mapping_primitives.SpatialUnit):\n raise InvalidArgument('zone is not a SpatialUnit')\n if not isinstance(reuse, int):\n raise InvalidArgument('reuse must be an integer')\n if reuse < 0:\n raise InvalidArgument('reuse must be >= 0')\n if not isinstance(name, DisplayText):\n name = self._str_display_text(name)\n if not isinstance(description, DisplayText):\n description = self._str_display_text(description)\n zone = {\n 'id': str(ObjectId()),\n 'spatialUnit': spatial_unit.get_spatial_unit_map(),\n 'containerId': container_id,\n 'names': [self._dict_display_text(name)],\n 'descriptions': [self._dict_display_text(description)],\n 'visible': visible,\n 'reuse': reuse,\n 'dropBehaviorType': str(drop_behavior_type)\n }\n self.my_osid_object_form._my_map['zones'].append(zone)\n return zone", "docstring": "container_id is a targetId that the zone belongs to" }, { "code": "def add(self, elem):\n if not isinstance(elem, JWK):\n raise TypeError('Only JWK objects are valid elements')\n set.add(self, elem)", "docstring": "Adds a JWK object to the set\n\n :param elem: the JWK object to add.\n\n :raises TypeError: if the object is not a JWK." }, { "code": "def extendMarkdown(self, md, md_globals):\n md.inlinePatterns.add('del', SimpleTagPattern(DEL_RE, 'del'), ' ruamel.yaml.YAML:\n if modules is None:\n modules = []\n classes_to_register = set()\n for module in modules:\n module_classes = [member[1] for member in inspect.getmembers(module, inspect.isclass)]\n classes_to_register.update(module_classes)\n return register_classes(yaml = yaml, classes = classes_to_register)", "docstring": "Register all classes in the given modules with the YAML object.\n\n This is a simple helper function." }, { "code": "def is_higher_permission(level1, level2):\n return (is_publish_permission(level1) and\n not is_publish_permission(level2) or\n (is_edit_permission(level1) and\n not is_publish_permission(level2) and\n not is_edit_permission(level2)) or\n (is_showon_permission(level1) and\n is_view_permission(level2)))", "docstring": "Return True if the level1 is higher than level2" }, { "code": "def iteryaml(self, *args, **kwargs):\n from rowgenerators.rowpipe.json import VTEncoder\n import yaml\n if 'cls' not in kwargs:\n kwargs['cls'] = VTEncoder\n for s in self.iterstruct:\n yield (yaml.safe_dump(s))", "docstring": "Yields the data structures from iterstruct as YAML strings" }, { "code": "def create_parser():\n parser = argparse.ArgumentParser(description=DESCRIPTION, formatter_class=argparse.RawDescriptionHelpFormatter)\n parser.add_argument('-v', '--verbose', action=\"count\", default=0, help=\"Increase logging level (goes error, warn, info, debug)\")\n parser.add_argument('-l', '--logfile', help=\"The file where we should log all logging messages\")\n parser.add_argument('-i', '--include', action=\"append\", default=[], help=\"Only include the specified loggers\")\n parser.add_argument('-e', '--exclude', action=\"append\", default=[], help=\"Exclude the specified loggers, including all others\")\n parser.add_argument('-q', '--quit', action=\"store_true\", help=\"Do not spawn a shell after executing any commands\")\n parser.add_argument('-t', '--timeout', type=float, help=\"Do not allow this process to run for more than a specified number of seconds.\")\n parser.add_argument('commands', nargs=argparse.REMAINDER, help=\"The command(s) to execute\")\n return parser", "docstring": "Create the argument parser for iotile." }, { "code": "def get(self, eid):\n\t\tdata = self._http_req('connections/%u' % eid)\n\t\tself.debug(0x01, data['decoded'])\n\t\treturn data['decoded']", "docstring": "Returns a dict with the complete record of the entity with the given eID" }, { "code": "def read(self):\n if path.exists(self.filepath):\n with open(self.filepath, 'rb') as infile:\n self.data = yaml.load(\n self.fernet.decrypt(infile.read()))\n else:\n self.data = dict()", "docstring": "Reads and decrypts data from the filesystem" }, { "code": "def _find_matching_expectation(self, args, kwargs):\n for expectation in self._expectations:\n if expectation.satisfy_exact_match(args, kwargs):\n return expectation\n for expectation in self._expectations:\n if expectation.satisfy_custom_matcher(args, kwargs):\n return expectation\n for expectation in self._expectations:\n if expectation.satisfy_any_args_match():\n return expectation", "docstring": "Return a matching expectation.\n\n Returns the first expectation that matches the ones declared. Tries one with specific\n arguments first, then falls back to an expectation that allows arbitrary arguments.\n\n :return: The matching ``Expectation``, if one was found.\n :rtype: Expectation, None" }, { "code": "def profile_update(self, profile):\n if profile.get('install_json') is None:\n print(\n '{}{}Missing install_json parameter for profile {}.'.format(\n c.Style.BRIGHT, c.Fore.YELLOW, profile.get('profile_name')\n )\n )\n self.profile_update_args_v2(profile)\n self.profile_update_args_v3(profile)\n self.profile_update_schema(profile)", "docstring": "Update an existing profile with new parameters or remove deprecated parameters.\n\n Args:\n profile (dict): The dictionary containting the profile settings." }, { "code": "def stop(self) -> None:\n if self._stop and not self._posted_kork:\n self._stop()\n self._stop = None", "docstring": "Stops the analysis as soon as possible." }, { "code": "def _build_implicit_prefetches(\n self,\n model,\n prefetches,\n requirements\n ):\n for source, remainder in six.iteritems(requirements):\n if not remainder or isinstance(remainder, six.string_types):\n continue\n related_field = get_model_field(model, source)\n related_model = get_related_model(related_field)\n queryset = self._build_implicit_queryset(\n related_model,\n remainder\n ) if related_model else None\n prefetches[source] = self._create_prefetch(\n source,\n queryset\n )\n return prefetches", "docstring": "Build a prefetch dictionary based on internal requirements." }, { "code": "def setup_standalone_signals(instance):\n window = instance.get_widget('config-window')\n window.connect('delete-event', Gtk.main_quit)\n button = instance.get_widget('button1')\n button.handler_block_by_func(instance.gtk_widget_destroy)\n button.connect('clicked', Gtk.main_quit)\n return instance", "docstring": "Called when prefs dialog is running in standalone mode. It\n makes the delete event of dialog and click on close button finish\n the application." }, { "code": "def put_acl(Bucket,\n ACL=None,\n AccessControlPolicy=None,\n GrantFullControl=None,\n GrantRead=None,\n GrantReadACP=None,\n GrantWrite=None,\n GrantWriteACP=None,\n region=None, key=None, keyid=None, profile=None):\n try:\n conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)\n kwargs = {}\n if AccessControlPolicy is not None:\n if isinstance(AccessControlPolicy, six.string_types):\n AccessControlPolicy = salt.utils.json.loads(AccessControlPolicy)\n kwargs['AccessControlPolicy'] = AccessControlPolicy\n for arg in ('ACL',\n 'GrantFullControl',\n 'GrantRead', 'GrantReadACP',\n 'GrantWrite', 'GrantWriteACP'):\n if locals()[arg] is not None:\n kwargs[arg] = str(locals()[arg])\n conn.put_bucket_acl(Bucket=Bucket, **kwargs)\n return {'updated': True, 'name': Bucket}\n except ClientError as e:\n return {'updated': False, 'error': __utils__['boto3.get_error'](e)}", "docstring": "Given a valid config, update the ACL for a bucket.\n\n Returns {updated: true} if the ACL was updated and returns\n {updated: False} if the ACL was not updated.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt myminion boto_s3_bucket.put_acl my_bucket 'public' \\\\\n GrantFullControl='emailaddress=example@example.com' \\\\\n GrantRead='uri=\"http://acs.amazonaws.com/groups/global/AllUsers\"' \\\\\n GrantReadACP='emailaddress=\"exampl@example.com\",id=\"2345678909876432\"'" }, { "code": "def do_mkdir(self, path):\n path = path[0]\n self.n.makeDirectory(self.current_path + path)\n self.dirs = self.dir_complete()", "docstring": "create a new directory" }, { "code": "def sg_prod(tensor, opt):\n r\n return tf.reduce_prod(tensor, axis=opt.axis, keep_dims=opt.keep_dims, name=opt.name)", "docstring": "r\"\"\"Computes the product of elements across axis of a tensor.\n\n See `tf.reduce_prod()` in tensorflow.\n\n Args:\n tensor: A `Tensor` (automatically given by chain).\n opt:\n axis : A tuple/list of integers or an integer. The axis to reduce.\n keep_dims: If true, retains reduced dimensions with length 1.\n name: If provided, replace current tensor's name.\n\n Returns:\n A `Tensor`." }, { "code": "def install_pyenv(name, user=None):\n ret = {'name': name, 'result': None, 'comment': '', 'changes': {}}\n if __opts__['test']:\n ret['comment'] = 'pyenv is set to be installed'\n return ret\n return _check_and_install_python(ret, user)", "docstring": "Install pyenv if not installed. Allows you to require pyenv be installed\n prior to installing the plugins. Useful if you want to install pyenv\n plugins via the git or file modules and need them installed before\n installing any rubies.\n\n Use the pyenv.root configuration option to set the path for pyenv if you\n want a system wide install that is not in a user home dir.\n\n user: None\n The user to run pyenv as." }, { "code": "def run_score(self):\n diffs = 0\n lines = 0\n for file in self.files:\n try:\n results = self._check(file)\n except Error as e:\n termcolor.cprint(e.msg, \"yellow\", file=sys.stderr)\n continue\n diffs += results.diffs\n lines += results.lines\n try:\n print(max(1 - diffs / lines, 0.0))\n except ZeroDivisionError:\n print(0.0)", "docstring": "Run checks on self.files, printing raw percentage to stdout." }, { "code": "def not26(func):\n @wraps(func)\n def errfunc(*args, **kwargs):\n raise NotImplementedError\n if hexversion < 0x02070000:\n return errfunc\n else:\n return func", "docstring": "Function decorator for methods not implemented in Python 2.6." }, { "code": "def terminate(self):\n logger.debug('client.terminate() called (state=%s)', self.strstate)\n if self.state == ClientState.WAITING_FOR_RESULT:\n raise ClientStateError('terimate() called while state='+self.strstate)\n if self.state == ClientState.TERMINATING:\n raise ClientStateError('terimate() called while state='+self.strstate)\n elif self.state in ClientState.TerminatedSet:\n assert not self._server_process.is_alive()\n return\n elif self.state == ClientState.READY:\n self._assert_alive()\n self.state = ClientState.TERMINATING\n self._delegate_channel.put(FunctionCallDelegate(_raise_terminate))\n try:\n self._read_result(num_retries=5)\n except ProcessTerminationError as ex:\n pass\n except ChannelError as ex:\n logger.debug('client failed to read sentinel from channel after 5 retries - will terminate anyway')\n self.state = ClientState.TERMINATED_CLEANLY", "docstring": "Stop the server process and change our state to TERMINATING. Only valid if state=READY." }, { "code": "def safe_str_to_class(s):\n lst = s.split(\".\")\n klass = lst[-1]\n mod_list = lst[:-1]\n module = \".\".join(mod_list)\n if not module:\n module = klass\n mod = my_import(module)\n if hasattr(mod, klass):\n return getattr(mod, klass)\n else:\n raise ImportError('')", "docstring": "Helper function to map string class names to module classes." }, { "code": "def reset(self):\n query =\n self.backend.library.database.connection.execute(query)", "docstring": "Drops index table." }, { "code": "def patch(self, request):\n attrs = ('edx_video_id', 'status')\n missing = [attr for attr in attrs if attr not in request.data]\n if missing:\n return Response(\n status=status.HTTP_400_BAD_REQUEST,\n data={'message': u'\"{missing}\" params must be specified.'.format(missing=' and '.join(missing))}\n )\n edx_video_id = request.data['edx_video_id']\n video_status = request.data['status']\n if video_status not in VALID_VIDEO_STATUSES:\n return Response(\n status=status.HTTP_400_BAD_REQUEST,\n data={'message': u'\"{status}\" is not a valid Video status.'.format(status=video_status)}\n )\n try:\n video = Video.objects.get(edx_video_id=edx_video_id)\n video.status = video_status\n video.save()\n response_status = status.HTTP_200_OK\n response_payload = {}\n except Video.DoesNotExist:\n response_status = status.HTTP_400_BAD_REQUEST\n response_payload = {\n 'message': u'Video is not found for specified edx_video_id: {edx_video_id}'.format(\n edx_video_id=edx_video_id\n )\n }\n return Response(status=response_status, data=response_payload)", "docstring": "Update the status of a video." }, { "code": "def resetSession(self, username=None, password=None, verify=True) :\n self.disconnectSession()\n self.session = AikidoSession(username, password, verify)", "docstring": "resets the session" }, { "code": "def list_all():\n ret = []\n if _sd_version() >= 219:\n for line in _machinectl('list-images')['stdout'].splitlines():\n try:\n ret.append(line.split()[0])\n except IndexError:\n continue\n else:\n rootdir = _root()\n try:\n for dirname in os.listdir(rootdir):\n if os.path.isdir(os.path.join(rootdir, dirname)):\n ret.append(dirname)\n except OSError:\n pass\n return ret", "docstring": "Lists all nspawn containers\n\n CLI Example:\n\n .. code-block:: bash\n\n salt myminion nspawn.list_all" }, { "code": "def listDatawraps() :\n\tl = {\"Genomes\" : [], \"SNPs\" : []}\n\tfor f in os.listdir(os.path.join(this_dir, \"bootstrap_data/genomes\")) :\n\t\tif f.find(\".tar.gz\") > -1 :\n\t\t\tl[\"Genomes\"].append(f)\n\tfor f in os.listdir(os.path.join(this_dir, \"bootstrap_data/SNPs\")) :\n\t\tif f.find(\".tar.gz\") > -1 :\n\t\t\tl[\"SNPs\"].append(f)\n\treturn l", "docstring": "Lists all the datawraps pyGeno comes with" }, { "code": "def get_nodedata(self, sort_names=False):\n if not self.Node.n:\n return\n if not self.pflow.solved:\n logger.error('Power flow not solved when getting bus data.')\n return tuple([False] * 7)\n idx = self.Node.idx\n names = self.Node.name\n V = [self.dae.y[x] for x in self.Node.v]\n if sort_names:\n ret = (list(x)\n for x in zip(*sorted(zip(idx, names, V), key=itemgetter(0))))\n else:\n ret = idx, names, V\n return ret", "docstring": "get dc node data from solved power flow" }, { "code": "def add_state(self, state, storage_load=False):\n assert isinstance(state, State)\n while state.state_id == self.state_id or state.state_id in self.states:\n state.change_state_id()\n if state.state_id in self._states.keys():\n raise AttributeError(\"State id %s already exists in the container state\", state.state_id)\n else:\n state.parent = self\n self._states[state.state_id] = state\n return state.state_id", "docstring": "Adds a state to the container state.\n\n :param state: the state that is going to be added\n :param storage_load: True if the state was directly loaded from filesystem\n :return: the state_id of the new state\n :raises exceptions.AttributeError: if state.state_id already exist" }, { "code": "def get_agent_settings():\n ret = dict()\n sorted_types = sorted(_SERVICE_TYPES.items(), key=lambda x: (-x[1], x[0]))\n ret['services'] = list()\n ret['contact'] = (__utils__['reg.read_value'](\n _HKEY, _AGENT_KEY, 'sysContact'))['vdata']\n ret['location'] = (__utils__['reg.read_value'](\n _HKEY, _AGENT_KEY, 'sysLocation'))['vdata']\n current_bitmask = (__utils__['reg.read_value'](\n _HKEY, _AGENT_KEY, 'sysServices'))['vdata']\n if current_bitmask == 0:\n ret['services'].append(sorted_types[-1][0])\n else:\n for service, bitmask in sorted_types:\n if current_bitmask is not None and current_bitmask > 0:\n remaining_bitmask = current_bitmask - bitmask\n if remaining_bitmask >= 0:\n current_bitmask = remaining_bitmask\n ret['services'].append(service)\n else:\n break\n ret['services'] = sorted(ret['services'])\n return ret", "docstring": "Determine the value of the SNMP sysContact, sysLocation, and sysServices\n settings.\n\n Returns:\n dict: A dictionary of the agent settings.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' win_snmp.get_agent_settings" }, { "code": "def namespace_lower(self, namespace):\n return self.namespace(namespace, key_transform=lambda key: key.lower())", "docstring": "Return a copy with only the keys from a given namespace, lower-cased.\n\n The keys in the returned dict will be transformed to lower case after\n filtering, so they can be easily passed as keyword arguments to other\n functions. This is just syntactic sugar for calling\n :meth:`~ConfigLoader.namespace` with\n ``key_transform=lambda key: key.lower()``.\n\n Example::\n\n >>> from configloader import ConfigLoader\n >>> config = ConfigLoader(\n ... MY_APP_SETTING1='a',\n ... EXTERNAL_LIB_SETTING1='b',\n ... EXTERNAL_LIB_SETTING2='c',\n ... )\n >>> config.namespace_lower('EXTERNAL_LIB')\n ConfigLoader({'setting1': 'b', 'setting2': 'c'})\n\n :arg namespace: Common prefix.\n\n :return: New config dict.\n :rtype: :class:`ConfigLoader`" }, { "code": "def _parse_boolean(element_text, state):\n value = None\n lowered_text = element_text.lower()\n if lowered_text == 'true':\n value = True\n elif lowered_text == 'false':\n value = False\n else:\n state.raise_error(InvalidPrimitiveValue, 'Invalid boolean value \"{}\"'.format(element_text))\n return value", "docstring": "Parse the raw XML string as a boolean value." }, { "code": "def build_submit_description(executable, output, error, user_log, query_params):\n all_query_params = DEFAULT_QUERY_CLASSAD.copy()\n all_query_params.update(query_params)\n submit_description = []\n for key, value in all_query_params.items():\n submit_description.append('%s = %s' % (key, value))\n submit_description.append('executable = ' + executable)\n submit_description.append('output = ' + output)\n submit_description.append('error = ' + error)\n submit_description.append('log = ' + user_log)\n submit_description.append('queue')\n return '\\n'.join(submit_description)", "docstring": "Build up the contents of a condor submit description file.\n\n >>> submit_args = dict(executable='/path/to/script', output='o', error='e', user_log='ul')\n >>> submit_args['query_params'] = dict()\n >>> default_description = build_submit_description(**submit_args)\n >>> assert 'executable = /path/to/script' in default_description\n >>> assert 'output = o' in default_description\n >>> assert 'error = e' in default_description\n >>> assert 'queue' in default_description\n >>> assert 'universe = vanilla' in default_description\n >>> assert 'universe = standard' not in default_description\n >>> submit_args['query_params'] = dict(universe='standard')\n >>> std_description = build_submit_description(**submit_args)\n >>> assert 'universe = vanilla' not in std_description\n >>> assert 'universe = standard' in std_description" }, { "code": "def run(self, n_iter=-1, bg=False):\n if n_iter == -1:\n if not self.eval_at:\n raise ValueError('Set n_iter or define evaluate_at.')\n n_iter = self.eval_at[-1] + 1\n self._running.set()\n if bg:\n self._t = threading.Thread(target=lambda: self._run(n_iter))\n self._t.start()\n else:\n self._run(n_iter)", "docstring": "Run the experiment.\n\n :param int n_iter: Number of run iterations, by default will run until the last evaluation step.\n :param bool bg: whether to run in background (using a Thread)" }, { "code": "def create_node(self, *args, **kwargs):\n with (yield from self._iou_id_lock):\n application_id = get_next_application_id(self.nodes)\n node = yield from super().create_node(*args, application_id=application_id, **kwargs)\n return node", "docstring": "Creates a new IOU VM.\n\n :returns: IOUVM instance" }, { "code": "def __eliminate_unused_constraits (self, objects):\n result = []\n for c in self.constraints_:\n if c [0] in objects and c [1] in objects:\n result.append (c)\n return result", "docstring": "Eliminate constraints which mention objects not in 'objects'.\n In graph-theory terms, this is finding subgraph induced by\n ordered vertices." }, { "code": "def create_queue_service(self):\n try:\n from azure.storage.queue.queueservice import QueueService\n return QueueService(self.account_name, self.account_key,\n sas_token=self.sas_token,\n is_emulated=self.is_emulated)\n except ImportError:\n raise Exception('The package azure-storage-queue is required. '\n + 'Please install it using \"pip install azure-storage-queue\"')", "docstring": "Creates a QueueService object with the settings specified in the \n CloudStorageAccount.\n\n :return: A service object.\n :rtype: :class:`~azure.storage.queue.queueservice.QueueService`" }, { "code": "def last_written_resolver(riak_object):\n riak_object.siblings = [max(riak_object.siblings,\n key=lambda x: x.last_modified), ]", "docstring": "A conflict-resolution function that resolves by selecting the most\n recently-modified sibling by timestamp.\n\n :param riak_object: an object-in-conflict that will be resolved\n :type riak_object: :class:`RiakObject `" }, { "code": "def get_key_by_job_id(cls, mapreduce_id):\n return db.Key.from_path(cls.kind(), str(mapreduce_id))", "docstring": "Retrieves the Key for a Job.\n\n Args:\n mapreduce_id: The job to retrieve.\n\n Returns:\n Datastore Key that can be used to fetch the MapreduceState." }, { "code": "def _add_dispatcher(self, path_regex, dispatch_function):\n self._dispatchers.append((re.compile(path_regex), dispatch_function))", "docstring": "Add a request path and dispatch handler.\n\n Args:\n path_regex: A string regex, the path to match against incoming requests.\n dispatch_function: The function to call for these requests. The function\n should take (request, start_response) as arguments and\n return the contents of the response body." }, { "code": "def preprocess(cls, cat):\n if isinstance(cat, str):\n cat = intake.open_catalog(cat)\n return cat", "docstring": "Function to run on each cat input" }, { "code": "def execution_timer(self, *path):\n start = time.time()\n try:\n yield\n finally:\n self.record_timing(max(start, time.time()) - start, *path)", "docstring": "Record the time it takes to perform an arbitrary code block.\n\n :param path: elements of the metric path to record\n\n This method returns a context manager that records the amount\n of time spent inside of the context and submits a timing metric\n to the specified `path` using (:meth:`record_timing`)." }, { "code": "def inspect_swarm(self):\n url = self._url('/swarm')\n return self._result(self._get(url), True)", "docstring": "Retrieve low-level information about the current swarm.\n\n Returns:\n A dictionary containing data about the swarm.\n\n Raises:\n :py:class:`docker.errors.APIError`\n If the server returns an error." }, { "code": "def _parse_queue_list(list_output):\n queues = dict((q.split('/')[-1], q) for q in list_output['stdout'])\n return queues", "docstring": "Parse the queue to get a dict of name -> URL" }, { "code": "def pickle_from_param(elem, name):\n\treturn pickle.loads(str(get_pyvalue(elem, u\"pickle:%s\" % name)))", "docstring": "Retrieve a pickled Python object from the document tree rooted at\n\telem." }, { "code": "def field_for(self, field_id):\n for field in self.fields:\n if field.id == field_id:\n return field\n return None", "docstring": "Fetches the field for the given Field ID.\n\n :param field_id: ID for Field to fetch.\n :return: :class:`ContentTypeField ` object.\n :rtype: contentful.ContentTypeField" }, { "code": "def search_schema_path(self, index, **options):\n if not self.yz_wm_schema:\n raise RiakError(\"Yokozuna search is unsupported by this Riak node\")\n return mkpath(self.yz_wm_schema, \"schema\", quote_plus(index),\n **options)", "docstring": "Builds a Yokozuna search Solr schema URL.\n\n :param index: a name of a yz solr schema\n :type index: string\n :param options: optional list of additional arguments\n :type index: dict\n :rtype URL string" }, { "code": "def _download_movielens(dest_path):\n url = 'http://files.grouplens.org/datasets/movielens/ml-100k.zip'\n req = requests.get(url, stream=True)\n with open(dest_path, 'wb') as fd:\n for chunk in req.iter_content():\n fd.write(chunk)", "docstring": "Download the dataset." }, { "code": "def DbGetDeviceAliasList(self, argin):\n self._log.debug(\"In DbGetDeviceAliasList()\")\n if not argin:\n argin = \"%\"\n else:\n argin = replace_wildcard(argin)\n return self.db.get_device_alias_list(argin)", "docstring": "Get device alias name with a specific filter\n\n :param argin: The filter\n :type: tango.DevString\n :return: Device alias list\n :rtype: tango.DevVarStringArray" }, { "code": "def frame_size(self):\n if self.sample_type == SampleType.S16NativeEndian:\n return self.sample_size * self.channels\n else:\n raise ValueError('Unknown sample type: %d', self.sample_type)", "docstring": "The byte size of a single frame of this format." }, { "code": "def load_library(self):\n \"loads configuration options\"\n try:\n filename = self.environment.get_template('chartkick.json').filename\n except TemplateNotFound:\n return {}\n else:\n options = Options()\n options.load(filename)\n return options", "docstring": "loads configuration options" }, { "code": "def rename(df, **kwargs):\n return df.rename(columns={v: k for k, v in kwargs.items()})", "docstring": "Renames columns, where keyword argument values are the current names\n of columns and keys are the new names.\n\n Args:\n df (:obj:`pandas.DataFrame`): DataFrame passed in via `>>` pipe.\n\n Kwargs:\n **kwargs: key:value pairs where keys are new names for columns and\n values are current names of columns." }, { "code": "def restart(uuid, **kwargs):\n from .worker_engine import restart_worker\n return text_type(restart_worker(uuid, **kwargs).uuid)", "docstring": "Restart the workflow from a given workflow engine UUID." }, { "code": "def unload_fixture(apps, schema_editor):\n \"Brutally deleting all entries for this model...\"\n MyModel = apps.get_model(\"blog\", \"Post\")\n MyModel.objects.all().delete()", "docstring": "Brutally deleting all entries for this model..." }, { "code": "def _hasattr(self, fieldname):\n special = 'history', 'raw'\n return (fieldname in special or \n fieldname in self._defn.fieldmap or\n fieldname in self._defn.derivationmap)", "docstring": "Returns True if this packet contains fieldname, False otherwise." }, { "code": "def list_rbac_policies(self, retrieve_all=True, **_params):\n return self.list('rbac_policies', self.rbac_policies_path,\n retrieve_all, **_params)", "docstring": "Fetch a list of all RBAC policies for a project." }, { "code": "def submit(self):\n self._newflg = False\n ret = list()\n for buf in self._buffer.values():\n buf = copy.deepcopy(buf)\n if self._fdpext:\n buf['fpout'] = f\"{self._fproot}/{buf['label']}.{self._fdpext}\"\n else:\n del buf['fpout']\n buf['index'] = tuple(buf['index'])\n ret.append(Info(buf))\n ret += self._stream\n return tuple(ret)", "docstring": "Submit traced TCP flows." }, { "code": "def logout(request):\n user = request.user\n serializer = LogoutSerializer(data=request.data)\n serializer.is_valid(raise_exception=True)\n data = serializer.validated_data\n if should_authenticate_session():\n auth.logout(request)\n if should_retrieve_token() and data['revoke_token']:\n try:\n user.auth_token.delete()\n except Token.DoesNotExist:\n raise BadRequest('Cannot remove non-existent token')\n return get_ok_response('Logout successful')", "docstring": "Logs out the user. returns an error if the user is not\n authenticated." }, { "code": "def init(args=None, lib='standard'):\n if args is None:\n args = sys.argv\n _loadlib(lib)\n arr = (ctypes.c_char_p * len(args))()\n arr[:] = args\n _LIB.RabitInit(len(args), arr)", "docstring": "Intialize the rabit module, call this once before using anything.\n\n Parameters\n ----------\n args: list of str, optional\n The list of arguments used to initialized the rabit\n usually you need to pass in sys.argv.\n Defaults to sys.argv when it is None.\n lib: {'standard', 'mock', 'mpi'}\n Type of library we want to load" }, { "code": "def bestDescription(self, prefLanguage=\"en\"):\n test_preds = [rdflib.RDFS.comment, rdflib.namespace.DCTERMS.description, rdflib.namespace.DC.description,\n rdflib.namespace.SKOS.definition]\n for pred in test_preds:\n test = self.getValuesForProperty(pred)\n if test:\n return addQuotes(firstEnglishStringInList(test))\n return \"\"", "docstring": "facility for extrating the best available description for an entity\n\n ..This checks RFDS.label, SKOS.prefLabel and finally the qname local component" }, { "code": "def handle_abort(self, obj):\n async_to_sync(consumer.send_event)({\n WorkerProtocol.COMMAND: WorkerProtocol.ABORT,\n WorkerProtocol.DATA_ID: obj[ExecutorProtocol.DATA_ID],\n WorkerProtocol.FINISH_COMMUNICATE_EXTRA: {\n 'executor': getattr(settings, 'FLOW_EXECUTOR', {}).get('NAME', 'resolwe.flow.executors.local'),\n },\n })", "docstring": "Handle an incoming ``Data`` abort processing request.\n\n .. IMPORTANT::\n\n This only makes manager's state consistent and doesn't\n affect Data object in any way. Any changes to the Data\n must be applied over ``handle_update`` method.\n\n :param obj: The Channels message object. Command object format:\n\n .. code-block:: none\n\n {\n 'command': 'abort',\n 'data_id': [id of the :class:`~resolwe.flow.models.Data` object\n this command was triggered by],\n }" }, { "code": "def get_group_line(self, data):\n idx = -1\n for key in self.groups:\n i = self.get_group_key_line(data, key)\n if (i < idx and i != -1) or idx == -1:\n idx = i\n return idx", "docstring": "Get the next group-style key's line.\n\n :param data: the data to proceed\n :returns: the line number" }, { "code": "def add_to_replication_queue(source_node_urn, sysmeta_pyxb):\n replica_info_model = d1_gmn.app.models.replica_info(\n status_str='queued', source_node_urn=source_node_urn\n )\n local_replica_model = d1_gmn.app.models.local_replica(\n pid=d1_common.xml.get_req_val(sysmeta_pyxb.identifier),\n replica_info_model=replica_info_model,\n )\n d1_gmn.app.models.replication_queue(\n local_replica_model=local_replica_model, size=sysmeta_pyxb.size\n )", "docstring": "Add a replication request issued by a CN to a queue that is processed\n asynchronously.\n\n Preconditions:\n - sysmeta_pyxb.identifier is verified to be available for create. E.g., with\n d1_gmn.app.views.is_valid_pid_for_create(pid).\n\n Postconditions:\n - The database is set up to track a new replica, with initial status, \"queued\".\n - The PID provided in the sysmeta_pyxb is reserved for the replica." }, { "code": "def start_circle_left(self, radius_m, velocity=VELOCITY):\n circumference = 2 * radius_m * math.pi\n rate = 360.0 * velocity / circumference\n self._set_vel_setpoint(velocity, 0.0, 0.0, -rate)", "docstring": "Start a circular motion to the left. This function returns immediately.\n\n :param radius_m: The radius of the circle (meters)\n :param velocity: The velocity of the motion (meters/second)\n :return:" }, { "code": "def get_name_from_name_hash128( self, name ):\n cur = self.db.cursor()\n name = namedb_get_name_from_name_hash128( cur, name, self.lastblock )\n return name", "docstring": "Get the name from a name hash" }, { "code": "def routers_removed_from_hosting_device(self, context, router_ids,\n hosting_device):\n self._agent_notification_bulk(\n context, 'router_removed_from_hosting_device', router_ids,\n hosting_device, operation=None)", "docstring": "Notify cfg agent that routers have been removed from hosting device.\n @param: context - information about tenant, user etc\n @param: router-ids - list of ids\n @param: hosting_device - device hosting the routers" }, { "code": "def cudnnGetConvolution2dForwardOutputDim(convDesc, inputTensorDesc, wDesc):\n n = ctypes.c_int()\n c = ctypes.c_int()\n h = ctypes.c_int()\n w = ctypes.c_int()\n status = _libcudnn.cudnnGetConvolution2dForwardOutputDim(convDesc, inputTensorDesc,\n wDesc, ctypes.byref(n),\n ctypes.byref(c), ctypes.byref(h),\n ctypes.byref(w))\n cudnnCheckStatus(status)\n return n.value, c.value, h.value, w.value", "docstring": "Return the dimensions of the output tensor given a convolution descriptor.\n\n This function returns the dimensions of the resulting 4D tensor of a 2D\n convolution, given the convolution descriptor, the input tensor descriptor and\n the filter descriptor. This function can help to setup the output tensor and allocate\n the proper amount of memory prior to launching the actual convolution.\n\n Parameters\n ----------\n convDesc : cudnnConvolutionDescriptor\n Handle to a previously created convolution descriptor.\n inputTensorDesc: cudnnTensorDescriptor\n Handle to a previously initialized tensor descriptor.\n wDesc: cudnnFilterDescriptor\n Handle to a previously initialized filter descriptor.\n\n Returns\n -------\n n : int\n Number of output images.\n c : int\n Number of output feature maps per image.\n h : int\n Height of each output feature map.\n w : int\n Width of each output feature map." }, { "code": "def can_allow_multiple_input_shapes(spec):\n try:\n layers = _get_nn_layers(spec)\n except:\n raise Exception('Unable to verify that this model contains a neural network.')\n try:\n shaper = NeuralNetworkShaper(spec, False)\n except:\n raise Exception('Unable to compute shapes for this neural network.')\n inputs = _get_input_names(spec)\n for name in inputs:\n shape_dict = shaper.shape(name)\n shape = NeuralNetworkMultiArrayShapeRange(shape_dict)\n if (shape.isFlexible()):\n return True\n return False", "docstring": "Examines a model specification and determines if it can compute results for more than one output shape.\n\n :param spec: MLModel\n The protobuf specification of the model.\n\n :return: Bool\n Returns True if the model can allow multiple input shapes, False otherwise." }, { "code": "def map_copy(source: tcod.map.Map, dest: tcod.map.Map) -> None:\n if source.width != dest.width or source.height != dest.height:\n dest.__init__(\n source.width, source.height, source._order\n )\n dest._Map__buffer[:] = source._Map__buffer[:]", "docstring": "Copy map data from `source` to `dest`.\n\n .. deprecated:: 4.5\n Use Python's copy module, or see :any:`tcod.map.Map` and assign between\n array attributes manually." }, { "code": "def maybe_download_and_extract():\n dest_directory = \"/tmp/cifar\"\n if not os.path.exists(dest_directory):\n os.makedirs(dest_directory)\n filename = DATA_URL.split('/')[-1]\n filepath = os.path.join(dest_directory, filename)\n if not os.path.exists(filepath):\n def _progress(count, block_size, total_size):\n sys.stdout.write('\\r>> Downloading %s %.1f%%' % (filename,\n float(count * block_size) / float(total_size) * 100.0))\n sys.stdout.flush()\n filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)\n print()\n statinfo = os.stat(filepath)\n print('Successfully downloaded', filename, statinfo.st_size, 'bytes.')\n tarfile.open(filepath, 'r:gz').extractall(dest_directory)", "docstring": "Download and extract the tarball from Alex's website." }, { "code": "def remove(self, game_object: Hashable) -> None:\n self.all.remove(game_object)\n for kind in type(game_object).mro():\n self.kinds[kind].remove(game_object)\n for s in self.tags.values():\n s.discard(game_object)", "docstring": "Remove the given object from the container.\n\n game_object: A hashable contained by container.\n\n Example:\n container.remove(myObject)" }, { "code": "def _traverse_relationship_objs(self, rel2src2dsts, goobj_child, goids_seen):\n child_id = goobj_child.id\n goids_seen.add(child_id)\n for goid_altid in goobj_child.alt_ids:\n goids_seen.add(goid_altid)\n for reltype, recs in goobj_child.relationship.items():\n if reltype in self.relationships:\n for relationship_obj in recs:\n relationship_id = relationship_obj.id\n rel2src2dsts[reltype][relationship_id].add(child_id)\n if relationship_id not in goids_seen:\n self._traverse_relationship_objs(rel2src2dsts, relationship_obj, goids_seen)", "docstring": "Traverse from source GO up relationships." }, { "code": "def list_styles(self):\n known = sorted(self.defaults.known_styles)\n if not known:\n err_exit('No styles', 0)\n for style in known:\n if style == self.defaults.default_style:\n print(style, '(default)')\n else:\n print(style)\n sys.exit(0)", "docstring": "Print available styles and exit." }, { "code": "def tail(ctx):\n click.echo('tailing logs')\n for e in ctx.tail()[-10:]:\n ts = datetime.utcfromtimestamp(e['timestamp'] // 1000).isoformat()\n click.echo(\"{}: {}\".format(ts, e['message']))\n click.echo('done')", "docstring": "Show the last 10 lines of the log file" }, { "code": "def remove_user(self, workspace, params={}, **options): \n path = \"/workspaces/%s/removeUser\" % (workspace)\n return self.client.post(path, params, **options)", "docstring": "The user making this call must be an admin in the workspace.\n Returns an empty data record.\n\n Parameters\n ----------\n workspace : {Id} The workspace or organization to invite the user to.\n [data] : {Object} Data for the request\n - user : {String} An identifier for the user. Can be one of an email address,\n the globally unique identifier for the user, or the keyword `me`\n to indicate the current user making the request." }, { "code": "def _get_order_by(self, request):\n attr = request.params.get('sort', request.params.get('order_by'))\n if attr is None or not hasattr(self.mapped_class, attr):\n return None\n if request.params.get('dir', '').upper() == 'DESC':\n return desc(getattr(self.mapped_class, attr))\n else:\n return asc(getattr(self.mapped_class, attr))", "docstring": "Return an SA order_by" }, { "code": "def filter_data(data, filter_dict):\n for key, match_string in filter_dict.items():\n if key not in data:\n logger.warning(\"{0} doesn't match a top level key\".format(key))\n continue\n values = data[key]\n matcher = re.compile(match_string)\n if isinstance(values, list):\n values = [v for v in values if matcher.search(v)]\n elif isinstance(values, dict):\n values = dict((k, v) for k, v in values.items() if matcher.search(k))\n else:\n raise MiuraException(\"cannot filter a {0}\".format(type(values)))\n data[key] = values", "docstring": "filter a data dictionary for values only matching the filter" }, { "code": "def _make_callsites(self, stack_pointer_tracker=None):\n rd = self.project.analyses.ReachingDefinitions(func=self.function, func_graph=self.graph, observe_all=True)\n for key in self._blocks:\n block = self._blocks[key]\n csm = self.project.analyses.AILCallSiteMaker(block, reaching_definitions=rd)\n if csm.result_block:\n ail_block = csm.result_block\n simp = self.project.analyses.AILBlockSimplifier(ail_block, stack_pointer_tracker=stack_pointer_tracker)\n self._blocks[key] = simp.result_block\n self._update_graph()", "docstring": "Simplify all function call statements.\n\n :return: None" }, { "code": "def unbound_dimensions(streams, kdims, no_duplicates=True):\n params = stream_parameters(streams, no_duplicates)\n return [d for d in kdims if d not in params]", "docstring": "Return a list of dimensions that have not been associated with\n any streams." }, { "code": "def list_folder(cls, session, mailbox, folder):\n return cls(\n '/mailboxes/%d/folders/%s/conversations.json' % (\n mailbox.id, folder.id,\n ),\n session=session,\n )", "docstring": "Return conversations in a specific folder of a mailbox.\n\n Args:\n session (requests.sessions.Session): Authenticated session.\n mailbox (helpscout.models.Mailbox): Mailbox that folder is in.\n folder (helpscout.models.Folder): Folder to list.\n\n Returns:\n RequestPaginator(output_type=helpscout.models.Conversation):\n Conversations iterator." }, { "code": "def update_properties(self, properties, email_to_addresses=None,\n email_cc_addresses=None, email_insert=None):\n volreq_obj = copy.deepcopy(properties)\n volreq_obj['operation'] = 'modify'\n volreq_obj['element-uri'] = self.uri\n body = {\n 'storage-volumes': [volreq_obj],\n }\n if email_to_addresses:\n body['email-to-addresses'] = email_to_addresses\n if email_cc_addresses:\n body['email-cc-addresses'] = email_cc_addresses\n if email_insert:\n body['email-insert'] = email_insert\n else:\n if email_cc_addresses:\n raise ValueError(\"email_cc_addresses must not be specified if \"\n \"there is no email_to_addresses: %r\" %\n email_cc_addresses)\n if email_insert:\n raise ValueError(\"email_insert must not be specified if \"\n \"there is no email_to_addresses: %r\" %\n email_insert)\n self.manager.session.post(\n self.manager.storage_group.uri + '/operations/modify',\n body=body)\n self.properties.update(copy.deepcopy(properties))", "docstring": "Update writeable properties of this storage volume on the HMC, and\n optionally send emails to storage administrators requesting\n modification of the storage volume on the storage subsystem and of any\n resources related to the storage volume.\n\n This method performs the \"Modify Storage Group Properties\" operation,\n requesting modification of the volume.\n\n Authorization requirements:\n\n * Object-access permission to the storage group owning this storage\n volume.\n * Task permission to the \"Configure Storage - System Programmer\" task.\n\n Parameters:\n\n properties (dict): New property values for the volume.\n Allowable properties are the fields defined in the\n \"storage-volume-request-info\" nested object for the \"modify\"\n operation. That nested object is described in section \"Request body\n contents\" for operation \"Modify Storage Group Properties\" in the\n :term:`HMC API` book.\n\n The properties provided in this parameter will be copied and then\n amended with the `operation=\"modify\"` and `element-uri` properties,\n and then used as a single array item for the `storage-volumes`\n field in the request body of the \"Modify Storage Group Properties\"\n operation.\n\n email_to_addresses (:term:`iterable` of :term:`string`): Email\n addresses of one or more storage administrator to be notified.\n If `None` or empty, no email will be sent.\n\n email_cc_addresses (:term:`iterable` of :term:`string`): Email\n addresses of one or more storage administrator to be copied\n on the notification email.\n If `None` or empty, nobody will be copied on the email.\n Must be `None` or empty if `email_to_addresses` is `None` or empty.\n\n email_insert (:term:`string`): Additional text to be inserted in the\n notification email.\n The text can include HTML formatting tags.\n If `None`, no additional text will be inserted.\n Must be `None` or empty if `email_to_addresses` is `None` or empty.\n\n Raises:\n\n :exc:`~zhmcclient.HTTPError`\n :exc:`~zhmcclient.ParseError`\n :exc:`~zhmcclient.AuthError`\n :exc:`~zhmcclient.ConnectionError`" }, { "code": "def extractSurface(image, radius=0.5):\n fe = vtk.vtkExtractSurface()\n fe.SetInputData(image)\n fe.SetRadius(radius)\n fe.Update()\n return Actor(fe.GetOutput())", "docstring": "``vtkExtractSurface`` filter. Input is a ``vtkImageData``.\n Generate zero-crossing isosurface from truncated signed distance volume." }, { "code": "def replay_sync(self, live=False):\n 'Replay all commands in log.'\n self.cursorRowIndex = 0\n CommandLog.currentReplay = self\n with Progress(total=len(self.rows)) as prog:\n while self.cursorRowIndex < len(self.rows):\n if CommandLog.currentReplay is None:\n status('replay canceled')\n return\n vd().statuses.clear()\n try:\n if self.replayOne(self.cursorRow):\n self.cancel()\n return\n except Exception as e:\n self.cancel()\n exceptionCaught(e)\n status('replay canceled')\n return\n self.cursorRowIndex += 1\n prog.addProgress(1)\n sync(1 if live else 0)\n while not self.delay():\n pass\n status('replay complete')\n CommandLog.currentReplay = None", "docstring": "Replay all commands in log." }, { "code": "def _kill_process(proc):\n try:\n proc.kill()\n except AccessDenied:\n logs.debug(u'Rerun: process PID {} ({}) could not be terminated'.format(\n proc.pid, proc.exe()))", "docstring": "Tries to kill the process otherwise just logs a debug message, the\n process will be killed when thefuck terminates.\n\n :type proc: Process" }, { "code": "def skip_connection_distance(a, b):\n if a[2] != b[2]:\n return 1.0\n len_a = abs(a[1] - a[0])\n len_b = abs(b[1] - b[0])\n return (abs(a[0] - b[0]) + abs(len_a - len_b)) / (max(a[0], b[0]) + max(len_a, len_b))", "docstring": "The distance between two skip-connections." }, { "code": "def get_channel_comment(self, name=None, group=None, index=None):\n gp_nr, ch_nr = self._validate_channel_selection(name, group, index)\n grp = self.groups[gp_nr]\n channel = grp.channels[ch_nr]\n return extract_cncomment_xml(channel.comment)", "docstring": "Gets channel comment.\n\n Channel can be specified in two ways:\n\n * using the first positional argument *name*\n\n * if there are multiple occurrences for this channel then the\n *group* and *index* arguments can be used to select a specific\n group.\n * if there are multiple occurrences for this channel and either the\n *group* or *index* arguments is None then a warning is issued\n\n * using the group number (keyword argument *group*) and the channel\n number (keyword argument *index*). Use *info* method for group and\n channel numbers\n\n\n If the *raster* keyword argument is not *None* the output is\n interpolated accordingly.\n\n Parameters\n ----------\n name : string\n name of channel\n group : int\n 0-based group index\n index : int\n 0-based channel index\n\n Returns\n -------\n comment : str\n found channel comment" }, { "code": "def check_driver_dependencies(driver, dependencies):\n ret = True\n for key, value in six.iteritems(dependencies):\n if value is False:\n log.warning(\n \"Missing dependency: '%s'. The %s driver requires \"\n \"'%s' to be installed.\", key, driver, key\n )\n ret = False\n return ret", "docstring": "Check if the driver's dependencies are available.\n\n .. versionadded:: 2015.8.0\n\n driver\n The name of the driver.\n\n dependencies\n The dictionary of dependencies to check." }, { "code": "def page(self, category=values.unset, start_date=values.unset,\n end_date=values.unset, include_subaccounts=values.unset,\n page_token=values.unset, page_number=values.unset,\n page_size=values.unset):\n params = values.of({\n 'Category': category,\n 'StartDate': serialize.iso8601_date(start_date),\n 'EndDate': serialize.iso8601_date(end_date),\n 'IncludeSubaccounts': include_subaccounts,\n 'PageToken': page_token,\n 'Page': page_number,\n 'PageSize': page_size,\n })\n response = self._version.page(\n 'GET',\n self._uri,\n params=params,\n )\n return DailyPage(self._version, response, self._solution)", "docstring": "Retrieve a single page of DailyInstance records from the API.\n Request is executed immediately\n\n :param DailyInstance.Category category: The usage category of the UsageRecord resources to read\n :param date start_date: Only include usage that has occurred on or after this date\n :param date end_date: Only include usage that occurred on or before this date\n :param bool include_subaccounts: Whether to include usage from the master account and all its subaccounts\n :param str page_token: PageToken provided by the API\n :param int page_number: Page Number, this value is simply for client state\n :param int page_size: Number of records to return, defaults to 50\n\n :returns: Page of DailyInstance\n :rtype: twilio.rest.api.v2010.account.usage.record.daily.DailyPage" }, { "code": "def _function_add_call_edge(self, addr, src_node, function_addr, syscall=False, stmt_idx=None, ins_addr=None):\n try:\n if src_node is None:\n self.kb.functions._add_node(function_addr, addr, syscall=syscall)\n else:\n src_snippet = self._to_snippet(cfg_node=src_node)\n return_to_outside = False\n ret_snippet = None\n self.kb.functions._add_call_to(function_addr, src_snippet, addr, ret_snippet, syscall=syscall,\n stmt_idx=stmt_idx, ins_addr=ins_addr,\n return_to_outside=return_to_outside,\n )\n return True\n except (SimMemoryError, SimEngineError):\n return False", "docstring": "Add a call edge to the function transition map.\n\n :param int addr: Address that is being called (callee).\n :param CFGNode src_node: The source CFG node (caller).\n :param int ret_addr: Address that returns to (in case the function returns).\n :param int function_addr: Function address..\n :param bool syscall: If this is a call to a syscall or not.\n :param int or str stmt_idx: Statement ID of this call.\n :param int or None ins_addr: Instruction address of this call.\n :return: True if the edge is added. False if any exception occurred.\n :rtype: bool" }, { "code": "def _max_args(self, f):\n if f.func_defaults is None:\n return f.func_code.co_argcount\n return f.func_code.co_argcount + len(f.func_defaults)", "docstring": "Returns maximum number of arguments accepted by given function." }, { "code": "def close(self):\n if isinstance(self._session, requests.Session):\n self._session.close()", "docstring": "Close http session." }, { "code": "def connect_float_text(instance, prop, widget, fmt=\"{:g}\"):\n if callable(fmt):\n format_func = fmt\n else:\n def format_func(x):\n return fmt.format(x)\n def update_prop():\n val = widget.text()\n try:\n setattr(instance, prop, float(val))\n except ValueError:\n setattr(instance, prop, 0)\n def update_widget(val):\n if val is None:\n val = 0.\n widget.setText(format_func(val))\n add_callback(instance, prop, update_widget)\n try:\n widget.editingFinished.connect(update_prop)\n except AttributeError:\n pass\n update_widget(getattr(instance, prop))", "docstring": "Connect a numerical callback property with a Qt widget containing text.\n\n Parameters\n ----------\n instance : object\n The class instance that the callback property is attached to\n prop : str\n The name of the callback property\n widget : QtWidget\n The Qt widget to connect. This should implement the ``setText`` and\n ``text`` methods as well optionally the ``editingFinished`` signal.\n fmt : str or func\n This should be either a format string (in the ``{}`` notation), or a\n function that takes a number and returns a string." }, { "code": "def get_instructions(self):\n tmp_ins = []\n idx = 0\n for i in self.method.get_instructions():\n if idx >= self.start and idx < self.end:\n tmp_ins.append(i)\n idx += i.get_length()\n return tmp_ins", "docstring": "Get all instructions from a basic block.\n\n :rtype: Return all instructions in the current basic block" }, { "code": "def distance_to_angle(distance, units='metric'):\n if units in ('km', 'metric'):\n pass\n elif units in ('sm', 'imperial', 'US customary'):\n distance *= STATUTE_MILE\n elif units in ('nm', 'nautical'):\n distance *= NAUTICAL_MILE\n else:\n raise ValueError('Unknown units type %r' % units)\n return math.degrees(distance / BODY_RADIUS)", "docstring": "Convert a distance in to an angle along a great circle.\n\n Args:\n distance (float): Distance to convert to degrees\n units (str): Unit type to be used for distances\n\n Returns:\n float: Angle in degrees\n\n Raises:\n ValueError: Unknown value for ``units``" }, { "code": "def select_by_key(self, key):\n self._selected_key = None\n self._selected_item = None\n for item in self.children.values():\n item.attributes['selected'] = False\n if key in self.children:\n self.children[key].attributes['selected'] = True\n self._selected_key = key\n self._selected_item = self.children[key]", "docstring": "Selects an item by its key.\n\n Args:\n key (str): The unique string identifier of the item that have to be selected." }, { "code": "def truepath_relative(path, otherpath=None):\n if otherpath is None:\n otherpath = os.getcwd()\n otherpath = truepath(otherpath)\n path_ = normpath(relpath(path, otherpath))\n return path_", "docstring": "Normalizes and returns absolute path with so specs\n\n Args:\n path (str): path to file or directory\n otherpath (None): (default = None)\n\n Returns:\n str: path_\n\n CommandLine:\n python -m utool.util_path --exec-truepath_relative --show\n\n Example:\n >>> # ENABLE_DOCTEST\n >>> from utool.util_path import * # NOQA\n >>> import utool as ut\n >>> path = 'C:/foobar/foobiz'\n >>> otherpath = 'C:/foobar'\n >>> path_ = truepath_relative(path, otherpath)\n >>> result = ('path_ = %s' % (ut.repr2(path_),))\n >>> print(result)\n path_ = 'foobiz'" }, { "code": "def wrap(self, text, **kwargs):\n pilcrow = re.compile(r'(\\n\\s*\\n)', re.MULTILINE)\n list_prefix = re.compile(r'\\s*(?:\\w|[0-9]+)[\\.\\)]\\s+')\n paragraphs = pilcrow.split(text)\n wrapped_lines = []\n for paragraph in paragraphs:\n if paragraph.isspace():\n wrapped_lines.append('')\n else:\n wrapper = textwrap.TextWrapper(**vars(self))\n list_item = re.match(list_prefix, paragraph)\n if list_item:\n wrapper.subsequent_indent += ' ' * len(list_item.group(0))\n wrapped_lines.extend(wrapper.wrap(paragraph))\n return wrapped_lines", "docstring": "Wraps each paragraph in ``text`` individually.\n\n Parameters\n ----------\n text : str\n\n Returns\n -------\n str\n Single string containing the wrapped paragraphs." }, { "code": "def Reynolds_valve(nu, Q, D1, FL, Fd, C):\n r\n return N4*Fd*Q/nu/(C*FL)**0.5*(FL**2*C**2/(N2*D1**4) + 1)**0.25", "docstring": "r'''Calculates Reynolds number of a control valve for a liquid or gas\n flowing through it at a specified Q, for a specified D1, FL, Fd, C, and\n with kinematic viscosity `nu` according to IEC 60534 calculations.\n\n .. math::\n Re_v = \\frac{N_4 F_d Q}{\\nu \\sqrt{C F_L}}\\left(\\frac{F_L^2 C^2}\n {N_2D^4} +1\\right)^{1/4}\n\n Parameters\n ----------\n nu : float\n Kinematic viscosity, [m^2/s]\n Q : float\n Volumetric flow rate of the fluid [m^3/s]\n D1 : float\n Diameter of the pipe before the valve [m]\n FL : float, optional\n Liquid pressure recovery factor of a control valve without attached \n fittings []\n Fd : float\n Valve style modifier [-]\n C : float\n Metric Kv valve flow coefficient (flow rate of water at a pressure drop \n of 1 bar) [m^3/hr]\n\n Returns\n -------\n Rev : float\n Valve reynolds number [-]\n\n Examples\n --------\n >>> Reynolds_valve(3.26e-07, 360, 150.0, 0.9, 0.46, 165)\n 2966984.7525455453\n\n References\n ----------\n .. [1] IEC 60534-2-1 / ISA-75.01.01-2007" }, { "code": "def set_value(self, value):\n v = 0\n measure_unit = 'px'\n try:\n v = int(float(value.replace('px', '')))\n except ValueError:\n try:\n v = int(float(value.replace('%', '')))\n measure_unit = '%'\n except ValueError:\n pass\n self.numInput.set_value(v)\n self.dropMeasureUnit.set_value(measure_unit)", "docstring": "The value have to be in the form '10px' or '10%', so numeric value plus measure unit" }, { "code": "def from_samples(cls, samples_like, vectors, info, vartype, variable_labels=None):\n try:\n samples = np.asarray(samples_like, dtype=np.int8)\n except TypeError:\n samples, variable_labels = _samples_dicts_to_array(samples_like, variable_labels)\n assert samples.dtype == np.int8, 'sanity check'\n record = data_struct_array(samples, **vectors)\n if variable_labels is None:\n __, num_variables = record.sample.shape\n variable_labels = list(range(num_variables))\n return cls(record, variable_labels, info, vartype)", "docstring": "Build a response from samples.\n\n Args:\n samples_like:\n A collection of samples. 'samples_like' is an extension of NumPy's array_like\n to include an iterable of sample dictionaries (as returned by\n :meth:`.Response.samples`).\n\n data_vectors (dict[field, :obj:`numpy.array`/list]):\n Additional per-sample data as a dict of vectors. Each vector is the\n same length as `samples_matrix`. The key 'energy' and it's vector is required.\n\n info (dict):\n Information about the response as a whole formatted as a dict.\n\n vartype (:class:`.Vartype`/str/set):\n Variable type for the response. Accepted input values:\n\n * :class:`.Vartype.SPIN`, ``'SPIN'``, ``{-1, 1}``\n * :class:`.Vartype.BINARY`, ``'BINARY'``, ``{0, 1}``\n\n variable_labels (list, optional):\n Determines the variable labels if samples_like is not an iterable of dictionaries.\n If samples_like is not an iterable of dictionaries and if variable_labels is not\n provided then index labels are used.\n\n Returns:\n :obj:`.Response`\n\n Examples:\n From dicts\n\n >>> import dimod\n ...\n >>> samples = [{'a': -1, 'b': +1}, {'a': -1, 'b': -1}]\n >>> response = dimod.Response.from_samples(samples, {'energy': [-1, 0]}, {}, dimod.SPIN)\n\n From an array\n\n >>> import dimod\n >>> import numpy as np\n ...\n >>> samples = np.ones((2, 3), dtype='int8') # 2 samples, 3 variables\n >>> response = dimod.Response.from_samples(samples, {'energy': [-1.0, -1.0]}, {},\n ... dimod.SPIN, variable_labels=['a', 'b', 'c'])" }, { "code": "def to_global(s):\n if s.startswith('GPSTime'):\n s = 'Gps' + s[3:]\n if '_' in s:\n s = \"\".join([i.capitalize() for i in s.split(\"_\")])\n return s[0].lower() + s[1:]", "docstring": "Format a global variable name." }, { "code": "def follow(user, obj, send_action=True, actor_only=True, flag='', **kwargs):\n check(obj)\n instance, created = apps.get_model('actstream', 'follow').objects.get_or_create(\n user=user, object_id=obj.pk, flag=flag,\n content_type=ContentType.objects.get_for_model(obj),\n actor_only=actor_only\n )\n if send_action and created:\n if not flag:\n action.send(user, verb=_('started following'), target=obj, **kwargs)\n else:\n action.send(user, verb=_('started %s' % flag), target=obj, **kwargs)\n return instance", "docstring": "Creates a relationship allowing the object's activities to appear in the\n user's stream.\n\n Returns the created ``Follow`` instance.\n\n If ``send_action`` is ``True`` (the default) then a\n `` started following `` action signal is sent.\n Extra keyword arguments are passed to the action.send call.\n\n If ``actor_only`` is ``True`` (the default) then only actions where the\n object is the actor will appear in the user's activity stream. Set to\n ``False`` to also include actions where this object is the action_object or\n the target.\n\n If ``flag`` not an empty string then the relationship would marked by this flag.\n\n Example::\n\n follow(request.user, group, actor_only=False)\n follow(request.user, group, actor_only=False, flag='liking')" }, { "code": "def load(self, shapefile=None):\r\n if shapefile:\r\n (shapeName, ext) = os.path.splitext(shapefile)\r\n self.shapeName = shapeName\r\n try:\r\n self.shp = open(\"%s.shp\" % shapeName, \"rb\")\r\n except IOError:\r\n raise ShapefileException(\"Unable to open %s.shp\" % shapeName)\r\n try:\r\n self.shx = open(\"%s.shx\" % shapeName, \"rb\")\r\n except IOError:\r\n raise ShapefileException(\"Unable to open %s.shx\" % shapeName)\r\n try:\r\n self.dbf = open(\"%s.dbf\" % shapeName, \"rb\")\r\n except IOError:\r\n raise ShapefileException(\"Unable to open %s.dbf\" % shapeName)\r\n if self.shp:\r\n self.__shpHeader()\r\n if self.dbf:\r\n self.__dbfHeader()", "docstring": "Opens a shapefile from a filename or file-like\r\n object. Normally this method would be called by the\r\n constructor with the file object or file name as an\r\n argument." }, { "code": "def calc_downsample(w, h, target=400):\n if w > h:\n return h / target\n elif h >= w:\n return w / target", "docstring": "Calculate downsampling value." }, { "code": "def get_values(self, set, selected_meta):\n warnings.warn(\"\\n\\nThis method assumes that the last level of the index is the sample_id.\\n\"\n \"In case of single index, the index itself should be the sample_id\")\n sample_ids = set.index.get_level_values(-1)\n corresponding_meta = self.meta.loc[sample_ids]\n values = corresponding_meta[selected_meta]\n try:\n values = values.astype(float)\n except ValueError:\n print(\"the values should be numeric\")\n return values", "docstring": "Retrieves the selected metadata values of the given set\n\n :param set: cluster that contains the data\n :param selected_meta: the values of the selected_meta\n :return: the values of the selected meta of the cluster" }, { "code": "def target(self):\n task = yield self.task()\n if not task:\n yield defer.succeed(None)\n defer.returnValue(None)\n defer.returnValue(task.target)", "docstring": "Find the target name for this build.\n\n :returns: deferred that when fired returns the build task's target\n name. If we could not determine the build task, or the task's\n target, return None." }, { "code": "def async_run(self, keyword, *args, **kwargs):\n handle = self._last_thread_handle\n thread = self._threaded(keyword, *args, **kwargs)\n thread.start()\n self._thread_pool[handle] = thread\n self._last_thread_handle += 1\n return handle", "docstring": "Executes the provided Robot Framework keyword in a separate thread and immediately returns a handle to be used with async_get" }, { "code": "def setInstrument(self, instrument, override_analyses=False):\n analyses = [an for an in self.getAnalyses()\n if (not an.getInstrument() or override_analyses) and\n an.isInstrumentAllowed(instrument)]\n total = 0\n for an in analyses:\n instr_methods = instrument.getMethods()\n meth = instr_methods[0] if instr_methods else None\n if meth and an.isMethodAllowed(meth):\n if an.getMethod() not in instr_methods:\n an.setMethod(meth)\n an.setInstrument(instrument)\n total += 1\n self.getField('Instrument').set(self, instrument)\n return total", "docstring": "Sets the specified instrument to the Analysis from the\n Worksheet. Only sets the instrument if the Analysis\n allows it, according to its Analysis Service and Method.\n If an analysis has already assigned an instrument, it won't\n be overriden.\n The Analyses that don't allow the instrument specified will\n not be modified.\n Returns the number of analyses affected" }, { "code": "def get_prop_value(name, props, default=None):\n if not props:\n return default\n try:\n return props[name]\n except KeyError:\n return default", "docstring": "Returns the value of a property or the default one\n\n :param name: Name of a property\n :param props: Dictionary of properties\n :param default: Default value\n :return: The value of the property or the default one" }, { "code": "def open_file_like(f, mode):\n new_fd = isinstance(f, (str, pathlib.Path))\n if new_fd:\n f = open(f, mode)\n try:\n yield f\n finally:\n if new_fd:\n f.close()", "docstring": "Wrapper for opening a file" }, { "code": "def focusd(task):\n if registration.get_registered(event_hooks=True, root_access=True):\n start_cmd_srv = (os.getuid() == 0)\n else:\n start_cmd_srv = False\n _run = lambda: Focusd(task).run(start_cmd_srv)\n daemonize(get_daemon_pidfile(task), task.task_dir, _run)", "docstring": "Forks the current process as a daemon to run a task.\n\n `task`\n ``Task`` instance for the task to run." }, { "code": "def __ordinal(self, num):\n if 10 <= num % 100 < 20:\n return str(num) + 'th'\n else:\n ord_info = {1: 'st', 2: 'nd', 3: 'rd'}.get(num % 10, 'th')\n return '{}{}'.format(num, ord_info)", "docstring": "Returns the ordinal number of a given integer, as a string.\n eg. 1 -> 1st, 2 -> 2nd, 3 -> 3rd, etc." }, { "code": "def execute(self, query, *multiparams, **params):\n coro = self._execute(query, *multiparams, **params)\n return _SAConnectionContextManager(coro)", "docstring": "Executes a SQL query with optional parameters.\n\n query - a SQL query string or any sqlalchemy expression.\n\n *multiparams/**params - represent bound parameter values to be\n used in the execution. Typically, the format is a dictionary\n passed to *multiparams:\n\n await conn.execute(\n table.insert(),\n {\"id\":1, \"value\":\"v1\"},\n )\n\n ...or individual key/values interpreted by **params::\n\n await conn.execute(\n table.insert(), id=1, value=\"v1\"\n )\n\n In the case that a plain SQL string is passed, a tuple or\n individual values in \\*multiparams may be passed::\n\n await conn.execute(\n \"INSERT INTO table (id, value) VALUES (%d, %s)\",\n (1, \"v1\")\n )\n\n await conn.execute(\n \"INSERT INTO table (id, value) VALUES (%s, %s)\",\n 1, \"v1\"\n )\n\n Returns ResultProxy instance with results of SQL query\n execution." }, { "code": "def disable_cors(self):\n return self.update_cors_configuration(\n enable_cors=False,\n allow_credentials=False,\n origins=[],\n overwrite_origins=True\n )", "docstring": "Switches CORS off.\n\n :returns: CORS status in JSON format" }, { "code": "def chart(self, x=None, y=None, chart_type=None, opts=None,\n\t\t\t style=None, label=None, options={}, **kwargs):\n\t\ttry:\n\t\t\tself.chart_obj = self._chart(x, y, chart_type, opts, style, label,\n\t\t\t\t\t\t\t\t\t\t options=options, **kwargs)\n\t\texcept Exception as e:\n\t\t\tself.err(e, self.chart, \"Can not create chart\")", "docstring": "Get a chart" }, { "code": "def _lookup_attributes(glyph_name, data):\n attributes = (\n data.names.get(glyph_name)\n or data.alternative_names.get(glyph_name)\n or data.production_names.get(glyph_name)\n or {}\n )\n return attributes", "docstring": "Look up glyph attributes in data by glyph name, alternative name or\n production name in order or return empty dictionary.\n\n Look up by alternative and production names for legacy projects and\n because of issue #232." }, { "code": "def read_string_data(file, number_values, endianness):\n offsets = [0]\n for i in range(number_values):\n offsets.append(types.Uint32.read(file, endianness))\n strings = []\n for i in range(number_values):\n s = file.read(offsets[i + 1] - offsets[i])\n strings.append(s.decode('utf-8'))\n return strings", "docstring": "Read string raw data\n\n This is stored as an array of offsets\n followed by the contiguous string data." }, { "code": "def loss(logits, labels):\n labels = tf.cast(labels, tf.int64)\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(\n labels=labels, logits=logits, name='cross_entropy_per_example')\n cross_entropy_mean = tf.reduce_mean(cross_entropy, name='cross_entropy')\n tf.add_to_collection('losses', cross_entropy_mean)\n return tf.add_n(tf.get_collection('losses'), name='total_loss')", "docstring": "Add L2Loss to all the trainable variables.\n\n Add summary for \"Loss\" and \"Loss/avg\".\n Args:\n logits: Logits from inference().\n labels: Labels from distorted_inputs or inputs(). 1-D tensor\n of shape [batch_size]\n\n Returns:\n Loss tensor of type float." }, { "code": "def read_html_file(filename):\n with open(os.path.join(get_static_directory(), 'html/{filename}'.format(filename=filename))) as f:\n contents = f.read()\n return contents", "docstring": "Reads the contents of an html file in the css directory\n\n @return: Contents of the specified file" }, { "code": "def mimetype(self, value: str) -> None:\n if (\n value.startswith('text/') or value == 'application/xml' or\n (value.startswith('application/') and value.endswith('+xml'))\n ):\n mimetype = f\"{value}; charset={self.charset}\"\n else:\n mimetype = value\n self.headers['Content-Type'] = mimetype", "docstring": "Set the mimetype to the value." }, { "code": "def get_sites_in_sphere(self, pt, r):\n neighbors = []\n for site in self._sites:\n dist = site.distance_from_point(pt)\n if dist <= r:\n neighbors.append((site, dist))\n return neighbors", "docstring": "Find all sites within a sphere from a point.\n\n Args:\n pt (3x1 array): Cartesian coordinates of center of sphere.\n r (float): Radius of sphere.\n\n Returns:\n [(site, dist) ...] since most of the time, subsequent processing\n requires the distance." }, { "code": "def overwrites_for(self, obj):\n if isinstance(obj, User):\n predicate = lambda p: p.type == 'member'\n elif isinstance(obj, Role):\n predicate = lambda p: p.type == 'role'\n else:\n predicate = lambda p: True\n for overwrite in filter(predicate, self._overwrites):\n if overwrite.id == obj.id:\n allow = Permissions(overwrite.allow)\n deny = Permissions(overwrite.deny)\n return PermissionOverwrite.from_pair(allow, deny)\n return PermissionOverwrite()", "docstring": "Returns the channel-specific overwrites for a member or a role.\n\n Parameters\n -----------\n obj\n The :class:`Role` or :class:`abc.User` denoting\n whose overwrite to get.\n\n Returns\n ---------\n :class:`PermissionOverwrite`\n The permission overwrites for this object." }, { "code": "def get_iso3_country_code(cls, country, use_live=True, exception=None):\n countriesdata = cls.countriesdata(use_live=use_live)\n countryupper = country.upper()\n len_countryupper = len(countryupper)\n if len_countryupper == 3:\n if countryupper in countriesdata['countries']:\n return countryupper\n elif len_countryupper == 2:\n iso3 = countriesdata['iso2iso3'].get(countryupper)\n if iso3 is not None:\n return iso3\n iso3 = countriesdata['countrynames2iso3'].get(countryupper)\n if iso3 is not None:\n return iso3\n for candidate in cls.expand_countryname_abbrevs(countryupper):\n iso3 = countriesdata['countrynames2iso3'].get(candidate)\n if iso3 is not None:\n return iso3\n if exception is not None:\n raise exception\n return None", "docstring": "Get ISO3 code for cls. Only exact matches or None are returned.\n\n Args:\n country (str): Country for which to get ISO3 code\n use_live (bool): Try to get use latest data from web rather than file in package. Defaults to True.\n exception (Optional[ExceptionUpperBound]): An exception to raise if country not found. Defaults to None.\n\n Returns:\n Optional[str]: ISO3 country code or None" }, { "code": "def classify(self, classifier_id, text, **kwargs):\n if classifier_id is None:\n raise ValueError('classifier_id must be provided')\n if text is None:\n raise ValueError('text must be provided')\n headers = {}\n if 'headers' in kwargs:\n headers.update(kwargs.get('headers'))\n sdk_headers = get_sdk_headers('natural_language_classifier', 'V1',\n 'classify')\n headers.update(sdk_headers)\n data = {'text': text}\n url = '/v1/classifiers/{0}/classify'.format(\n *self._encode_path_vars(classifier_id))\n response = self.request(\n method='POST',\n url=url,\n headers=headers,\n json=data,\n accept_json=True)\n return response", "docstring": "Classify a phrase.\n\n Returns label information for the input. The status must be `Available` before you\n can use the classifier to classify text.\n\n :param str classifier_id: Classifier ID to use.\n :param str text: The submitted phrase. The maximum length is 2048 characters.\n :param dict headers: A `dict` containing the request headers\n :return: A `DetailedResponse` containing the result, headers and HTTP status code.\n :rtype: DetailedResponse" }, { "code": "def wp_status(self):\n try:\n print(\"Have %u of %u waypoints\" % (self.wploader.count()+len(self.wp_received), self.wploader.expected_count))\n except Exception:\n print(\"Have %u waypoints\" % (self.wploader.count()+len(self.wp_received)))", "docstring": "show status of wp download" }, { "code": "def update(self, **kwargs):\n super(CommonConf, self).update(**kwargs)\n conf_changed = False\n for conf_name, conf_value in kwargs.items():\n rtconf.base.get_validator(conf_name)(conf_value)\n item1 = self._settings.get(conf_name, None)\n item2 = kwargs.get(conf_name, None)\n if item1 != item2:\n conf_changed = True\n if conf_changed:\n for conf_name, conf_value in kwargs.items():\n self._settings[conf_name] = conf_value\n self._notify_listeners(CommonConf.CONF_CHANGED_EVT, self)", "docstring": "Updates global configuration settings with given values.\n\n First checks if given configuration values differ from current values.\n If any of the configuration values changed, generates a change event.\n Currently we generate change event for any configuration change.\n Note: This method is idempotent." }, { "code": "def confirmation(self, *args, **kwargs):\n if not self.current_terminal:\n raise RuntimeError(\"no active terminal\")\n if not isinstance(self.current_terminal, Client):\n raise RuntimeError(\"current terminal not a client\")\n self.current_terminal.confirmation(*args, **kwargs)", "docstring": "Upstream packet, send to current terminal." }, { "code": "def wsgi_app(self, environ, start_response):\n @_LOCAL_MANAGER.middleware\n def _wrapped_app(environ, start_response):\n request = Request(environ)\n setattr(_local, _CURRENT_REQUEST_KEY, request)\n response = self._dispatch_request(request)\n return response(environ, start_response)\n return _wrapped_app(environ, start_response)", "docstring": "A basic WSGI app" }, { "code": "def layer_from_combo(combo):\n index = combo.currentIndex()\n if index < 0:\n return None\n layer_id = combo.itemData(index, Qt.UserRole)\n layer = QgsProject.instance().mapLayer(layer_id)\n return layer", "docstring": "Get the QgsMapLayer currently selected in a combo.\n\n Obtain QgsMapLayer id from the userrole of the QtCombo and return it as a\n QgsMapLayer.\n\n :returns: The currently selected map layer a combo.\n :rtype: QgsMapLayer" }, { "code": "def client_view(client):\n if request.method == 'POST' and 'delete' in request.form:\n db.session.delete(client)\n db.session.commit()\n return redirect(url_for('.index'))\n form = ClientForm(request.form, obj=client)\n if form.validate_on_submit():\n form.populate_obj(client)\n db.session.commit()\n return render_template(\n 'invenio_oauth2server/settings/client_view.html',\n client=client,\n form=form,\n )", "docstring": "Show client's detail." }, { "code": "def _contour_helper(self, args, kwargs):\n contour_kwargs = {}\n contour_kwargs['measurement'] = kwargs.pop('measurement', 'poles')\n contour_kwargs['method'] = kwargs.pop('method', 'exponential_kamb')\n contour_kwargs['sigma'] = kwargs.pop('sigma', 3)\n contour_kwargs['gridsize'] = kwargs.pop('gridsize', 100)\n contour_kwargs['weights'] = kwargs.pop('weights', None)\n lon, lat, totals = contouring.density_grid(*args, **contour_kwargs)\n return lon, lat, totals, kwargs", "docstring": "Unify defaults and common functionality of ``density_contour`` and\n ``density_contourf``." }, { "code": "def convert_group(tokens):\n tok = tokens.asList()\n dic = dict(tok)\n if not (len(dic) == len(tok)):\n raise ParseFatalException(\"Names in group must be unique: %s\" % tokens)\n return ConfGroup(dic)", "docstring": "Converts parseResult from to ConfGroup type." }, { "code": "def prepare_value(value):\n if isinstance(value, (list, tuple, set)):\n return \",\".join(value)\n if isinstance(value, bool):\n return \"y\" if value else \"n\"\n return str(value)", "docstring": "Prepare value to pylint." }, { "code": "def get_normalized_bdew_profile(self):\n self.df['temperature'] = self.temperature.values\n self.df['temperature_geo'] = self.weighted_temperature(\n how='geometric_series')\n sf = self.get_sf_values()\n [a, b, c, d] = self.get_sigmoid_parameters()\n f = self.get_weekday_parameters()\n h = (a / (1 + (b / (self.df['temperature_geo'] - 40)) ** c) + d)\n kw = 1.0 / (sum(h * f) / 24)\n heat_profile_normalized = (kw * h * f * sf)\n return heat_profile_normalized", "docstring": "Calculation of the normalized hourly heat demand" }, { "code": "def _create_timezone_static(tz):\n timezone = icalendar.Timezone()\n timezone.add('TZID', tz)\n subcomp = icalendar.TimezoneStandard()\n subcomp.add('TZNAME', tz)\n subcomp.add('DTSTART', dt.datetime(1601, 1, 1))\n subcomp.add('RDATE', dt.datetime(1601, 1, 1))\n subcomp.add('TZOFFSETTO', tz._utcoffset)\n subcomp.add('TZOFFSETFROM', tz._utcoffset)\n timezone.add_component(subcomp)\n return timezone", "docstring": "create an icalendar vtimezone from a pytz.tzinfo.StaticTzInfo\n\n :param tz: the timezone\n :type tz: pytz.tzinfo.StaticTzInfo\n :returns: timezone information\n :rtype: icalendar.Timezone()" }, { "code": "def forward_moves(self, position):\n if position.is_square_empty(self.square_in_front(self.location)):\n if self.would_move_be_promotion():\n for move in self.create_promotion_moves(notation_const.PROMOTE):\n yield move\n else:\n yield self.create_move(end_loc=self.square_in_front(self.location),\n status=notation_const.MOVEMENT)\n if self.on_home_row() and \\\n position.is_square_empty(self.two_squares_in_front(self.location)):\n yield self.create_move(\n end_loc=self.square_in_front(self.square_in_front(self.location)),\n status=notation_const.MOVEMENT\n )", "docstring": "Finds possible moves one step and two steps in front\n of Pawn.\n\n :type: position: Board\n :rtype: list" }, { "code": "def _is_whitelisted(self, email):\n return hasattr(settings, \"SAFE_EMAIL_WHITELIST\") and \\\n any(re.match(m, email) for m in settings.SAFE_EMAIL_WHITELIST)", "docstring": "Check if an email is in the whitelist. If there's no whitelist,\n it's assumed it's not whitelisted." }, { "code": "def generate_aliases_global(fieldfile, **kwargs):\n from easy_thumbnails.files import generate_all_aliases\n generate_all_aliases(fieldfile, include_global=True)", "docstring": "A saved_file signal handler which generates thumbnails for all field,\n model, and app specific aliases matching the saved file's field, also\n generating thumbnails for each project-wide alias." }, { "code": "def copy_files(source_files, target_directory, source_directory=None):\n try:\n os.makedirs(target_directory)\n except:\n pass\n for f in source_files:\n source = os.path.join(source_directory, f) if source_directory else f\n target = os.path.join(target_directory, f)\n shutil.copy2(source, target)", "docstring": "Copies a list of files to the specified directory.\n If source_directory is provided, it will be prepended to each source file." }, { "code": "def new_temp_file(directory=None, hint=''):\n return tempfile.NamedTemporaryFile(\n prefix='tmp-wpull-{0}-'.format(hint), suffix='.tmp', dir=directory)", "docstring": "Return a new temporary file." }, { "code": "def _get_request_token(self):\n params = {\n 'oauth_callback': self.get_callback_url()\n }\n response, content = self.client().request(self.request_token_url,\n \"POST\", body=urllib.urlencode(params))\n content = smart_unicode(content)\n if not response['status'] == '200':\n raise OAuthError(_(\n u\"Invalid status code %s while obtaining request token from %s: %s\") % (\n response['status'], self.request_token_url, content))\n token = dict(urlparse.parse_qsl(content))\n return oauth.Token(token['oauth_token'], token['oauth_token_secret'])", "docstring": "Fetch a request token from `self.request_token_url`." }, { "code": "def connect(server, port, username, password):\n print(\"-\" * 79)\n print(\"Connecting to: {}\".format(server))\n print(\"At port: {}\".format(port))\n print(\"Using username: {}\".format(username))\n print(\"Using password: {}\".format(password))\n print(\"-\" * 79)", "docstring": "This function might be something coming from your ORM" }, { "code": "def get_connection(self, fail_silently=False):\n from protean.services.email import get_connection\n if not self.connection:\n self.connection = get_connection(fail_silently=fail_silently)\n return self.connection", "docstring": "Retrieve connection to send email" }, { "code": "def get_metatab_doc(nb_path):\n from metatab.generate import CsvDataRowGenerator\n from metatab.rowgenerators import TextRowGenerator\n from metatab import MetatabDoc\n with open(nb_path) as f:\n nb = nbformat.reads(f.read(), as_version=4)\n for cell in nb.cells:\n source = ''.join(cell['source']).strip()\n if source.startswith('%%metatab'):\n return MetatabDoc(TextRowGenerator(source))", "docstring": "Read a notebook and extract the metatab document. Only returns the first document" }, { "code": "def __set_value(self, value):\n array = ((self._clean_value(value),),)\n return self._get_target().setDataArray(array)", "docstring": "Sets cell value to a string or number based on the given value." }, { "code": "def print_all_signals(self):\n for o in dir(self):\n obj= getattr(self, o)\n div = False\n for c in dir(obj):\n cobj = getattr(obj, c)\n if isinstance(cobj, Signal):\n print('def _on_{}__{}(self):'.format(o, c))\n div = True\n if div: print('-'*30)", "docstring": "Prints out every signal available for this widget and childs." }, { "code": "def slices(self):\n if self.chunks is None:\n yield tuple(slice(None, s) for s in self.shape)\n else:\n ceilings = tuple(-(-s // c) for s, c in zip(self.shape, self.chunks))\n for idx in np.ndindex(ceilings):\n out = []\n for i, c, s in zip(idx, self.chunks, self.shape):\n start = i * c\n stop = min(start + c, s + 1)\n out.append(slice(start, stop, 1))\n yield tuple(out)", "docstring": "Returns a generator yielding tuple of slice objects.\n\n Order is not guaranteed." }, { "code": "def dimensions(self):\n return ImageDimensions(self._info.file.width, self._info.file.height)", "docstring": "Dimensions of the image.\n\n :rtype: :py:class:`ImageDimensions`" }, { "code": "def get_recipients(self, **options):\n if options['recipients_from_setting']:\n return settings.TIMELINE_DIGEST_EMAIL_RECIPIENTS\n users = get_user_model()._default_manager.all()\n if options['staff']:\n users = users.filter(is_staff=True)\n elif not options['all']:\n users = users.filter(is_staff=True, is_superuser=True)\n return users.values_list(settings.TIMELINE_USER_EMAIL_FIELD, flat=True)", "docstring": "Figures out the recipients" }, { "code": "def num_orifices(FlowPlant, RatioVCOrifice, HeadLossOrifice, DiamOrifice):\n return np.ceil(area_orifice(HeadLossOrifice, RatioVCOrifice,\n FlowPlant).magnitude\n / area_circle(DiamOrifice).magnitude)", "docstring": "Return the number of orifices." }, { "code": "def getPattern(self, word):\n if word in self.patterns:\n return self.patterns[word]\n else:\n raise ValueError('Unknown pattern in getPattern().', word)", "docstring": "Returns the pattern with key word.\n\n Example: net.getPattern(\"tom\") => [0, 0, 0, 1]" }, { "code": "def begin_transaction(\n self,\n database,\n options_=None,\n retry=google.api_core.gapic_v1.method.DEFAULT,\n timeout=google.api_core.gapic_v1.method.DEFAULT,\n metadata=None,\n ):\n if \"begin_transaction\" not in self._inner_api_calls:\n self._inner_api_calls[\n \"begin_transaction\"\n ] = google.api_core.gapic_v1.method.wrap_method(\n self.transport.begin_transaction,\n default_retry=self._method_configs[\"BeginTransaction\"].retry,\n default_timeout=self._method_configs[\"BeginTransaction\"].timeout,\n client_info=self._client_info,\n )\n request = firestore_pb2.BeginTransactionRequest(\n database=database, options=options_\n )\n if metadata is None:\n metadata = []\n metadata = list(metadata)\n try:\n routing_header = [(\"database\", database)]\n except AttributeError:\n pass\n else:\n routing_metadata = google.api_core.gapic_v1.routing_header.to_grpc_metadata(\n routing_header\n )\n metadata.append(routing_metadata)\n return self._inner_api_calls[\"begin_transaction\"](\n request, retry=retry, timeout=timeout, metadata=metadata\n )", "docstring": "Starts a new transaction.\n\n Example:\n >>> from google.cloud import firestore_v1beta1\n >>>\n >>> client = firestore_v1beta1.FirestoreClient()\n >>>\n >>> database = client.database_root_path('[PROJECT]', '[DATABASE]')\n >>>\n >>> response = client.begin_transaction(database)\n\n Args:\n database (str): The database name. In the format:\n ``projects/{project_id}/databases/{database_id}``.\n options_ (Union[dict, ~google.cloud.firestore_v1beta1.types.TransactionOptions]): The options for the transaction.\n Defaults to a read-write transaction.\n\n If a dict is provided, it must be of the same form as the protobuf\n message :class:`~google.cloud.firestore_v1beta1.types.TransactionOptions`\n retry (Optional[google.api_core.retry.Retry]): A retry object used\n to retry requests. If ``None`` is specified, requests will not\n be retried.\n timeout (Optional[float]): The amount of time, in seconds, to wait\n for the request to complete. Note that if ``retry`` is\n specified, the timeout applies to each individual attempt.\n metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata\n that is provided to the method.\n\n Returns:\n A :class:`~google.cloud.firestore_v1beta1.types.BeginTransactionResponse` instance.\n\n Raises:\n google.api_core.exceptions.GoogleAPICallError: If the request\n failed for any reason.\n google.api_core.exceptions.RetryError: If the request failed due\n to a retryable error and retry attempts failed.\n ValueError: If the parameters are invalid." }, { "code": "def spike_latency(signal, threshold, fs):\n over, = np.where(signal>threshold)\n segments, = np.where(np.diff(over) > 1)\n if len(over) > 1:\n if len(segments) == 0:\n idx = over[0] + np.argmax(signal[over[0]:over[-1]])\n latency = float(idx)/fs\n elif segments[0] == 0:\n latency = float(over[0])/fs\n else:\n idx = over[0] + np.argmax(signal[over[0]:over[segments[0]]])\n latency = float(idx)/fs\n elif len(over) > 0:\n latency = float(over[0])/fs\n else:\n latency = np.nan\n return latency", "docstring": "Find the latency of the first spike over threshold\n\n :param signal: Spike trace recording (vector)\n :type signal: numpy array\n :param threshold: Threshold value to determine spikes\n :type threshold: float\n :returns: float -- Time of peak of first spike, or None if no values over threshold\n\n This is the same as the first value returned from calc_spike_times" }, { "code": "def wrap_url(s, l):\n parts = s.split('/')\n if len(parts) == 1:\n return parts[0]\n else:\n i = 0\n lines = []\n for j in range(i, len(parts) + 1):\n tv = '/'.join(parts[i:j])\n nv = '/'.join(parts[i:j + 1])\n if len(nv) > l or nv == tv:\n i = j\n lines.append(tv)\n return '/\\n'.join(lines)", "docstring": "Wrap a URL string" }, { "code": "def limiter(arr):\n dyn_range = 32767.0 / 32767.0\n lim_thresh = 30000.0 / 32767.0\n lim_range = dyn_range - lim_thresh\n new_arr = arr.copy()\n inds = N.where(arr > lim_thresh)[0]\n new_arr[inds] = (new_arr[inds] - lim_thresh) / lim_range\n new_arr[inds] = (N.arctan(new_arr[inds]) * 2.0 / N.pi) *\\\n lim_range + lim_thresh\n inds = N.where(arr < -lim_thresh)[0]\n new_arr[inds] = -(new_arr[inds] + lim_thresh) / lim_range\n new_arr[inds] = -(\n N.arctan(new_arr[inds]) * 2.0 / N.pi * lim_range + lim_thresh)\n return new_arr", "docstring": "Restrict the maximum and minimum values of arr" }, { "code": "def get_parent_until(path):\n dirname = osp.dirname(path)\n try:\n mod = osp.basename(path)\n mod = osp.splitext(mod)[0]\n imp.find_module(mod, [dirname])\n except ImportError:\n return\n items = [mod]\n while 1:\n items.append(osp.basename(dirname))\n try:\n dirname = osp.dirname(dirname)\n imp.find_module('__init__', [dirname + os.sep])\n except ImportError:\n break\n return '.'.join(reversed(items))", "docstring": "Given a file path, determine the full module path.\n\n e.g. '/usr/lib/python2.7/dist-packages/numpy/core/__init__.pyc' yields\n 'numpy.core'" }, { "code": "def groups_invite(self, *, channel: str, user: str, **kwargs) -> SlackResponse:\n self._validate_xoxp_token()\n kwargs.update({\"channel\": channel, \"user\": user})\n return self.api_call(\"groups.invite\", json=kwargs)", "docstring": "Invites a user to a private channel.\n\n Args:\n channel (str): The group id. e.g. 'G1234567890'\n user (str): The user id. e.g. 'U1234567890'" }, { "code": "def add_entry(self, entry):\n self.entry_keys.setdefault(entry, [])\n self.entries.append(entry)\n for dist in find_distributions(entry, True):\n self.add(dist, entry, False)", "docstring": "Add a path item to ``.entries``, finding any distributions on it\n\n ``find_distributions(entry, True)`` is used to find distributions\n corresponding to the path entry, and they are added. `entry` is\n always appended to ``.entries``, even if it is already present.\n (This is because ``sys.path`` can contain the same value more than\n once, and the ``.entries`` of the ``sys.path`` WorkingSet should always\n equal ``sys.path``.)" }, { "code": "def get_snapshot_by(self, volume_id_or_uri, field, value):\n uri = self.__build_volume_snapshot_uri(volume_id_or_uri)\n return self._client.get_by(field, value, uri=uri)", "docstring": "Gets all snapshots that match the filter.\n\n The search is case-insensitive.\n\n Args:\n volume_id_or_uri: Can be either the volume id or the volume uri.\n field: Field name to filter.\n value: Value to filter.\n\n Returns:\n list: Snapshots" }, { "code": "def shuffled_batches(self, batch_size):\n if batch_size >= self.num_envs * self.num_steps:\n yield self\n else:\n rollouts_in_batch = batch_size // self.num_steps\n batch_splits = math_util.divide_ceiling(self.num_envs, rollouts_in_batch)\n indices = list(range(self.num_envs))\n np.random.shuffle(indices)\n for sub_indices in np.array_split(indices, batch_splits):\n yield Trajectories(\n num_steps=self.num_steps,\n num_envs=len(sub_indices),\n environment_information=None,\n transition_tensors={k: x[:, sub_indices] for k, x in self.transition_tensors.items()},\n rollout_tensors={k: x[sub_indices] for k, x in self.rollout_tensors.items()},\n )", "docstring": "Generate randomized batches of data - only sample whole trajectories" }, { "code": "def get_encoder_settings(self):\n if self.lame_header is None:\n return u\"\"\n return self.lame_header.guess_settings(*self.lame_version)", "docstring": "Returns the guessed encoder settings" }, { "code": "def saveShp(self, target):\r\n if not hasattr(target, \"write\"):\r\n target = os.path.splitext(target)[0] + '.shp'\r\n if not self.shapeType:\r\n self.shapeType = self._shapes[0].shapeType\r\n self.shp = self.__getFileObj(target)\r\n self.__shapefileHeader(self.shp, headerType='shp')\r\n self.__shpRecords()", "docstring": "Save an shp file." }, { "code": "def terminate(self):\n for process in list(self.processes):\n process[\"subprocess\"].send_signal(signal.SIGTERM)\n self.stop_watch()", "docstring": "Terminates the processes right now with a SIGTERM" }, { "code": "def get_maintainer(self):\n return hdx.data.user.User.read_from_hdx(self.data['maintainer'], configuration=self.configuration)", "docstring": "Get the dataset's maintainer.\n\n Returns:\n User: Dataset's maintainer" }, { "code": "def copy_entities(from_namespace, from_workspace, to_namespace,\n to_workspace, etype, enames, link_existing_entities=False):\n uri = \"workspaces/{0}/{1}/entities/copy\".format(to_namespace, to_workspace)\n body = {\n \"sourceWorkspace\": {\n \"namespace\": from_namespace,\n \"name\": from_workspace\n },\n \"entityType\": etype,\n \"entityNames\": enames\n }\n return __post(uri, json=body, params={'linkExistingEntities':\n str(link_existing_entities).lower()})", "docstring": "Copy entities between workspaces\n\n Args:\n from_namespace (str): project (namespace) to which source workspace belongs\n from_workspace (str): Source workspace name\n to_namespace (str): project (namespace) to which target workspace belongs\n to_workspace (str): Target workspace name\n etype (str): Entity type\n enames (list(str)): List of entity names to copy\n link_existing_entities (boolean): Link all soft conflicts to the entities that already exist.\n\n Swagger:\n https://api.firecloud.org/#!/Entities/copyEntities" }, { "code": "def _read_incoming(self):\n fileno = self.proc.stdout.fileno()\n while 1:\n buf = b''\n try:\n buf = os.read(fileno, 1024)\n except OSError as e:\n self._log(e, 'read')\n if not buf:\n self._read_queue.put(None)\n return\n self._read_queue.put(buf)", "docstring": "Run in a thread to move output from a pipe to a queue." }, { "code": "def guard_rollback_to_open(worksheet):\n for analysis in worksheet.getAnalyses():\n if api.get_review_status(analysis) in [\"assigned\"]:\n return True\n return False", "docstring": "Return whether 'rollback_to_receive' transition can be performed or not" }, { "code": "def import_qt(glbls):\r\n if 'QtCore' in glbls:\r\n return\r\n from projexui.qt import QtCore, QtGui, wrapVariant, uic\r\n from projexui.widgets.xloggersplashscreen import XLoggerSplashScreen\r\n glbls['QtCore'] = QtCore\r\n glbls['QtGui'] = QtGui\r\n glbls['wrapVariant'] = wrapVariant\r\n glbls['uic'] = uic\r\n glbls['XLoggerSplashScreen'] = XLoggerSplashScreen", "docstring": "Delayed qt loader." }, { "code": "def cira_stretch(img, **kwargs):\n LOG.debug(\"Applying the cira-stretch\")\n def func(band_data):\n log_root = np.log10(0.0223)\n denom = (1.0 - log_root) * 0.75\n band_data *= 0.01\n band_data = band_data.clip(np.finfo(float).eps)\n band_data = xu.log10(band_data)\n band_data -= log_root\n band_data /= denom\n return band_data\n return apply_enhancement(img.data, func)", "docstring": "Logarithmic stretch adapted to human vision.\n\n Applicable only for visible channels." }, { "code": "def _to_hours_mins_secs(time_taken):\n mins, secs = divmod(time_taken, 60)\n hours, mins = divmod(mins, 60)\n return hours, mins, secs", "docstring": "Convert seconds to hours, mins, and seconds." }, { "code": "def rtt_read(self, buffer_index, num_bytes):\n buf = (ctypes.c_ubyte * num_bytes)()\n bytes_read = self._dll.JLINK_RTTERMINAL_Read(buffer_index, buf, num_bytes)\n if bytes_read < 0:\n raise errors.JLinkRTTException(bytes_read)\n return list(buf)[:bytes_read]", "docstring": "Reads data from the RTT buffer.\n\n This method will read at most num_bytes bytes from the specified\n RTT buffer. The data is automatically removed from the RTT buffer.\n If there are not num_bytes bytes waiting in the RTT buffer, the\n entire contents of the RTT buffer will be read.\n\n Args:\n self (JLink): the ``JLink`` instance\n buffer_index (int): the index of the RTT buffer to read from\n num_bytes (int): the maximum number of bytes to read\n\n Returns:\n A list of bytes read from RTT.\n\n Raises:\n JLinkRTTException if the underlying JLINK_RTTERMINAL_Read call fails." }, { "code": "def review_metadata_csv_single_user(filedir, metadata, csv_in, n_headers):\n try:\n if not validate_metadata(filedir, metadata):\n return False\n for filename, file_metadata in metadata.items():\n is_single_file_metadata_valid(file_metadata, None, filename)\n except ValueError as e:\n print_error(e)\n return False\n return True", "docstring": "Check validity of metadata for single user.\n\n :param filedir: This field is the filepath of the directory whose csv\n has to be made.\n :param metadata: This field is the metadata generated from the\n load_metadata_csv function.\n :param csv_in: This field returns a reader object which iterates over the\n csv.\n :param n_headers: This field is the number of headers in the csv." }, { "code": "def list_(runas=None):\n rubies = []\n output = _rvm(['list'], runas=runas)\n if output:\n regex = re.compile(r'^[= ]([*> ]) ([^- ]+)-([^ ]+) \\[ (.*) \\]')\n for line in output.splitlines():\n match = regex.match(line)\n if match:\n rubies.append([\n match.group(2), match.group(3), match.group(1) == '*'\n ])\n return rubies", "docstring": "List all rvm-installed rubies\n\n runas\n The user under which to run rvm. If not specified, then rvm will be run\n as the user under which Salt is running.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' rvm.list" }, { "code": "def pore_coords(target):\n r\n network = target.project.network\n Ts = network.throats(target.name)\n conns = network['throat.conns']\n coords = network['pore.coords']\n return _sp.mean(coords[conns], axis=1)[Ts]", "docstring": "r\"\"\"\n The average of the pore coords" }, { "code": "def parse(filename):\n with open(filename) as f:\n parser = ASDLParser()\n return parser.parse(f.read())", "docstring": "Parse ASDL from the given file and return a Module node describing it." }, { "code": "def get_layer(self):\n if self.layer:\n return\n try:\n self.layer = Layer.objects.get(slug=self.kwargs['slug'])\n except Layer.DoesNotExist:\n raise Http404(_('Layer not found'))", "docstring": "retrieve layer from DB" }, { "code": "def nextClass(self, classuri):\n if classuri == self.classes[-1].uri:\n return self.classes[0]\n flag = False\n for x in self.classes:\n if flag == True:\n return x\n if x.uri == classuri:\n flag = True\n return None", "docstring": "Returns the next class in the list of classes. If it's the last one, returns the first one." }, { "code": "def _compute_hamming_matrix(N):\n possible_states = np.array(list(utils.all_states((N))))\n return cdist(possible_states, possible_states, 'hamming') * N", "docstring": "Compute and store a Hamming matrix for |N| nodes.\n\n Hamming matrices have the following sizes::\n\n N MBs\n == ===\n 9 2\n 10 8\n 11 32\n 12 128\n 13 512\n\n Given these sizes and the fact that large matrices are needed infrequently,\n we store computed matrices using the Joblib filesystem cache instead of\n adding computed matrices to the ``_hamming_matrices`` global and clogging\n up memory.\n\n This function is only called when |N| >\n ``_NUM_PRECOMPUTED_HAMMING_MATRICES``. Don't call this function directly;\n use |_hamming_matrix| instead." }, { "code": "def wsp(word):\n HEAVY = r'[ieaAoO]{1}[\\.]*(u|y)[^ieaAoO]+(\\.|$)'\n delimiters = [i for i, char in enumerate(word) if char == '.']\n if len(delimiters) % 2 != 0:\n delimiters.append(len(word))\n unstressed = []\n for i, d in enumerate(delimiters):\n if i % 2 == 0:\n unstressed.extend(range(d + 1, delimiters[i + 1]))\n heavies = re.finditer(HEAVY, word)\n violations = sum(1 for m in heavies if m.start(0) in unstressed)\n return violations", "docstring": "Return the number of unstressed heavy syllables." }, { "code": "def add_and_matches(self, matcher, lhs, params, numq=1, flatten=None):\n params = self._adapt_params(params)\n qs = ['?'] * numq\n flatten = flatten or self._default_flatten(numq)\n expr = repeat(adapt_matcher(matcher)(lhs, *qs), len(params))\n self.conditions.extend(expr)\n self.params.extend(flatten(params))", "docstring": "Add AND conditions to match to `params`.\n\n :type matcher: str or callable\n :arg matcher: if `str`, `matcher.format` is used.\n :type lhs: str\n :arg lhs: the first argument to `matcher`.\n :type params: list\n :arg params: each element should be able to feed into sqlite '?'.\n :type numq: int\n :arg numq: number of parameters for each condition.\n :type flatten: None or callable\n :arg flatten: when `numq > 1`, it should return a list of\n length `numq * len(params)`." }, { "code": "def readall(self):\n if not self._open:\n raise pycdlibexception.PyCdlibInvalidInput('I/O operation on closed file.')\n readsize = self._length - self._offset\n if readsize > 0:\n data = self._fp.read(readsize)\n self._offset += readsize\n else:\n data = b''\n return data", "docstring": "A method to read and return the remaining bytes in the file.\n\n Parameters:\n None.\n Returns:\n The rest of the data left in the file. If the file is at or past EOF,\n returns an empty bytestring." }, { "code": "def load_module(self, name):\n if name not in sys.modules:\n sys.modules[name] = getattr(maps, name.split('.')[2])\n return sys.modules[name]", "docstring": "Load the ``pygal.maps.name`` module from the previously\n loaded plugin" }, { "code": "def _reserve(self, key):\n self.assign(key, RESERVED)\n try:\n yield\n finally:\n del self._cache[key]", "docstring": "Reserve a component's binding temporarily.\n\n Protects against cycles." }, { "code": "def update_constants():\n global MANAGER_CONTROL_CHANNEL, MANAGER_EXECUTOR_CHANNELS\n global MANAGER_LISTENER_STATS, MANAGER_STATE_PREFIX\n redis_prefix = getattr(settings, 'FLOW_MANAGER', {}).get('REDIS_PREFIX', '')\n MANAGER_CONTROL_CHANNEL = '{}.control'.format(redis_prefix)\n MANAGER_EXECUTOR_CHANNELS = ManagerChannelPair(\n '{}.result_queue'.format(redis_prefix),\n '{}.result_queue_response'.format(redis_prefix),\n )\n MANAGER_STATE_PREFIX = '{}.state'.format(redis_prefix)\n MANAGER_LISTENER_STATS = '{}.listener_stats'.format(redis_prefix)", "docstring": "Recreate channel name constants with changed settings.\n\n This kludge is mostly needed due to the way Django settings are\n patched for testing and how modules need to be imported throughout\n the project. On import time, settings are not patched yet, but some\n of the code needs static values immediately. Updating functions such\n as this one are then needed to fix dummy values." }, { "code": "def _exprcomp(node):\n try:\n comp = _LITS[node.data()]\n except KeyError:\n comp = _LITS[node.data()] = Complement(node)\n return comp", "docstring": "Return a unique Expression complement." }, { "code": "def zero_weight_obs_names(self):\n self.observation_data.index = self.observation_data.obsnme\n groups = self.observation_data.groupby(\n self.observation_data.weight.apply(lambda x: x==0.0)).groups\n if True in groups:\n return list(self.observation_data.loc[groups[True],\"obsnme\"])\n else:\n return []", "docstring": "get the zero-weighted observation names\n\n Returns\n -------\n zero_weight_obs_names : list\n a list of zero-weighted observation names" }, { "code": "def focusOutEvent(self, ev):\n Kittens.widgets.ClickableTreeWidget.focusOutEvent(self, ev)\n wid = QApplication.focusWidget()\n while wid:\n if wid is self:\n return\n wid = wid.parent()\n self._startOrStopEditing()", "docstring": "Redefine focusOut events to stop editing" }, { "code": "def _server_rollback():\n from os import path, remove\n archpath = path.abspath(path.expanduser(settings.archfile))\n if path.isfile(archpath) and not args[\"nolive\"]:\n vms(\"Removing archive JSON file at {}.\".format(archpath))\n remove(archpath)\n datapath = path.abspath(path.expanduser(settings.datafile))\n if path.isfile(datapath) and not args[\"nolive\"]:\n vms(\"Removing script database JSON file at {}\".format(datapath))\n remove(datapath)", "docstring": "Removes script database and archive files to rollback the CI server\n installation." }, { "code": "def get_cat_model(model):\n try:\n if isinstance(model, string_types):\n model_class = apps.get_model(*model.split(\".\"))\n elif issubclass(model, CategoryBase):\n model_class = model\n if model_class is None:\n raise TypeError\n except TypeError:\n raise TemplateSyntaxError(\"Unknown model submitted: %s\" % model)\n return model_class", "docstring": "Return a class from a string or class" }, { "code": "def _record_last_active(self, host):\n if host in self.hosts:\n self.hosts = [host] + [h for h in self.hosts if h != host]\n self._last_time_recorded_active = time.time()", "docstring": "Put host first in our host list, so we try it first next time\n\n The implementation of get_active_namenode relies on this reordering." }, { "code": "def autoinc(self):\n if not self.get('autoinc_version'):\n return\n oldver = self['version']\n newver = bump_version_tail(oldver)\n config_path = self.filepath\n temp_fd, temp_name = tempfile.mkstemp(\n dir=os.path.dirname(config_path),\n )\n with open(config_path) as old:\n with os.fdopen(temp_fd, 'w') as new:\n for oldline in old:\n if oldline.startswith('version:'):\n new.write(\"version: '%s'\\n\" % newver)\n continue\n new.write(oldline)\n log.info('Incrementing stack version %s -> %s' % (oldver, newver))\n os.rename(temp_name, config_path)", "docstring": "Conditionally updates the stack version in the file associated with\n this config.\n\n This handles both official releases (i.e. QA configs), and release\n candidates. Assumptions about version:\n\n - Official release versions are MAJOR.minor, where MAJOR and minor\n are both non-negative integers. E.g.\n\n 2.9\n 2.10\n 2.11\n 3.0\n 3.1\n 3.2\n etc...\n\n - Release candidate versions are MAJOR.minor-rc.N, where MAJOR,\n minor, and N are all non-negative integers.\n\n 3.5-rc.1\n 3.5-rc.2" }, { "code": "def refresh_address_presence(self, address):\n composite_presence = {\n self._fetch_user_presence(uid)\n for uid\n in self._address_to_userids[address]\n }\n new_presence = UserPresence.UNKNOWN\n for presence in UserPresence.__members__.values():\n if presence in composite_presence:\n new_presence = presence\n break\n new_address_reachability = USER_PRESENCE_TO_ADDRESS_REACHABILITY[new_presence]\n if new_address_reachability == self._address_to_reachability.get(address):\n return\n log.debug(\n 'Changing address presence state',\n current_user=self._user_id,\n address=to_normalized_address(address),\n prev_state=self._address_to_reachability.get(address),\n state=new_address_reachability,\n )\n self._address_to_reachability[address] = new_address_reachability\n self._address_reachability_changed_callback(address, new_address_reachability)", "docstring": "Update synthesized address presence state from cached user presence states.\n\n Triggers callback (if any) in case the state has changed.\n\n This method is only provided to cover an edge case in our use of the Matrix protocol and\n should **not** generally be used." }, { "code": "def db_value(self, value):\n if isinstance(value, string_types):\n value = arrow.get(value)\n if isinstance(value, arrow.Arrow):\n value = value.datetime\n return super(ArrowDateTimeField, self).db_value(value)", "docstring": "Convert the Arrow instance to a datetime for saving in the db." }, { "code": "def _count(self, method, limit, keywords):\n limit = limit.copy()\n has_more = True\n count = None\n while has_more:\n limit.set_request_args(keywords)\n response = self.call(method, **keywords)\n limit.post_fetch(response)\n count += Count.from_response(response)\n last_evaluated_key = response.get('LastEvaluatedKey')\n has_more = last_evaluated_key is not None and not limit.complete\n if has_more:\n keywords['ExclusiveStartKey'] = last_evaluated_key\n return count", "docstring": "Do a scan or query and aggregate the results into a Count" }, { "code": "def getDatastreamHistory(self, pid, dsid, format=None):\n http_args = {}\n if format is not None:\n http_args['format'] = format\n uri = 'objects/%(pid)s/datastreams/%(dsid)s/history' % \\\n {'pid': pid, 'dsid': dsid}\n return self.get(uri, params=http_args)", "docstring": "Get history information for a datastream.\n\n :param pid: object pid\n :param dsid: datastream id\n :param format: format\n :rtype: :class:`requests.models.Response`" }, { "code": "def _on_progress(adapter, operation, conn_id, done, total):\n conn_string = adapter._get_property(conn_id, 'connection_string')\n if conn_string is None:\n return\n adapter.notify_progress(conn_string, operation, done, total)", "docstring": "Callback when progress is reported." }, { "code": "def get_lower_triangle_correlation_matrix(self, sites, imt):\n return numpy.linalg.cholesky(self._get_correlation_matrix(sites, imt))", "docstring": "Get lower-triangle matrix as a result of Cholesky-decomposition\n of correlation matrix.\n\n The resulting matrix should have zeros on values above\n the main diagonal.\n\n The actual implementations of :class:`BaseCorrelationModel` interface\n might calculate the matrix considering site collection and IMT (like\n :class:`JB2009CorrelationModel` does) or might have it pre-constructed\n for a specific site collection and IMT, in which case they will need\n to make sure that parameters to this function match parameters that\n were used to pre-calculate decomposed correlation matrix.\n\n :param sites:\n :class:`~openquake.hazardlib.site.SiteCollection` to create\n correlation matrix for.\n :param imt:\n Intensity measure type object, see :mod:`openquake.hazardlib.imt`." }, { "code": "def get_hyperedge_degree_matrix(M):\n degrees = M.sum(0).transpose()\n new_degree = []\n for degree in degrees:\n new_degree.append(int(degree[0:]))\n return sparse.diags([new_degree], [0])", "docstring": "Creates the diagonal matrix of hyperedge degrees D_e as a sparse matrix,\n where a hyperedge degree is the cardinality of the hyperedge.\n\n :param M: the incidence matrix of the hypergraph to find the D_e matrix on.\n :returns: sparse.csc_matrix -- the diagonal hyperedge degree matrix as a\n sparse matrix." }, { "code": "def _get_weight_size(self, data, n_local_subj):\n weight_size = np.zeros(1).astype(int)\n local_weight_offset = np.zeros(n_local_subj).astype(int)\n for idx, subj_data in enumerate(data):\n if idx > 0:\n local_weight_offset[idx] = weight_size[0]\n weight_size[0] += self.K * subj_data.shape[1]\n return weight_size, local_weight_offset", "docstring": "Calculate the size of weight for this process\n\n Parameters\n ----------\n\n data : a list of 2D array, each in shape [n_voxel, n_tr]\n The fMRI data from multi-subject.\n\n n_local_subj : int\n Number of subjects allocated to this process.\n\n\n Returns\n -------\n\n weight_size : 1D array\n The size of total subject weight on this process.\n\n local_weight_offset : 1D array\n Number of elements away from the first element\n in the combined weight array at which to begin\n the new, segmented array for a subject" }, { "code": "def make_big_empty_files(self):\n for file_url in self.file_urls:\n local_path = file_url.get_local_path(self.dest_directory)\n with open(local_path, \"wb\") as outfile:\n if file_url.size > 0:\n outfile.seek(int(file_url.size) - 1)\n outfile.write(b'\\0')", "docstring": "Write out a empty file so the workers can seek to where they should write and write their data." }, { "code": "def set_metrics_params(self, enable=None, store_dir=None, restore=None, no_cores=None):\n self._set('enable-metrics', enable, cast=bool)\n self._set('metrics-dir', self._section.replace_placeholders(store_dir))\n self._set('metrics-dir-restore', restore, cast=bool)\n self._set('metrics-no-cores', no_cores, cast=bool)\n return self._section", "docstring": "Sets basic Metrics subsystem params.\n\n uWSGI metrics subsystem allows you to manage \"numbers\" from your apps.\n\n When enabled, the subsystem configures a vast amount of metrics\n (like requests per-core, memory usage, etc) but, in addition to this,\n you can configure your own metrics, such as the number of active users or, say,\n hits of a particular URL, as well as the memory consumption of your app or the whole server.\n\n * http://uwsgi.readthedocs.io/en/latest/Metrics.html\n * SNMP Integration - http://uwsgi.readthedocs.io/en/latest/Metrics.html#snmp-integration\n\n :param bool enable: Enables the subsystem.\n\n :param str|unicode store_dir: Directory to store metrics.\n The metrics subsystem can expose all of its metrics in the form\n of text files in a directory. The content of each file is the value\n of the metric (updated in real time).\n\n .. note:: Placeholders can be used to build paths, e.g.: {project_runtime_dir}/metrics/\n See ``Section.project_name`` and ``Section.runtime_dir``.\n\n :param bool restore: Restore previous metrics from ``store_dir``.\n When you restart a uWSGI instance, all of its metrics are reset.\n Use the option to force the metric subsystem to read-back the values\n from the metric directory before starting to collect values.\n\n :param bool no_cores: Disable generation of cores-related metrics." }, { "code": "def get_or_generate_vocab(data_dir, tmp_dir, vocab_filename, vocab_size,\n sources, file_byte_budget=1e6,\n max_subtoken_length=None):\n vocab_generator = generate_lines_for_vocab(tmp_dir, sources, file_byte_budget)\n return get_or_generate_vocab_inner(data_dir, vocab_filename, vocab_size,\n vocab_generator, max_subtoken_length)", "docstring": "Generate a vocabulary from the datasets in sources." }, { "code": "def reverse(self, name, **kwargs):\n for p, n, _ in self.endpoints:\n if name == n:\n return p.format(**kwargs)", "docstring": "Reverse routing.\n\n >>> from kobin import Response\n >>> r = Router()\n >>> def view(user_id: int) -> Response:\n ... return Response(f'You are {user_id}')\n ...\n >>> r.add('/users/{user_id}', 'GET', 'user-detail', view)\n >>> r.reverse('user-detail', user_id=1)\n '/users/1'" }, { "code": "def success(self):\n return self.ack.upper() in (self.config.ACK_SUCCESS,\n self.config.ACK_SUCCESS_WITH_WARNING)", "docstring": "Checks for the presence of errors in the response. Returns ``True`` if\n all is well, ``False`` otherwise.\n\n :rtype: bool\n :returns ``True`` if PayPal says our query was successful." }, { "code": "def convert_result(converter):\n def decorate(fn):\n @inspection.wraps(fn)\n def new_fn(*args, **kwargs):\n return converter(fn(*args, **kwargs))\n return new_fn\n return decorate", "docstring": "Decorator that can convert the result of a function call." }, { "code": "def is_smart(self, value):\n self.set_bool(\"is_smart\", value)\n if value is True:\n if self.find(\"criteria\") is None:\n self.criteria = ElementTree.SubElement(self, \"criteria\")", "docstring": "Set group is_smart property to value.\n\n Args:\n value: Boolean." }, { "code": "def half_cauchy_like(x, alpha, beta):\n R\n x = np.atleast_1d(x)\n if sum(x.ravel() < 0):\n return -inf\n return flib.cauchy(x, alpha, beta) + len(x) * np.log(2)", "docstring": "R\"\"\"\n Half-Cauchy log-likelihood. Simply the absolute value of Cauchy.\n\n .. math::\n f(x \\mid \\alpha, \\beta) = \\frac{2}{\\pi \\beta [1 + (\\frac{x-\\alpha}{\\beta})^2]}\n\n :Parameters:\n - `alpha` : Location parameter.\n - `beta` : Scale parameter (beta > 0).\n\n .. note::\n - x must be non-negative." }, { "code": "def _get_subtype_tags(self):\n assert self.is_member_of_enumerated_subtypes_tree(), \\\n 'Not a part of a subtypes tree.'\n cur = self.parent_type\n cur_dt = self\n tags = []\n while cur:\n assert cur.has_enumerated_subtypes()\n for subtype_field in cur.get_enumerated_subtypes():\n if subtype_field.data_type is cur_dt:\n tags.append(subtype_field.name)\n break\n else:\n assert False, 'Could not find?!'\n cur_dt = cur\n cur = cur.parent_type\n tags.reverse()\n return tuple(tags)", "docstring": "Returns a list of type tags that refer to this type starting from the\n base of the struct hierarchy." }, { "code": "def get_by_details(self, name, type, clazz):\n entry = DNSEntry(name, type, clazz)\n return self.get(entry)", "docstring": "Gets an entry by details. Will return None if there is\n no matching entry." }, { "code": "def _hline_bokeh_(self, col):\n c = hv.HLine(self.df[col].mean())\n return c", "docstring": "Returns an horizontal line from a column mean value" }, { "code": "def rate_slack(self, max_rate):\n if self.fragment_type == self.REGULAR:\n return -self.rate_lack(max_rate)\n elif self.fragment_type == self.NONSPEECH:\n return self.length\n else:\n return TimeValue(\"0.000\")", "docstring": "The maximum time interval that can be stolen to this fragment\n while keeping it respecting the given max rate.\n\n For ``REGULAR`` fragments this value is\n the opposite of the ``rate_lack``.\n For ``NONSPEECH`` fragments this value is equal to\n the length of the fragment.\n For ``HEAD`` and ``TAIL`` fragments this value is ``0.000``,\n meaning that they cannot be stolen.\n\n :param max_rate: the maximum rate (characters/second)\n :type max_rate: :class:`~aeneas.exacttiming.Decimal`\n :rtype: :class:`~aeneas.exacttiming.TimeValue`\n\n .. versionadded:: 1.7.0" }, { "code": "def timedelta_average(*values: datetime.timedelta) -> datetime.timedelta:\n r\n if isinstance(values[0], (list, tuple)):\n values = values[0]\n return sum(values, datetime.timedelta()) // len(values)", "docstring": "r\"\"\"Compute the arithmetic mean for timedeltas list.\n\n :param \\*values: Timedelta instances to process." }, { "code": "def _guess_vc_legacy(self):\n default = r'Microsoft Visual Studio %0.1f\\VC' % self.vc_ver\n return os.path.join(self.ProgramFilesx86, default)", "docstring": "Locate Visual C for versions prior to 2017" }, { "code": "def map(self, mapper: Callable[[Any], Any]) -> 'Observable':\n r\n source = self\n return Observable(lambda on_next: source.subscribe(compose(on_next, mapper)))", "docstring": "r\"\"\"Map a function over an observable.\n\n Haskell: fmap f m = Cont $ \\c -> runCont m (c . f)" }, { "code": "def extract_archive(archive, verbosity=0, outdir=None, program=None, interactive=True):\n util.check_existing_filename(archive)\n if verbosity >= 0:\n util.log_info(\"Extracting %s ...\" % archive)\n return _extract_archive(archive, verbosity=verbosity, interactive=interactive, outdir=outdir, program=program)", "docstring": "Extract given archive." }, { "code": "def _arguments_repr(self):\n document_class_repr = (\n 'dict' if self.document_class is dict\n else repr(self.document_class))\n uuid_rep_repr = UUID_REPRESENTATION_NAMES.get(self.uuid_representation,\n self.uuid_representation)\n return ('document_class=%s, tz_aware=%r, uuid_representation=%s, '\n 'unicode_decode_error_handler=%r, tzinfo=%r, '\n 'type_registry=%r' %\n (document_class_repr, self.tz_aware, uuid_rep_repr,\n self.unicode_decode_error_handler, self.tzinfo,\n self.type_registry))", "docstring": "Representation of the arguments used to create this object." }, { "code": "def mapper_metro(self, _, data):\n if 'tags' in data:\n type_tag = 1\n lonlat = data['coordinates']\n payload = data['tags']\n elif 'user_id' in data:\n type_tag = 2\n accept = [\n \"twitter\\.com\",\n \"foursquare\\.com\",\n \"instagram\\.com\",\n \"untappd\\.com\"\n ]\n expr = \"|\".join(accept)\n if not re.findall(expr, data['source']):\n return\n lonlat = data['lonlat']\n payload = None\n metro = self.lookup.get(lonlat, METRO_DISTANCE)\n if not metro:\n return\n yield metro, (type_tag, lonlat, payload)", "docstring": "map each osm POI and geotweets based on spatial lookup of metro area" }, { "code": "def check_valence(self):\n return [x for x, atom in self.atoms() if not atom.check_valence(self.environment(x))]", "docstring": "check valences of all atoms\n\n :return: list of invalid atoms" }, { "code": "def to_kwargs(triangles):\n triangles = np.asanyarray(triangles, dtype=np.float64)\n if not util.is_shape(triangles, (-1, 3, 3)):\n raise ValueError('Triangles must be (n,3,3)!')\n vertices = triangles.reshape((-1, 3))\n faces = np.arange(len(vertices)).reshape((-1, 3))\n kwargs = {'vertices': vertices,\n 'faces': faces}\n return kwargs", "docstring": "Convert a list of triangles to the kwargs for the Trimesh\n constructor.\n\n Parameters\n ---------\n triangles : (n, 3, 3) float\n Triangles in space\n\n Returns\n ---------\n kwargs : dict\n Keyword arguments for the trimesh.Trimesh constructor\n Includes keys 'vertices' and 'faces'\n\n Examples\n ---------\n >>> mesh = trimesh.Trimesh(**trimesh.triangles.to_kwargs(triangles))" }, { "code": "def enable_tracing(self, thread_trace_func=None):\n if self.frame_eval_func is not None:\n self.frame_eval_func()\n pydevd_tracing.SetTrace(self.dummy_trace_dispatch)\n return\n if thread_trace_func is None:\n thread_trace_func = self.get_thread_local_trace_func()\n else:\n self._local_thread_trace_func.thread_trace_func = thread_trace_func\n pydevd_tracing.SetTrace(thread_trace_func)", "docstring": "Enables tracing.\n\n If in regular mode (tracing), will set the tracing function to the tracing\n function for this thread -- by default it's `PyDB.trace_dispatch`, but after\n `PyDB.enable_tracing` is called with a `thread_trace_func`, the given function will\n be the default for the given thread." }, { "code": "def _CreateFeedMapping(client, feed_details):\n feed_mapping_service = client.GetService('FeedMappingService',\n version='v201809')\n operation = {\n 'operand': {\n 'criterionType': DSA_PAGE_FEED_CRITERION_TYPE,\n 'feedId': feed_details.feed_id,\n 'attributeFieldMappings': [\n {\n 'feedAttributeId': feed_details.url_attribute_id,\n 'fieldId': DSA_PAGE_URLS_FIELD_ID\n },\n {\n 'feedAttributeId': feed_details.label_attribute_id,\n 'fieldId': DSA_LABEL_FIELD_ID\n }\n ]\n },\n 'operator': 'ADD'\n }\n feed_mapping_service.mutate([operation])", "docstring": "Creates the feed mapping for DSA page feeds.\n\n Args:\n client: an AdWordsClient instance.\n feed_details: a _DSAFeedDetails instance." }, { "code": "def add_to_package_numpy(self, root, ndarray, node_path, target, source_path, transform, custom_meta):\n filehash = self.save_numpy(ndarray)\n metahash = self.save_metadata(custom_meta)\n self._add_to_package_contents(root, node_path, [filehash], target, source_path, transform, metahash)", "docstring": "Save a Numpy array to the store." }, { "code": "def _reconnect(self):\n if self.idle or self.closed:\n LOGGER.debug('Attempting RabbitMQ reconnect in %s seconds',\n self.reconnect_delay)\n self.io_loop.call_later(self.reconnect_delay, self.connect)\n return\n LOGGER.warning('Reconnect called while %s', self.state_description)", "docstring": "Schedule the next connection attempt if the class is not currently\n closing." }, { "code": "def workspace_backup_add(ctx):\n backup_manager = WorkspaceBackupManager(Workspace(ctx.resolver, directory=ctx.directory, mets_basename=ctx.mets_basename, automatic_backup=ctx.automatic_backup))\n backup_manager.add()", "docstring": "Create a new backup" }, { "code": "def _atomicModification(func):\n def wrapper(*args, **kwargs):\n self = args[0]\n with self._qpart:\n func(*args, **kwargs)\n return wrapper", "docstring": "Decorator\n Make document modification atomic" }, { "code": "def dt_avg(self, print_output=True, output_file=\"dt_query.csv\"):\n avg = self.dt.mean(axis=2)\n if print_output:\n np.savetxt(output_file, avg, delimiter=\",\")\n return avg", "docstring": "Compute average document-topic matrix,\n and print to file if print_output=True." }, { "code": "def get_wrong_answer_ids(self):\n id_list = []\n for answer in self.get_wrong_answers():\n id_list.append(answer.get_id())\n return IdList(id_list)", "docstring": "provide this method to return only wrong answer ids" }, { "code": "def parse_inline(self, text):\n element_list = self._build_inline_element_list()\n return inline_parser.parse(\n text, element_list, fallback=self.inline_elements['RawText']\n )", "docstring": "Parses text into inline elements.\n RawText is not considered in parsing but created as a wrapper of holes\n that don't match any other elements.\n\n :param text: the text to be parsed.\n :returns: a list of inline elements." }, { "code": "def _serialize_rules(rules):\n result = [(rule_name, str(rule)) for rule_name, rule in rules.items()]\n return sorted(result, key=lambda rule: rule[0])", "docstring": "Serialize all the Rule object as string.\n\n New string is used to compare the rules list." }, { "code": "def add_selected(self, ):\n browser = self.shot_browser if self.browser_tabw.currentIndex() == 1 else self.asset_browser\n selelements = browser.selected_indexes(2)\n if not selelements:\n return\n seltypes = browser.selected_indexes(3)\n if not seltypes:\n return\n elementi = selelements[0]\n typi = seltypes[0]\n if not elementi.isValid() or not typi.isValid():\n return\n element = elementi.internalPointer().internal_data()\n typ = typi.internalPointer().internal_data()[0]\n reftrack.Reftrack(self.root, self.refobjinter, typ=typ, element=element)", "docstring": "Create a new reftrack with the selected element and type and add it to the root.\n\n :returns: None\n :rtype: None\n :raises: NotImplementedError" }, { "code": "def with_more_selectors(self, selectors):\n if self.headers and self.headers[-1].is_selector:\n new_selectors = extend_unique(\n self.headers[-1].selectors,\n selectors)\n new_headers = self.headers[:-1] + (\n BlockSelectorHeader(new_selectors),)\n return RuleAncestry(new_headers)\n else:\n new_headers = self.headers + (BlockSelectorHeader(selectors),)\n return RuleAncestry(new_headers)", "docstring": "Return a new ancestry that also matches the given selectors. No\n nesting is done." }, { "code": "def ensure_on():\n if get_status() == 'not-running':\n if config.dbserver.multi_user:\n sys.exit('Please start the DbServer: '\n 'see the documentation for details')\n subprocess.Popen([sys.executable, '-m', 'openquake.server.dbserver',\n '-l', 'INFO'])\n waiting_seconds = 30\n while get_status() == 'not-running':\n if waiting_seconds == 0:\n sys.exit('The DbServer cannot be started after 30 seconds. '\n 'Please check the configuration')\n time.sleep(1)\n waiting_seconds -= 1", "docstring": "Start the DbServer if it is off" }, { "code": "def nested_dict_to_list(path, dic, exclusion=None):\n result = []\n exclusion = ['__self'] if exclusion is None else exclusion\n for key, value in dic.items():\n if not any([exclude in key for exclude in exclusion]):\n if isinstance(value, dict):\n aux = path + key + \"/\"\n result.extend(nested_dict_to_list(aux, value))\n else:\n if path.endswith(\"/\"):\n path = path[:-1]\n result.append([path, key, value])\n return result", "docstring": "Transform nested dict to list" }, { "code": "def build_annotation_dict_any_filter(annotations: Mapping[str, Iterable[str]]) -> EdgePredicate:\n if not annotations:\n return keep_edge_permissive\n @edge_predicate\n def annotation_dict_any_filter(edge_data: EdgeData) -> bool:\n return _annotation_dict_any_filter(edge_data, query=annotations)\n return annotation_dict_any_filter", "docstring": "Build an edge predicate that passes for edges whose data dictionaries match the given dictionary.\n\n If the given dictionary is empty, will always evaluate to true.\n\n :param annotations: The annotation query dict to match" }, { "code": "def print_file_details_as_csv(self, fname, col_headers):\r\n line = ''\r\n qu = '\"'\r\n d = ','\r\n for fld in col_headers:\r\n if fld == \"fullfilename\":\r\n line = line + qu + fname + qu + d\r\n if fld == \"name\":\r\n line = line + qu + os.path.basename(fname) + qu + d\r\n if fld == \"date\":\r\n line = line + qu + self.GetDateAsString(fname) + qu + d\r\n if fld == \"size\":\r\n line = line + qu + self.get_size_as_string(fname) + qu + d\r\n if fld == \"path\":\r\n try:\r\n line = line + qu + os.path.dirname(fname) + qu + d\r\n except IOError:\r\n line = line + qu + 'ERROR_PATH' + qu + d\r\n return line", "docstring": "saves as csv format" }, { "code": "def contracts_version_expects_deposit_limits(contracts_version: Optional[str]) -> bool:\n if contracts_version is None:\n return True\n if contracts_version == '0.3._':\n return False\n return compare(contracts_version, '0.9.0') > -1", "docstring": "Answers whether TokenNetworkRegistry of the contracts_vesion needs deposit limits" }, { "code": "def _reference_rmvs(self, removes):\n print(\"\")\n self.msg.template(78)\n msg_pkg = \"package\"\n if len(removes) > 1:\n msg_pkg = \"packages\"\n print(\"| Total {0} {1} removed\".format(len(removes), msg_pkg))\n self.msg.template(78)\n for pkg in removes:\n if not GetFromInstalled(pkg).name():\n print(\"| Package {0} removed\".format(pkg))\n else:\n print(\"| Package {0} not found\".format(pkg))\n self.msg.template(78)\n print(\"\")", "docstring": "Prints all removed packages" }, { "code": "def iter_dialogs(\n self, limit=None, *, offset_date=None, offset_id=0,\n offset_peer=types.InputPeerEmpty(), ignore_migrated=False\n ):\n return _DialogsIter(\n self,\n limit,\n offset_date=offset_date,\n offset_id=offset_id,\n offset_peer=offset_peer,\n ignore_migrated=ignore_migrated\n )", "docstring": "Returns an iterator over the dialogs, yielding 'limit' at most.\n Dialogs are the open \"chats\" or conversations with other people,\n groups you have joined, or channels you are subscribed to.\n\n Args:\n limit (`int` | `None`):\n How many dialogs to be retrieved as maximum. Can be set to\n ``None`` to retrieve all dialogs. Note that this may take\n whole minutes if you have hundreds of dialogs, as Telegram\n will tell the library to slow down through a\n ``FloodWaitError``.\n\n offset_date (`datetime`, optional):\n The offset date to be used.\n\n offset_id (`int`, optional):\n The message ID to be used as an offset.\n\n offset_peer (:tl:`InputPeer`, optional):\n The peer to be used as an offset.\n\n ignore_migrated (`bool`, optional):\n Whether :tl:`Chat` that have ``migrated_to`` a :tl:`Channel`\n should be included or not. By default all the chats in your\n dialogs are returned, but setting this to ``True`` will hide\n them in the same way official applications do.\n\n Yields:\n Instances of `telethon.tl.custom.dialog.Dialog`." }, { "code": "def get_generic_subseq_3D(protein, cutoff, prop, condition):\n if not protein.representative_structure:\n log.error('{}: no representative structure, cannot search for subseq'.format(protein.id))\n return {'subseq_len': 0, 'subseq': None, 'subseq_resnums': []}\n subseq, subseq_resnums = protein.get_seqprop_subsequence_from_structchain_property(property_key=prop,\n property_value=cutoff,\n condition=condition,\n use_representatives=True,\n return_resnums=True) or (\n None, [])\n return {'subseq_len': len(subseq_resnums), 'subseq': subseq, 'subseq_resnums': subseq_resnums}", "docstring": "Get a subsequence from REPSEQ based on a property stored in REPSTRUCT.REPCHAIN.letter_annotations" }, { "code": "def visit_ListComp(self, node: ast.ListComp) -> None:\n if node in self._recomputed_values:\n value = self._recomputed_values[node]\n text = self._atok.get_text(node)\n self.reprs[text] = value\n self.generic_visit(node=node)", "docstring": "Represent the list comprehension by dumping its source code." }, { "code": "def parse_iptables_rule(line):\n bits = line.split()\n definition = {}\n key = None\n args = []\n not_arg = False\n def add_args():\n arg_string = ' '.join(args)\n if key in IPTABLES_ARGS:\n definition_key = (\n 'not_{0}'.format(IPTABLES_ARGS[key])\n if not_arg\n else IPTABLES_ARGS[key]\n )\n definition[definition_key] = arg_string\n else:\n definition.setdefault('extras', []).extend((key, arg_string))\n for bit in bits:\n if bit == '!':\n if key:\n add_args()\n args = []\n key = None\n not_arg = True\n elif bit.startswith('-'):\n if key:\n add_args()\n args = []\n not_arg = False\n key = bit\n else:\n args.append(bit)\n if key:\n add_args()\n if 'extras' in definition:\n definition['extras'] = set(definition['extras'])\n return definition", "docstring": "Parse one iptables rule. Returns a dict where each iptables code argument\n is mapped to a name using IPTABLES_ARGS." }, { "code": "def renderer_doc(*args):\n renderers_ = salt.loader.render(__opts__, [])\n docs = {}\n if not args:\n for func in six.iterkeys(renderers_):\n docs[func] = renderers_[func].__doc__\n return _strip_rst(docs)\n for module in args:\n if '*' in module or '.' in module:\n for func in fnmatch.filter(renderers_, module):\n docs[func] = renderers_[func].__doc__\n else:\n moduledot = module + '.'\n for func in six.iterkeys(renderers_):\n if func.startswith(moduledot):\n docs[func] = renderers_[func].__doc__\n return _strip_rst(docs)", "docstring": "Return the docstrings for all renderers. Optionally, specify a renderer or a\n function to narrow the selection.\n\n The strings are aggregated into a single document on the master for easy\n reading.\n\n Multiple renderers can be specified.\n\n .. versionadded:: 2015.5.0\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' sys.renderer_doc\n salt '*' sys.renderer_doc cheetah\n salt '*' sys.renderer_doc jinja json\n\n Renderer names can be specified as globs.\n\n .. code-block:: bash\n\n salt '*' sys.renderer_doc 'c*' 'j*'" }, { "code": "def _create_binary_trigger(trigger):\n ops = {\n 0: \">\",\n 1: \"<\",\n 2: \">=\",\n 3: \"<=\",\n 4: \"==\",\n 5: 'always'\n }\n op_codes = {y: x for x, y in ops.items()}\n source = 0\n if isinstance(trigger, TrueTrigger):\n op_code = op_codes['always']\n elif isinstance(trigger, FalseTrigger):\n raise ArgumentError(\"Cannot express a never trigger in binary descriptor\", trigger=trigger)\n else:\n op_code = op_codes[trigger.comp_string]\n if trigger.use_count:\n source = 1\n return (op_code << 1) | source", "docstring": "Create an 8-bit binary trigger from an InputTrigger, TrueTrigger, FalseTrigger." }, { "code": "def match(self, p_todo):\n operand1 = self.value\n operand2 = p_todo.priority() or 'ZZ'\n return self.compare_operands(operand1, operand2)", "docstring": "Performs a match on a priority in the todo.\n\n It gets priority from p_todo and compares it with user-entered\n expression based on the given operator (default ==). It does that however\n in reversed order to obtain more intuitive result. Example: (>B) will\n match todos with priority (A).\n Items without priority are designated with corresponding operand set to\n 'ZZ', because python doesn't allow NoneType() and str() comparisons." }, { "code": "def _validate_file_format(self, file_format):\n if file_format not in self.valid_file_formats:\n raise InvalidFileFormatError(\n \"{} is not a valid file format\".format(file_format)\n )\n return file_format", "docstring": "Validates file format, raising error if invalid." }, { "code": "def from_json(cls, data, json_schema_class=None):\n schema = cls.json_schema if json_schema_class is None else json_schema_class()\n return schema.load(data)", "docstring": "JSON deserialization method that retrieves a genome instance from its json representation\n\n If specific json schema is provided, it is utilized, and if not, a class specific is used" }, { "code": "def upload_content(self, synchronous=True, **kwargs):\n kwargs = kwargs.copy()\n kwargs.update(self._server_config.get_client_kwargs())\n response = client.post(self.path('upload_content'), **kwargs)\n json = _handle_response(response, self._server_config, synchronous)\n if json['status'] != 'success':\n raise APIResponseError(\n 'Received error when uploading file {0} to repository {1}: {2}'\n .format(kwargs.get('files'), self.id, json)\n )\n return json", "docstring": "Upload a file or files to the current repository.\n\n Here is an example of how to upload content::\n\n with open('my_content.rpm') as content:\n repo.upload_content(files={'content': content})\n\n This method accepts the same keyword arguments as Requests. As a\n result, the following examples can be adapted for use here:\n\n * `POST a Multipart-Encoded File`_\n * `POST Multiple Multipart-Encoded Files`_\n\n :param synchronous: What should happen if the server returns an HTTP\n 202 (accepted) status code? Wait for the task to complete if\n ``True``. Immediately return the server's response otherwise.\n :param kwargs: Arguments to pass to requests.\n :returns: The server's response, with all JSON decoded.\n :raises: ``requests.exceptions.HTTPError`` If the server responds with\n an HTTP 4XX or 5XX message.\n :raises nailgun.entities.APIResponseError: If the response has a status\n other than \"success\".\n\n .. _POST a Multipart-Encoded File:\n http://docs.python-requests.org/en/latest/user/quickstart/#post-a-multipart-encoded-file\n .. _POST Multiple Multipart-Encoded Files:\n http://docs.python-requests.org/en/latest/user/advanced/#post-multiple-multipart-encoded-files" }, { "code": "def copy(self, deep=True):\n from copy import copy, deepcopy\n if deep:\n return deepcopy(self)\n else:\n return copy(self)", "docstring": "Make a copy of this object\n\n Parameters\n ----------\n deep : boolean, default True\n Make a deep copy, i.e. also copy data\n\n Returns\n -------\n copy : type of caller" }, { "code": "def _parse_file():\n file_name = path.join(\n path.abspath(path.dirname(path.dirname(__file__))), 'config.json'\n )\n logger.info('loading configuration from file: %r', file_name)\n try:\n data = _read_file(file_name)\n except FileNotFoundError:\n logger.error('no configuration available, set FLASH_CONFIG or '\n 'provide config.json')\n exit()\n for service in data.get('services', []):\n for key, val in service.items():\n if isinstance(val, str) and re.match(r'^\\$[A-Z_]+$', val):\n env_val = getenv(val[1:])\n if env_val is None:\n logger.warning('environment variable %r not found', val[1:])\n service[key] = env_val or val\n return data", "docstring": "Parse the config from a file.\n\n Note:\n Assumes any value that ``\"$LOOKS_LIKE_THIS\"`` in a service\n definition refers to an environment variable, and attempts to get\n it accordingly." }, { "code": "def tmp(p_queue, host=None):\n if host is not None:\n return _path(_c.FSQ_TMP, root=_path(host, root=hosts(p_queue)))\n return _path(p_queue, _c.FSQ_TMP)", "docstring": "Construct a path to the tmp dir for a queue" }, { "code": "def _get_request_fields_from_parent(self):\n if not self.parent:\n return None\n if not getattr(self.parent, 'request_fields'):\n return None\n if not isinstance(self.parent.request_fields, dict):\n return None\n return self.parent.request_fields.get(self.field_name)", "docstring": "Get request fields from the parent serializer." }, { "code": "def release_subnet(self, cidr, direc):\n if direc == 'in':\n self.service_in_ip.release_subnet(cidr)\n else:\n self.service_out_ip.release_subnet(cidr)", "docstring": "Routine to release a subnet from the DB." }, { "code": "def list(self, request):\n max_items_per_page = getattr(self, 'max_per_page',\n getattr(settings, 'AJAX_MAX_PER_PAGE', 100))\n requested_items_per_page = request.POST.get(\"items_per_page\", 20)\n items_per_page = min(max_items_per_page, requested_items_per_page)\n current_page = request.POST.get(\"current_page\", 1)\n if not self.can_list(request.user):\n raise AJAXError(403, _(\"Access to this endpoint is forbidden\"))\n objects = self.get_queryset(request)\n paginator = Paginator(objects, items_per_page)\n try:\n page = paginator.page(current_page)\n except PageNotAnInteger:\n page = paginator.page(1)\n except EmptyPage:\n page = EmptyPageResult()\n data = [encoder.encode(record) for record in page.object_list]\n return EnvelopedResponse(data=data, metadata={'total': paginator.count})", "docstring": "List objects of a model. By default will show page 1 with 20 objects on it.\n\n **Usage**::\n\n params = {\"items_per_page\":10,\"page\":2} //all params are optional\n $.post(\"/ajax/{app}/{model}/list.json\"),params)" }, { "code": "def parse_skypos(ra, dec):\n rval = make_val_float(ra)\n dval = make_val_float(dec)\n if rval is None:\n rval, dval = radec_hmstodd(ra, dec)\n return rval, dval", "docstring": "Function to parse RA and Dec input values and turn them into decimal\n degrees\n\n Input formats could be:\n [\"nn\",\"nn\",\"nn.nn\"]\n \"nn nn nn.nnn\"\n \"nn:nn:nn.nn\"\n \"nnH nnM nn.nnS\" or \"nnD nnM nn.nnS\"\n nn.nnnnnnnn\n \"nn.nnnnnnn\"" }, { "code": "def mfpt(totflux, pi, qminus):\n r\n return dense.tpt.mfpt(totflux, pi, qminus)", "docstring": "r\"\"\"Mean first passage time for reaction A to B.\n\n Parameters\n ----------\n totflux : float\n The total flux between reactant and product\n pi : (M,) ndarray\n Stationary distribution\n qminus : (M,) ndarray\n Backward comittor\n\n Returns\n -------\n tAB : float\n The mean first-passage time for the A to B reaction\n\n See also\n --------\n rate\n\n Notes\n -----\n Equal to the inverse rate, see [1].\n\n References\n ----------\n .. [1] F. Noe, Ch. Schuette, E. Vanden-Eijnden, L. Reich and\n T. Weikl: Constructing the Full Ensemble of Folding Pathways\n from Short Off-Equilibrium Simulations.\n Proc. Natl. Acad. Sci. USA, 106, 19011-19016 (2009)" }, { "code": "def is_supported():\n on_supported_platform = False\n if salt.utils.platform.is_sunos():\n on_supported_platform = True\n elif salt.utils.platform.is_freebsd() and _check_retcode('kldstat -q -m zfs'):\n on_supported_platform = True\n elif salt.utils.platform.is_linux() and os.path.exists('/sys/module/zfs'):\n on_supported_platform = True\n elif salt.utils.platform.is_linux() and salt.utils.path.which('zfs-fuse'):\n on_supported_platform = True\n elif salt.utils.platform.is_darwin() and \\\n os.path.exists('/Library/Extensions/zfs.kext') and \\\n os.path.exists('/dev/zfs'):\n on_supported_platform = True\n return (salt.utils.path.which('zpool') and on_supported_platform) is True", "docstring": "Check the system for ZFS support" }, { "code": "def write_temp_file(self, content, filename=None, mode='w'):\n if filename is None:\n filename = str(uuid.uuid4())\n fqpn = os.path.join(self.tcex.default_args.tc_temp_path, filename)\n with open(fqpn, mode) as fh:\n fh.write(content)\n return fqpn", "docstring": "Write content to a temporary file.\n\n Args:\n content (bytes|str): The file content. If passing binary data the mode needs to be set\n to 'wb'.\n filename (str, optional): The filename to use when writing the file.\n mode (str, optional): The file write mode which could be either 'w' or 'wb'.\n\n Returns:\n str: Fully qualified path name for the file." }, { "code": "def url_view(url_pattern, name=None, priority=None):\n def meta_wrapper(func):\n @functools.wraps(func)\n def wrapper(*args, **kwargs):\n return func(*args, **kwargs)\n wrapper.urljects_view = True\n wrapper.url = url_pattern\n wrapper.url_name = name or func.__name__\n wrapper.url_priority = priority\n return wrapper\n return meta_wrapper", "docstring": "Decorator for registering functional views.\n Meta decorator syntax has to be used in order to accept arguments.\n\n This decorator does not really do anything that magical:\n\n This:\n >>> from urljects import U, url_view\n >>> @url_view(U / 'my_view')\n ... def my_view(request)\n ... pass\n\n is equivalent to this:\n >>> def my_view(request)\n ... pass\n >>> my_view.urljects_view = True\n >>> my_view.url = U / 'my_view'\n >>> my_view.url_name = 'my_view'\n\n Those view are then supposed to be used with ``view_include`` which will\n register all views that have ``urljects_view`` set to ``True``.\n\n :param url_pattern: regex or URLPattern or anything passable to url()\n :param name: name of the view, __name__ will be used otherwise.\n :param priority: priority of the view, the lower the better" }, { "code": "def _get_meaning(value_pb, is_list=False):\n meaning = None\n if is_list:\n if len(value_pb.array_value.values) == 0:\n return None\n all_meanings = [\n _get_meaning(sub_value_pb) for sub_value_pb in value_pb.array_value.values\n ]\n unique_meanings = set(all_meanings)\n if len(unique_meanings) == 1:\n meaning = unique_meanings.pop()\n else:\n meaning = all_meanings\n elif value_pb.meaning:\n meaning = value_pb.meaning\n return meaning", "docstring": "Get the meaning from a protobuf value.\n\n :type value_pb: :class:`.entity_pb2.Value`\n :param value_pb: The protobuf value to be checked for an\n associated meaning.\n\n :type is_list: bool\n :param is_list: Boolean indicating if the ``value_pb`` contains\n a list value.\n\n :rtype: int\n :returns: The meaning for the ``value_pb`` if one is set, else\n :data:`None`. For a list value, if there are disagreeing\n means it just returns a list of meanings. If all the\n list meanings agree, it just condenses them." }, { "code": "def find_element(driver, elem_path, by=CSS, timeout=TIMEOUT, poll_frequency=0.5):\n wait = WebDriverWait(driver, timeout, poll_frequency)\n return wait.until(EC.presence_of_element_located((by, elem_path)))", "docstring": "Find and return an element once located\n\n find_element locates an element on the page, waiting\n for up to timeout seconds. The element, when located,\n is returned. If not located, a TimeoutException is raised.\n\n Args:\n driver (selenium webdriver or element): A driver or element\n elem_path (str): String used to located the element\n by (selenium By): Selenium By reference\n timeout (int): Selenium Wait timeout, in seconds\n poll_frequency (float): Selenium Wait polling frequency, in seconds\n\n Returns:\n element: Selenium element\n\n Raises:\n TimeoutException: Raised when target element isn't located" }, { "code": "def exit_statistics(hostname, start_time, count_sent, count_received, min_time, avg_time, max_time, deviation):\n end_time = datetime.datetime.now()\n duration = end_time - start_time\n duration_sec = float(duration.seconds * 1000)\n duration_ms = float(duration.microseconds / 1000)\n duration = duration_sec + duration_ms\n package_loss = 100 - ((float(count_received) / float(count_sent)) * 100)\n print(f'\\b\\b--- {hostname} ping statistics ---')\n try:\n print(f'{count_sent} packages transmitted, {count_received} received, {package_loss}% package loss, time {duration}ms')\n except ZeroDivisionError:\n print(f'{count_sent} packets transmitted, {count_received} received, 100% packet loss, time {duration}ms')\n print(\n 'rtt min/avg/max/dev = %.2f/%.2f/%.2f/%.2f ms' % (\n min_time.seconds*1000 + float(min_time.microseconds)/1000,\n float(avg_time) / 1000,\n max_time.seconds*1000 + float(max_time.microseconds)/1000,\n float(deviation)\n )\n )", "docstring": "Print ping exit statistics" }, { "code": "def _get_subelements(self, node):\n items = node.find('rdf:Alt', self.NS)\n if items is not None:\n try:\n return items[0].text\n except IndexError:\n return ''\n for xmlcontainer, container, insertfn in XMP_CONTAINERS:\n items = node.find('rdf:{}'.format(xmlcontainer), self.NS)\n if items is None:\n continue\n result = container()\n for item in items:\n insertfn(result, item.text)\n return result\n return ''", "docstring": "Gather the sub-elements attached to a node\n\n Gather rdf:Bag and and rdf:Seq into set and list respectively. For\n alternate languages values, take the first language only for\n simplicity." }, { "code": "def _sigma_pi_midE(self, Tp):\n m_p = self._m_p\n Qp = (Tp - self._Tth) / m_p\n multip = -6e-3 + 0.237 * Qp - 0.023 * Qp ** 2\n return self._sigma_inel(Tp) * multip", "docstring": "Geant 4.10.0 model for 2 GeV < Tp < 5 GeV" }, { "code": "def ts_stats_significance(ts, ts_stat_func, null_ts_func, B=1000, permute_fast=False):\n stats_ts = ts_stat_func(ts)\n if permute_fast:\n null_ts = map(np.random.permutation, np.array([ts, ] * B))\n else:\n null_ts = np.vstack([null_ts_func(ts) for i in np.arange(0, B)])\n stats_null_ts = np.vstack([ts_stat_func(nts) for nts in null_ts])\n pvals = []\n nums = []\n for i in np.arange(0, len(stats_ts)):\n num_samples = np.sum((stats_null_ts[:, i] >= stats_ts[i]))\n nums.append(num_samples)\n pval = num_samples / float(B)\n pvals.append(pval)\n return stats_ts, pvals, nums", "docstring": "Compute the statistical significance of a test statistic at each point\n of the time series." }, { "code": "def breathe_identifier(self):\n if self.kind == \"function\":\n return \"{name}({parameters})\".format(\n name=self.name,\n parameters=\", \".join(self.parameters)\n )\n return self.name", "docstring": "The unique identifier for breathe directives.\n\n .. note::\n\n This method is currently assumed to only be called for nodes that are\n in :data:`exhale.utils.LEAF_LIKE_KINDS` (see also\n :func:`exhale.graph.ExhaleRoot.generateSingleNodeRST` where it is used).\n\n **Return**\n\n :class:`python:str`\n Usually, this will just be ``self.name``. However, for functions in\n particular the signature must be included to distinguish overloads." }, { "code": "def table(name=None, mode='create', use_cache=True, priority='interactive',\n allow_large_results=False):\n output = QueryOutput()\n output._output_type = 'table'\n output._table_name = name\n output._table_mode = mode\n output._use_cache = use_cache\n output._priority = priority\n output._allow_large_results = allow_large_results\n return output", "docstring": "Construct a query output object where the result is a table\n\n Args:\n name: the result table name as a string or TableName; if None (the default), then a\n temporary table will be used.\n table_mode: one of 'create', 'overwrite' or 'append'. If 'create' (the default), the request\n will fail if the table exists.\n use_cache: whether to use past query results or ignore cache. Has no effect if destination is\n specified (default True).\n priority:one of 'batch' or 'interactive' (default). 'interactive' jobs should be scheduled\n to run quickly but are subject to rate limits; 'batch' jobs could be delayed by as much\n as three hours but are not rate-limited.\n allow_large_results: whether to allow large results; i.e. compressed data over 100MB. This is\n slower and requires a name to be specified) (default False)." }, { "code": "def get_version(filename):\n with open(filename) as in_fh:\n for line in in_fh:\n if line.startswith('__version__'):\n return line.split('=')[1].strip()[1:-1]\n raise ValueError(\"Cannot extract version from %s\" % filename)", "docstring": "Extract the package version" }, { "code": "def load_notebook(fullname: str):\n shell = InteractiveShell.instance()\n path = fullname\n with open(path, 'r', encoding='utf-8') as f:\n notebook = read(f, 4)\n mod = types.ModuleType(fullname)\n mod.__file__ = path\n mod.__dict__['get_ipython'] = get_ipython\n sys.modules[fullname] = mod\n save_user_ns = shell.user_ns\n shell.user_ns = mod.__dict__\n try:\n for cell in notebook.cells:\n if cell.cell_type == 'code':\n try:\n ast.parse(cell.source)\n except SyntaxError:\n continue\n try:\n exec(cell.source, mod.__dict__)\n except NameError:\n print(cell.source)\n raise\n finally:\n shell.user_ns = save_user_ns\n return mod", "docstring": "Import a notebook as a module." }, { "code": "def display_element_selected(self, f):\n self._display_element_selected_func = f\n @wraps(f)\n def wrapper(*args, **kw):\n self._flask_view_func(*args, **kw)\n return f", "docstring": "Decorator routes Alexa Display.ElementSelected request to the wrapped view function.\n\n @ask.display_element_selected\n def eval_element():\n return \"\", 200\n\n The wrapped function is registered as the display_element_selected view function\n and renders the response for requests.\n\n Arguments:\n f {function} -- display_element_selected view function" }, { "code": "def file_w_create_directories(filepath):\n dirname = os.path.dirname(filepath)\n if dirname and dirname != os.path.curdir and not os.path.isdir(dirname):\n os.makedirs(dirname)\n return open(filepath, 'w')", "docstring": "Recursively create some directories if needed so that the directory where\n @filepath must be written exists, then open it in \"w\" mode and return the\n file object." }, { "code": "def get_start_time(self):\n start_time = c_double()\n self.library.get_start_time.argtypes = [POINTER(c_double)]\n self.library.get_start_time.restype = None\n self.library.get_start_time(byref(start_time))\n return start_time.value", "docstring": "returns start time" }, { "code": "def duration(self):\n self._duration = self.lib.iperf_get_test_duration(self._test)\n return self._duration", "docstring": "The test duration in seconds." }, { "code": "def sync_and_deploy_gateway(collector):\n configuration = collector.configuration\n aws_syncr = configuration['aws_syncr']\n find_gateway(aws_syncr, configuration)\n artifact = aws_syncr.artifact\n aws_syncr.artifact = \"\"\n sync(collector)\n aws_syncr.artifact = artifact\n deploy_gateway(collector)", "docstring": "Do a sync followed by deploying the gateway" }, { "code": "def generate_key(block_size=32):\n random_seq = os.urandom(block_size)\n random_key = base64.b64encode(random_seq)\n return random_key", "docstring": "Generate random key for ope cipher.\n\n Parameters\n ----------\n block_size : int, optional\n Length of random bytes.\n\n Returns\n -------\n random_key : str\n A random key for encryption.\n\n Notes:\n ------\n Implementation follows https://github.com/pyca/cryptography" }, { "code": "def save_proficiency(self, proficiency_form, *args, **kwargs):\n if proficiency_form.is_for_update():\n return self.update_proficiency(proficiency_form, *args, **kwargs)\n else:\n return self.create_proficiency(proficiency_form, *args, **kwargs)", "docstring": "Pass through to provider ProficiencyAdminSession.update_proficiency" }, { "code": "def sort_resources(cls, request, resources, fail_enum, header_proto=None):\n if not request.sorting:\n return resources\n value_handlers = cls._get_handler_set(request, fail_enum, header_proto)\n def sorter(resource_a, resource_b):\n for handler in value_handlers:\n val_a, val_b = handler.get_sort_values(resource_a, resource_b)\n if val_a < val_b:\n return handler.xform_result(-1)\n if val_a > val_b:\n return handler.xform_result(1)\n return 0\n return sorted(resources, key=cmp_to_key(sorter))", "docstring": "Sorts a list of resources based on a list of sort controls\n\n Args:\n request (object): The parsed protobuf request object\n resources (list of objects): The resources to be sorted\n fail_enum (int, enum): The enum status to raise with invalid keys\n header_proto(class): Class to decode a resources header\n\n Returns:\n list: The sorted list of resources" }, { "code": "def generate_token(self):\n response = self._make_request()\n self.auth = response\n self.token = response['token']", "docstring": "Make request in API to generate a token." }, { "code": "def on_interesting_rts_change(self, new_global_rts, removed_global_rts):\n if new_global_rts:\n LOG.debug(\n 'Sending route_refresh to all neighbors that'\n ' did not negotiate RTC capability.'\n )\n pm = self._core_service.peer_manager\n pm.schedule_rr_to_non_rtc_peers()\n if removed_global_rts:\n LOG.debug(\n 'Cleaning up global tables as some interested RTs were removed'\n )\n self._clean_global_uninteresting_paths()", "docstring": "Update global tables as interested RTs changed.\n\n Adds `new_rts` and removes `removed_rts` rt nlris. Does not check if\n `new_rts` or `removed_rts` are already present. Schedules refresh\n request to peers that do not participate in RTC address-family." }, { "code": "def circular_pores(target, pore_diameter='pore.diameter',\n throat_diameter='throat.diameter',\n throat_centroid='throat.centroid'):\n r\n return spherical_pores(target=target, pore_diameter=pore_diameter,\n throat_diameter=throat_diameter)", "docstring": "r\"\"\"\n Calculate the coordinates of throat endpoints, assuming circular pores.\n This model accounts for the overlapping lens between pores and throats.\n\n Parameters\n ----------\n target : OpenPNM Object\n The object which this model is associated with. This controls the\n length of the calculated array, and also provides access to other\n necessary properties.\n\n pore_diameter : string\n Dictionary key of the pore diameter values.\n\n throat_diameter : string\n Dictionary key of the throat diameter values.\n\n throat_centroid : string, optional\n Dictionary key of the throat centroid values. See the notes.\n\n Returns\n -------\n EP : dictionary\n Coordinates of throat endpoints stored in Dict form. Can be accessed\n via the dict keys 'head' and 'tail'.\n\n Notes\n -----\n (1) This model should only be applied to ture 2D networks.\n\n (2) By default, this model assumes that throat centroid and pore\n coordinates are colinear. If that's not the case, such as in extracted\n networks, `throat_centroid` could be passed as an optional argument, and\n the model takes care of the rest." }, { "code": "def do_diff(self, params):\n count = 0\n for count, (diff, path) in enumerate(self._zk.diff(params.path_a, params.path_b), 1):\n if diff == -1:\n self.show_output(\"-- %s\", path)\n elif diff == 0:\n self.show_output(\"-+ %s\", path)\n elif diff == 1:\n self.show_output(\"++ %s\", path)\n if count == 0:\n self.show_output(\"Branches are equal.\")", "docstring": "\\x1b[1mNAME\\x1b[0m\n diff - Display the differences between two paths\n\n\\x1b[1mSYNOPSIS\\x1b[0m\n diff \n\n\\x1b[1mDESCRIPTION\\x1b[0m\n The output is interpreted as:\n -- means the znode is missing in /new-configs\n ++ means the znode is new in /new-configs\n +- means the znode's content differ between /configs and /new-configs\n\n\\x1b[1mEXAMPLES\\x1b[0m\n > diff /configs /new-configs\n -- service-x/hosts\n ++ service-x/hosts.json\n +- service-x/params" }, { "code": "def config_keys(self, sortkey = False):\n if sortkey:\n items = sorted(self.items())\n else:\n items = self.items()\n for k,v in items:\n if isinstance(v, ConfigTree):\n for k2 in v.config_keys(sortkey):\n yield k + '.' + k2\n else:\n yield k", "docstring": "Return all configuration keys in this node, including configurations on children nodes." }, { "code": "def validate(data):\n text = data.get('text')\n if not isinstance(text, _string_types) or len(text) == 0:\n raise ValueError('text field is required and should not be empty')\n if 'markdown' in data and not type(data['markdown']) is bool:\n raise ValueError('markdown field should be bool')\n if 'attachments' in data:\n if not isinstance(data['attachments'], (list, tuple)):\n raise ValueError('attachments field should be list or tuple')\n for attachment in data['attachments']:\n if 'text' not in attachment and 'title' not in attachment:\n raise ValueError('text or title is required in attachment')\n return True", "docstring": "Validates incoming data\n\n Args:\n data(dict): the incoming data\n\n Returns:\n True if the data is valid\n\n Raises:\n ValueError: the data is not valid" }, { "code": "def surface_measure(self, param):\n scalar_out = (np.shape(param) == ())\n param = np.array(param, dtype=float, copy=False, ndmin=1)\n if self.check_bounds and not is_inside_bounds(param, self.params):\n raise ValueError('`param` {} not in the valid range '\n '{}'.format(param, self.params))\n if scalar_out:\n return self.radius\n else:\n return self.radius * np.ones(param.shape)", "docstring": "Return the arc length measure at ``param``.\n\n This is a constant function evaluating to `radius` everywhere.\n\n Parameters\n ----------\n param : float or `array-like`\n Parameter value(s) at which to evaluate.\n\n Returns\n -------\n measure : float or `numpy.ndarray`\n Constant value(s) of the arc length measure at ``param``.\n If ``param`` is a single parameter, a float is returned,\n otherwise an array of shape ``param.shape``.\n\n See Also\n --------\n surface\n surface_deriv\n\n Examples\n --------\n The method works with a single parameter, resulting in a float:\n\n >>> part = odl.uniform_partition(-np.pi / 2, np.pi / 2, 10)\n >>> det = CircularDetector(part, axis=[1, 0], radius=2)\n >>> det.surface_measure(0)\n 2.0\n >>> det.surface_measure(np.pi / 2)\n 2.0\n\n It is also vectorized, i.e., it can be called with multiple\n parameters at once (or an n-dimensional array of parameters):\n\n >>> det.surface_measure([0, np.pi / 2])\n array([ 2., 2.])\n >>> det.surface_measure(np.zeros((4, 5))).shape\n (4, 5)" }, { "code": "def upload_path(instance, filename):\n filename = filename.replace(\" \", \"_\")\n filename = unicodedata.normalize('NFKD', filename).lower()\n return os.path.join(str(timezone.now().date().isoformat()), filename)", "docstring": "Sanitize the user-provided file name, add timestamp for uniqness." }, { "code": "def get_session(username, password, cookie_path=COOKIE_PATH, cache=True,\n cache_expiry=300, cache_path=CACHE_PATH, driver='phantomjs'):\n class USPSAuth(AuthBase):\n def __init__(self, username, password, cookie_path, driver):\n self.username = username\n self.password = password\n self.cookie_path = cookie_path\n self.driver = driver\n def __call__(self, r):\n return r\n session = requests.Session()\n if cache:\n session = requests_cache.core.CachedSession(cache_name=cache_path,\n expire_after=cache_expiry)\n session.auth = USPSAuth(username, password, cookie_path, driver)\n session.headers.update({'User-Agent': USER_AGENT})\n if os.path.exists(cookie_path):\n _LOGGER.debug(\"cookie found at: %s\", cookie_path)\n session.cookies = _load_cookies(cookie_path)\n else:\n _login(session)\n return session", "docstring": "Get session, existing or new." }, { "code": "def _identity(self, *args, **kwargs):\n LOCAL = 'local accounts'\n EXT = 'external accounts'\n data = dict()\n data[LOCAL] = self._get_local_users(disabled=kwargs.get('disabled'))\n data[EXT] = self._get_external_accounts(data[LOCAL].keys()) or 'N/A'\n data['local groups'] = self._get_local_groups()\n return data", "docstring": "Local users and groups.\n\n accounts\n Can be either 'local', 'remote' or 'all' (equal to \"local,remote\").\n Remote accounts cannot be resolved on all systems, but only\n those, which supports 'passwd -S -a'.\n\n disabled\n True (or False, default) to return only disabled accounts." }, { "code": "def bulk_create(self, *args, **kwargs):\n ret_val = super(ManagerUtilsQuerySet, self).bulk_create(*args, **kwargs)\n post_bulk_operation.send(sender=self.model, model=self.model)\n return ret_val", "docstring": "Overrides Django's bulk_create function to emit a post_bulk_operation signal when bulk_create\n is finished." }, { "code": "def get_actions(self, request):\n actions = super(CertificateMixin, self).get_actions(request)\n actions.pop('delete_selected', '')\n return actions", "docstring": "Disable the \"delete selected\" admin action.\n\n Otherwise the action is present even though has_delete_permission is False, it just doesn't\n work." }, { "code": "def square_off(series, time_delta=None, transition_seconds=1):\n if time_delta:\n if isinstance(time_delta, (int, float)):\n time_delta = datetime.timedelta(0, time_delta)\n new_times = series.index + time_delta\n else:\n diff = np.diff(series.index)\n time_delta = np.append(diff, [diff[-1]])\n new_times = series.index + time_delta\n new_times = pd.DatetimeIndex(new_times) - datetime.timedelta(0, transition_seconds)\n return pd.concat([series, pd.Series(series.values, index=new_times)]).sort_index()", "docstring": "Insert samples in regularly sampled data to produce stairsteps from ramps when plotted.\n\n New samples are 1 second (1e9 ns) before each existing samples, to facilitate plotting and sorting\n\n >>> square_off(pd.Series(range(3), index=pd.date_range('2014-01-01', periods=3, freq='15m')),\n ... time_delta=5.5) # doctest: +NORMALIZE_WHITESPACE\n 2014-01-31 00:00:00 0\n 2014-01-31 00:00:05.500000 0\n 2015-04-30 00:00:00 1\n 2015-04-30 00:00:05.500000 1\n 2016-07-31 00:00:00 2\n 2016-07-31 00:00:05.500000 2\n dtype: int64\n >>> square_off(pd.Series(range(2), index=pd.date_range('2014-01-01', periods=2, freq='15min')),\n ... transition_seconds=2.5) # doctest: +NORMALIZE_WHITESPACE\n 2014-01-01 00:00:00 0\n 2014-01-01 00:14:57.500000 0\n 2014-01-01 00:15:00 1\n 2014-01-01 00:29:57.500000 1\n dtype: int64" }, { "code": "def write(text, delay=0, restore_state_after=True, exact=None):\n if exact is None:\n exact = _platform.system() == 'Windows'\n state = stash_state()\n if exact:\n for letter in text:\n if letter in '\\n\\b':\n send(letter)\n else:\n _os_keyboard.type_unicode(letter)\n if delay: _time.sleep(delay)\n else:\n for letter in text:\n try:\n entries = _os_keyboard.map_name(normalize_name(letter))\n scan_code, modifiers = next(iter(entries))\n except (KeyError, ValueError):\n _os_keyboard.type_unicode(letter)\n continue\n for modifier in modifiers:\n press(modifier)\n _os_keyboard.press(scan_code)\n _os_keyboard.release(scan_code)\n for modifier in modifiers:\n release(modifier)\n if delay:\n _time.sleep(delay)\n if restore_state_after:\n restore_modifiers(state)", "docstring": "Sends artificial keyboard events to the OS, simulating the typing of a given\n text. Characters not available on the keyboard are typed as explicit unicode\n characters using OS-specific functionality, such as alt+codepoint.\n\n To ensure text integrity, all currently pressed keys are released before\n the text is typed, and modifiers are restored afterwards.\n\n - `delay` is the number of seconds to wait between keypresses, defaults to\n no delay.\n - `restore_state_after` can be used to restore the state of pressed keys\n after the text is typed, i.e. presses the keys that were released at the\n beginning. Defaults to True.\n - `exact` forces typing all characters as explicit unicode (e.g.\n alt+codepoint or special events). If None, uses platform-specific suggested\n value." }, { "code": "def shutdown(opts):\n log.debug('dummy proxy shutdown() called...')\n DETAILS = _load_state()\n if 'filename' in DETAILS:\n os.unlink(DETAILS['filename'])", "docstring": "For this proxy shutdown is a no-op" }, { "code": "def _diff_interface_lists(old, new):\n diff = _diff_lists(old, new, _nics_equal)\n macs = [nic.find('mac').get('address') for nic in diff['unchanged']]\n for nic in diff['new']:\n mac = nic.find('mac')\n if mac.get('address') in macs:\n nic.remove(mac)\n return diff", "docstring": "Compare network interface definitions to extract the changes\n\n :param old: list of ElementTree nodes representing the old interfaces\n :param new: list of ElementTree nodes representing the new interfaces" }, { "code": "def _project_eigenvectors(self):\n self._p_eigenvectors = []\n for vecs_q in self._eigenvectors:\n p_vecs_q = []\n for vecs in vecs_q.T:\n p_vecs_q.append(np.dot(vecs.reshape(-1, 3),\n self._projection_direction))\n self._p_eigenvectors.append(np.transpose(p_vecs_q))\n self._p_eigenvectors = np.array(self._p_eigenvectors)", "docstring": "Eigenvectors are projected along Cartesian direction" }, { "code": "def setMAC(self, xEUI):\n print '%s call setMAC' % self.port\n address64 = ''\n try:\n if not xEUI:\n address64 = self.mac\n if not isinstance(xEUI, str):\n address64 = self.__convertLongToString(xEUI)\n if len(address64) < 16:\n address64 = address64.zfill(16)\n print address64\n else:\n address64 = xEUI\n cmd = WPANCTL_CMD + 'setprop NCP:MACAddress %s' % address64\n if self.__sendCommand(cmd)[0] != 'Fail':\n self.mac = address64\n return True\n else:\n return False\n except Exception, e:\n ModuleHelper.WriteIntoDebugLogger('setMAC() Error: ' + str(e))", "docstring": "set the extended addresss of Thread device\n\n Args:\n xEUI: extended address in hex format\n\n Returns:\n True: successful to set the extended address\n False: fail to set the extended address" }, { "code": "def _to_json_type(obj, classkey=None):\n if isinstance(obj, dict):\n data = {}\n for (k, v) in obj.items():\n data[k] = _to_json_type(v, classkey)\n return data\n elif hasattr(obj, \"_ast\"):\n return _to_json_type(obj._ast())\n elif hasattr(obj, \"__iter__\"):\n return [_to_json_type(v, classkey) for v in obj]\n elif hasattr(obj, \"__dict__\"):\n data = dict([\n (key, _to_json_type(value, classkey))\n for key, value in obj.__dict__.iteritems()\n if not callable(value) and not key.startswith('_')\n ])\n if classkey is not None and hasattr(obj, \"__class__\"):\n data[classkey] = obj.__class__.__name__\n return data\n else:\n return obj", "docstring": "Recursively convert the object instance into a valid JSON type." }, { "code": "def _costfcn(self, x):\n f = self._f(x)\n df = self._df(x)\n d2f = self._d2f(x)\n return f, df, d2f", "docstring": "Evaluates the objective function, gradient and Hessian for OPF." }, { "code": "def label(self, input_grid):\n marked = self.find_local_maxima(input_grid)\n marked = np.where(marked >= 0, 1, 0)\n markers = splabel(marked)[0]\n return markers", "docstring": "Labels input grid using enhanced watershed algorithm.\n\n Args:\n input_grid (numpy.ndarray): Grid to be labeled.\n\n Returns:\n Array of labeled pixels" }, { "code": "def check_input_files(self,\n return_found=True,\n return_missing=True):\n all_input_files = self.files.chain_input_files + self.sub_files.chain_input_files\n return check_files(all_input_files, self._file_stage,\n return_found, return_missing)", "docstring": "Check if input files exist.\n\n Parameters\n ----------\n return_found : list\n A list with the paths of the files that were found.\n\n return_missing : list\n A list with the paths of the files that were missing.\n\n Returns\n -------\n found : list\n List of the found files, if requested, otherwise `None`\n\n missing : list\n List of the missing files, if requested, otherwise `None`" }, { "code": "def _post_activity(self, activity, unserialize=True):\n feed_url = \"{proto}://{server}/api/user/{username}/feed\".format(\n proto=self._pump.protocol,\n server=self._pump.client.server,\n username=self._pump.client.nickname\n )\n data = self._pump.request(feed_url, method=\"POST\", data=activity)\n if not data:\n return False\n if \"error\" in data:\n raise PumpException(data[\"error\"])\n if unserialize:\n if \"target\" in data:\n self.unserialize(data[\"target\"])\n else:\n if \"author\" not in data[\"object\"]:\n data[\"object\"][\"author\"] = data[\"actor\"]\n for key in [\"to\", \"cc\", \"bto\", \"bcc\"]:\n if key not in data[\"object\"] and key in data:\n data[\"object\"][key] = data[key]\n self.unserialize(data[\"object\"])\n return True", "docstring": "Posts a activity to feed" }, { "code": "def __getAvatar(self, web):\n try:\n self.avatar = web.find(\"img\", {\"class\": \"avatar\"})['src'][:-10]\n except IndexError as error:\n print(\"There was an error with the user \" + self.name)\n print(error)\n except AttributeError as error:\n print(\"There was an error with the user \" + self.name)\n print(error)", "docstring": "Scrap the avatar from a GitHub profile.\n\n :param web: parsed web.\n :type web: BeautifulSoup node." }, { "code": "def get_output_margin(self, status=None):\n margin = self.get_reserved_space() + self.get_prompt(self.prompt).count('\\n') + 1\n if special.is_timing_enabled():\n margin += 1\n if status:\n margin += 1 + status.count('\\n')\n return margin", "docstring": "Get the output margin (number of rows for the prompt, footer and\n timing message." }, { "code": "def _save(self, url, path, data):\n worker = self._workers[url]\n path = self._paths[url]\n if len(data):\n try:\n with open(path, 'wb') as f:\n f.write(data)\n except Exception:\n logger.error((url, path))\n worker.finished = True\n worker.sig_download_finished.emit(url, path)\n worker.sig_finished.emit(worker, path, None)\n self._get_requests.pop(url)\n self._workers.pop(url)\n self._paths.pop(url)", "docstring": "Save `data` of downloaded `url` in `path`." }, { "code": "def etree_to_string(tree):\n buff = BytesIO()\n tree.write(buff, xml_declaration=True, encoding='UTF-8')\n return buff.getvalue()", "docstring": "Creates string from lxml.etree.ElementTree with XML declaration and UTF-8 encoding.\n\n :param tree: the instance of ElementTree\n :return: the string of XML." }, { "code": "def is_newer_file(a, b):\n if not (op.exists(a) and op.exists(b)):\n return False\n am = os.stat(a).st_mtime\n bm = os.stat(b).st_mtime\n return am > bm", "docstring": "Check if the file a is newer than file b" }, { "code": "def main():\n try:\n device = AlarmDecoder(SerialDevice(interface=SERIAL_DEVICE))\n device.on_zone_fault += handle_zone_fault\n device.on_zone_restore += handle_zone_restore\n with device.open(baudrate=BAUDRATE):\n last_update = time.time()\n while True:\n if time.time() - last_update > WAIT_TIME:\n last_update = time.time()\n device.fault_zone(TARGET_ZONE)\n time.sleep(1)\n except Exception as ex:\n print('Exception:', ex)", "docstring": "Example application that periodically faults a virtual zone and then\n restores it.\n\n This is an advanced feature that allows you to emulate a virtual zone. When\n the AlarmDecoder is configured to emulate a zone expander we can fault and\n restore those zones programmatically at will. These events can also be seen by\n others, such as home automation platforms which allows you to connect other\n devices or services and monitor them as you would any physical zone.\n\n For example, you could connect a ZigBee device and receiver and fault or\n restore it's zone(s) based on the data received.\n\n In order for this to happen you need to perform a couple configuration steps:\n\n 1. Enable zone expander emulation on your AlarmDecoder device by hitting '!'\n in a terminal and going through the prompts.\n 2. Enable the zone expander in your panel programming." }, { "code": "def alarm_on_segfault(self, alarm):\n self.register_alarm(alarm)\n for alarm in listify(alarm):\n self._set('alarm-segfault', alarm.alias, multi=True)\n return self._section", "docstring": "Raise the specified alarm when the segmentation fault handler is executed.\n\n Sends a backtrace.\n\n :param AlarmType|list[AlarmType] alarm: Alarm." }, { "code": "def add_host(self, host_id=None, host='localhost', port=6379,\n unix_socket_path=None, db=0, password=None,\n ssl=False, ssl_options=None):\n if host_id is None:\n raise RuntimeError('Host ID is required')\n elif not isinstance(host_id, (int, long)):\n raise ValueError('The host ID has to be an integer')\n host_id = int(host_id)\n with self._lock:\n if host_id in self.hosts:\n raise TypeError('Two hosts share the same host id (%r)' %\n (host_id,))\n self.hosts[host_id] = HostInfo(host_id=host_id, host=host,\n port=port, db=db,\n unix_socket_path=unix_socket_path,\n password=password, ssl=ssl,\n ssl_options=ssl_options)\n self._hosts_age += 1", "docstring": "Adds a new host to the cluster. This is only really useful for\n unittests as normally hosts are added through the constructor and\n changes after the cluster has been used for the first time are\n unlikely to make sense." }, { "code": "async def tile(tile_number):\n try:\n tile = get_tile(tile_number)\n except TileOutOfBoundsError:\n abort(404)\n buf = BytesIO(tile.tobytes())\n tile.save(buf, 'JPEG')\n content = buf.getvalue()\n response = await make_response(content)\n response.headers['Content-Type'] = 'image/jpg'\n response.headers['Accept-Ranges'] = 'bytes'\n response.headers['Content-Length'] = str(len(content))\n return response", "docstring": "Handles GET requests for a tile number.\n\n :param int tile_number: Number of the tile between 0 and `max_tiles`^2.\n :raises HTTPError: 404 if tile exceeds `max_tiles`^2." }, { "code": "def check_fieldsets(*args, **kwargs):\n if hasattr(settings, \"CONFIG_FIELDSETS\") and settings.CONFIG_FIELDSETS:\n inconsistent_fieldnames = get_inconsistent_fieldnames()\n if inconsistent_fieldnames:\n return [\n checks.Warning(\n _(\n \"CONSTANCE_CONFIG_FIELDSETS is missing \"\n \"field(s) that exists in CONSTANCE_CONFIG.\"\n ),\n hint=\", \".join(sorted(inconsistent_fieldnames)),\n obj=\"settings.CONSTANCE_CONFIG\",\n id=\"constance.E001\",\n )\n ]\n return []", "docstring": "A Django system check to make sure that, if defined, CONFIG_FIELDSETS accounts for\n every entry in settings.CONFIG." }, { "code": "def load_fixture(self, body, attachment_bodies={}):\n doc = json.loads(body)\n self._documents[doc['_id']] = doc\n self._attachments[doc['_id']] = dict()\n for name in doc.get('_attachments', list()):\n attachment_body = attachment_bodies.get(name, 'stub')\n self._attachments[doc['_id']][name] = attachment_body", "docstring": "Loads the document into the database from json string. Fakes the\n attachments if necessary." }, { "code": "def operator_complexity(self):\n return sum([level.A.nnz for level in self.levels]) /\\\n float(self.levels[0].A.nnz)", "docstring": "Operator complexity of this multigrid hierarchy.\n\n Defined as:\n Number of nonzeros in the matrix on all levels /\n Number of nonzeros in the matrix on the finest level" }, { "code": "def _set_implied_name(self):\n\t\t\"Allow the name of this handler to default to the function name.\"\n\t\tif getattr(self, 'name', None) is None:\n\t\t\tself.name = self.func.__name__\n\t\tself.name = self.name.lower()", "docstring": "Allow the name of this handler to default to the function name." }, { "code": "def validate_number(self, number):\n if not isinstance(number, str):\n raise ElksException('Recipient phone number may not be empty')\n if number[0] == '+' and len(number) > 2 and len(number) < 16:\n return True\n else:\n raise ElksException(\"Phone number must be of format +CCCXXX...\")", "docstring": "Checks if a number looks somewhat like a E.164 number. Not an\n exhaustive check, as the API takes care of that" }, { "code": "def cmServiceRequest(PriorityLevel_presence=0):\n a = TpPd(pd=0x5)\n b = MessageType(mesType=0x24)\n c = CmServiceTypeAndCiphKeySeqNr()\n e = MobileStationClassmark2()\n f = MobileId()\n packet = a / b / c / e / f\n if PriorityLevel_presence is 1:\n g = PriorityLevelHdr(ieiPL=0x8, eightBitPL=0x0)\n packet = packet / g\n return packet", "docstring": "CM SERVICE REQUEST Section 9.2.9" }, { "code": "def secp256k1():\n GFp = FiniteField(2 ** 256 - 2 ** 32 - 977)\n ec = EllipticCurve(GFp, 0, 7)\n return ECDSA(ec, ec.point(0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798, 0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8), 2 ** 256 - 432420386565659656852420866394968145599)", "docstring": "create the secp256k1 curve" }, { "code": "def StartElement(self, name, attributes):\n if name == 'hierarchy':\n pass\n elif name == 'node':\n attributes['uniqueId'] = 'id/no_id/%d' % self.idCount\n bounds = re.split('[\\][,]', attributes['bounds'])\n attributes['bounds'] = ((int(bounds[1]), int(bounds[2])), (int(bounds[4]), int(bounds[5])))\n if DEBUG_BOUNDS:\n print >> sys.stderr, \"bounds=\", attributes['bounds']\n self.idCount += 1\n child = View.factory(attributes, self.device, version=self.version, uiAutomatorHelper=self.uiAutomatorHelper)\n self.views.append(child)\n if not self.nodeStack:\n self.root = child\n else:\n self.parent = self.nodeStack[-1]\n self.parent.add(child)\n self.nodeStack.append(child)", "docstring": "Expat start element event handler" }, { "code": "def _transform(xsl_filename, xml, **kwargs):\n xslt = _make_xsl(xsl_filename)\n xml = xslt(xml, **kwargs)\n return xml", "docstring": "Transforms the xml using the specifiec xsl file." }, { "code": "def diff(candidate, running, *models):\n if isinstance(models, tuple) and isinstance(models[0], list):\n models = models[0]\n first = _get_root_object(models)\n first.load_dict(candidate)\n second = _get_root_object(models)\n second.load_dict(running)\n return napalm_yang.utils.diff(first, second)", "docstring": "Returns the difference between two configuration entities structured\n according to the YANG model.\n\n .. note::\n This function is recommended to be used mostly as a state helper.\n\n candidate\n First model to compare.\n\n running\n Second model to compare.\n\n models\n A list of models to be used when comparing.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' napalm_yang.diff {} {} models.openconfig_interfaces\n\n Output Example:\n\n .. code-block:: python\n\n {\n \"interfaces\": {\n \"interface\": {\n \"both\": {\n \"Port-Channel1\": {\n \"config\": {\n \"mtu\": {\n \"first\": \"0\",\n \"second\": \"9000\"\n }\n }\n }\n },\n \"first_only\": [\n \"Loopback0\"\n ],\n \"second_only\": [\n \"Loopback1\"\n ]\n }\n }\n }" }, { "code": "def normalize_name(self, name):\n name = name.lower()\n if name in self.aliases:\n name = self.aliases[name]\n return name", "docstring": "Normalize a field or level name.\n\n :param name: The field or level name (a string).\n :returns: The normalized name (a string).\n\n Transforms all strings to lowercase and resolves level name aliases\n (refer to :func:`find_level_aliases()`) to their canonical name:\n\n >>> from coloredlogs import NameNormalizer\n >>> from humanfriendly import format_table\n >>> nn = NameNormalizer()\n >>> sample_names = ['DEBUG', 'INFO', 'WARN', 'WARNING', 'ERROR', 'FATAL', 'CRITICAL']\n >>> print(format_table([(n, nn.normalize_name(n)) for n in sample_names]))\n -----------------------\n | DEBUG | debug |\n | INFO | info |\n | WARN | warning |\n | WARNING | warning |\n | ERROR | error |\n | FATAL | critical |\n | CRITICAL | critical |\n -----------------------" }, { "code": "def parse_services(config, services):\n enabled = 0\n for service in services:\n check_disabled = config.getboolean(service, 'check_disabled')\n if not check_disabled:\n enabled += 1\n return enabled", "docstring": "Parse configuration to return number of enabled service checks.\n\n Arguments:\n config (obj): A configparser object with the configuration of\n anycast-healthchecker.\n services (list): A list of section names which holds configuration\n for each service check\n\n Returns:\n A number (int) of enabled service checks." }, { "code": "def on_batch_begin(self, train, **kwargs:Any)->None:\n \"Record learning rate and momentum at beginning of batch.\"\n if train:\n self.lrs.append(self.opt.lr)\n self.moms.append(self.opt.mom)", "docstring": "Record learning rate and momentum at beginning of batch." }, { "code": "def get_files(self):\n files = {}\n for filename in os.listdir(self.source):\n path = os.path.join(self.source, filename)\n files[filename] = frontmatter.load(path, \n filename=filename, \n slug=os.path.splitext(filename)[0])\n return files", "docstring": "Read and parse files from a directory,\n return a dictionary of path => post" }, { "code": "def install_timers(config, context):\n timers = []\n if config.get('capture_timeout_warnings'):\n timeout_threshold = config.get('timeout_warning_threshold')\n time_remaining = context.get_remaining_time_in_millis() / 1000\n timers.append(Timer(time_remaining * timeout_threshold, timeout_warning, (config, context)))\n timers.append(Timer(max(time_remaining - .5, 0), timeout_error, [config]))\n if config.get('capture_memory_warnings'):\n timers.append(Timer(.5, memory_warning, (config, context)))\n for t in timers:\n t.start()\n return timers", "docstring": "Create the timers as specified by the plugin configuration." }, { "code": "def execute_sql(self, query):\n c = self.con.cursor()\n c.execute(query)\n result = c.fetchall()\n return result", "docstring": "Executes a given query string on an open sqlite database." }, { "code": "def get_oncall(self, **kwargs):\n endpoint = '/'.join((self.endpoint, self.id, 'users'))\n return self.request('GET', endpoint=endpoint, query_params=kwargs)", "docstring": "Retrieve this schedule's \"on call\" users." }, { "code": "def get_setup_requires():\n if {'--help', '--help-commands'}.intersection(sys.argv):\n return list()\n reqlist = []\n for cmd, dependencies in SETUP_REQUIRES.items():\n if cmd in sys.argv:\n reqlist.extend(dependencies)\n return reqlist", "docstring": "Return the list of packages required for this setup.py run" }, { "code": "def ext_pillar(minion_id,\n pillar,\n command):\n try:\n command = command.replace('%s', minion_id)\n return deserialize(__salt__['cmd.run']('{0}'.format(command)))\n except Exception:\n log.critical('YAML data from %s failed to parse', command)\n return {}", "docstring": "Execute a command and read the output as YAMLEX" }, { "code": "def all(cls):\n api = Client.instance().api\n endpoint_list = api.endpoint.get()\n return endpoint_list", "docstring": "Returns a list of all configured endpoints the server is listening on. For each endpoint,\n the list of allowed databases is returned too if set.\n\n The result is a JSON hash which has the endpoints as keys, and the list of\n mapped database names as values for each endpoint.\n\n If a list of mapped databases is empty, it means that all databases can be accessed via the endpoint.\n If a list of mapped databases contains more than one database name, this means that any of the\n databases might be accessed via the endpoint, and the first database in the list will be treated\n as the default database for the endpoint. The default database will be used when an incoming request\n does not specify a database name in the request explicitly.\n\n *Note*: retrieving the list of all endpoints is allowed in the system database only.\n Calling this action in any other database will make the server return an error." }, { "code": "def jars(self, absolute=True):\n jars = glob(os.path.join(self._jar_path, '*.jar'))\n return jars if absolute else map(lambda j: os.path.abspath(j), jars)", "docstring": "List of jars in the jar path" }, { "code": "def get_language_details(self, language):\n for lang in self.user_data.languages:\n if language == lang['language_string']:\n return lang\n return {}", "docstring": "Get user's status about a language." }, { "code": "def stop(name, timeout=None, **kwargs):\n if timeout is None:\n try:\n timeout = inspect_container(name)['Config']['StopTimeout']\n except KeyError:\n timeout = salt.utils.docker.SHUTDOWN_TIMEOUT\n orig_state = state(name)\n if orig_state == 'paused':\n if kwargs.get('unpause', False):\n unpause_result = _change_state(name, 'unpause', 'running')\n if unpause_result['result'] is False:\n unpause_result['comment'] = (\n 'Failed to unpause container \\'{0}\\''.format(name)\n )\n return unpause_result\n else:\n return {'result': False,\n 'state': {'old': orig_state, 'new': orig_state},\n 'comment': ('Container \\'{0}\\' is paused, run with '\n 'unpause=True to unpause before stopping'\n .format(name))}\n ret = _change_state(name, 'stop', 'stopped', timeout=timeout)\n ret['state']['old'] = orig_state\n return ret", "docstring": "Stops a running container\n\n name\n Container name or ID\n\n unpause : False\n If ``True`` and the container is paused, it will be unpaused before\n attempting to stop the container.\n\n timeout\n Timeout in seconds after which the container will be killed (if it has\n not yet gracefully shut down)\n\n .. versionchanged:: 2017.7.0\n If this argument is not passed, then the container's configuration\n will be checked. If the container was created using the\n ``stop_timeout`` argument, then the configured timeout will be\n used, otherwise the timeout will be 10 seconds.\n\n **RETURN DATA**\n\n A dictionary will be returned, containing the following keys:\n\n - ``status`` - A dictionary showing the prior state of the container as\n well as the new state\n - ``result`` - A boolean noting whether or not the action was successful\n - ``comment`` - Only present if the container can not be stopped\n\n\n CLI Examples:\n\n .. code-block:: bash\n\n salt myminion docker.stop mycontainer\n salt myminion docker.stop mycontainer unpause=True\n salt myminion docker.stop mycontainer timeout=20" }, { "code": "def iter_rows(self, start=None, end=None):\n start = start or 0\n end = end or self.nrows\n for i in range(start, end):\n yield self.iloc[i, :]", "docstring": "Iterate each of the Region rows in this region" }, { "code": "def parse_class_id(self, sel, m, has_selector):\n selector = m.group(0)\n if selector.startswith('.'):\n sel.classes.append(css_unescape(selector[1:]))\n else:\n sel.ids.append(css_unescape(selector[1:]))\n has_selector = True\n return has_selector", "docstring": "Parse HTML classes and ids." }, { "code": "def _no_spelling_errors(relative_path, contents, linter_options):\n block_regexps = linter_options.get(\"block_regexps\", None)\n chunks, shadow = spellcheckable_and_shadow_contents(contents,\n block_regexps)\n cache = linter_options.get(\"spellcheck_cache\", None)\n user_words, valid_words = valid_words_dictionary_helper.create(cache)\n technical_words = _create_technical_words_dictionary(cache,\n relative_path,\n user_words,\n shadow)\n if linter_options.get(\"log_technical_terms_to\"):\n linter_options[\"log_technical_terms_to\"].put(technical_words.words())\n return [e for e in _find_spelling_errors_in_chunks(chunks,\n contents,\n valid_words,\n technical_words,\n user_words) if e]", "docstring": "No spelling errors in strings, comments or anything of the like." }, { "code": "def calc_area_under_PSD(self, lowerFreq, upperFreq):\n Freq_startAreaPSD = take_closest(self.freqs, lowerFreq)\n index_startAreaPSD = int(_np.where(self.freqs == Freq_startAreaPSD)[0][0])\n Freq_endAreaPSD = take_closest(self.freqs, upperFreq)\n index_endAreaPSD = int(_np.where(self.freqs == Freq_endAreaPSD)[0][0])\n AreaUnderPSD = sum(self.PSD[index_startAreaPSD: index_endAreaPSD])\n return AreaUnderPSD", "docstring": "Sums the area under the PSD from lowerFreq to upperFreq.\n\n Parameters\n ----------\n lowerFreq : float\n The lower limit of frequency to sum from\n upperFreq : float\n The upper limit of frequency to sum to\n\n Returns\n -------\n AreaUnderPSD : float\n The area under the PSD from lowerFreq to upperFreq" }, { "code": "def spectral_norm(w, dim=0, itr=1, eps=1e-12, test=False, u_init=None, fix_parameters=True):\n assert (0 <= dim and dim < len(w.shape)\n ), \"`dim` must be `0 <= dim and dim < len(w.shape)`.\"\n assert 0 < itr, \"`itr` must be greater than 0.\"\n assert 0 < eps, \"`eps` must be greater than 0.\"\n if dim == len(w.shape) - 1:\n w_sn = _spectral_norm_outer_most_dim(w, dim=dim, itr=itr, eps=eps, test=test,\n u_init=u_init, fix_parameters=fix_parameters)\n else:\n w_sn = _spectral_norm(w, dim=dim, itr=itr, eps=eps, test=test,\n u_init=u_init, fix_parameters=fix_parameters)\n return w_sn", "docstring": "Spectral Normalization.\n\n .. math::\n\n W_{sn} = \\\\frac{W}{\\\\sigma(W)}.\n\n where :math:`W` is the input matrix, and the :math:`\\\\sigma(W)` is the spectral norm of :math:`W`. The spectral norm is approximately computed by the power iteration.\n\n References:\n\n Takeru Miyato, Toshiki Kataoka, Masanori Koyama, Yuichi Yoshida, \n \"Spectral Normalization for Generative Adversarial Networks\", \n International Conference on Learning Representations. 2018.\n\n Args:\n W (~nnabla.Variable): Input N-D array with shape. This is normally network parameter.\n dim (`int`): Output dimension. Default is 0. If the dimension is not 0, then the specified dimension becomes the most-left dimension by transposing.\n itr (`int`): Number of iterations. Default is 1.\n eps (`float`): Epsilon for the normalization. Default is 1e-12.\n test (`bool`): Use test mode. Default is False.\n\n Returns:\n ~nnabla.Variable: Spectrally normalized :math:`W_{sn}` with the same shape as :math:`W`.\n\n Example:\n\n .. code-block:: python\n\n import nnabla as nn\n import nnabla.parametric_functions as PF\n\n b, c, h, w = 4, 64, 32, 32\n\n # Spectrally normalized convolution\n apply_w = lambda w: PF.spectral_norm(w, dim=0)\n h = nn.Variable.from_numpy_array(np.random.randn(b, c, h, w))\n h = PF.convolution(h, with_bias=False, apply_w=apply_w)\n\n # Spectrally normalized affine\n apply_w = lambda w: PF.spectral_norm(w, dim=1)\n h = nn.Variable.from_numpy_array(np.random.randn(b, c))\n h = PF.affine(h, with_bias=False, apply_w=apply_w)\n\n # Spectrally normalized embed\n apply_w = lambda w: PF.spectral_norm(w, dim=1)\n h = nn.Variable.from_numpy_array(np.random.randn(b, c))\n h = PF.embed(h, c, apply_w=apply_w)" }, { "code": "def value(self):\n if self.ready is True:\n flag, load = self.__queue.get()\n if flag:\n return load\n raise load", "docstring": "Read-only property containing data returned from function." }, { "code": "def exclude(self, scheduled_operation: ScheduledOperation) -> bool:\n try:\n self.scheduled_operations.remove(scheduled_operation)\n return True\n except ValueError:\n return False", "docstring": "Omits a scheduled operation from the schedule, if present.\n\n Args:\n scheduled_operation: The operation to try to remove.\n\n Returns:\n True if the operation was present and is now removed, False if it\n was already not present." }, { "code": "def get_page_template(self, **kwargs):\n opts = self.object_list.model._meta\n return '{0}/{1}{2}{3}.html'.format(\n opts.app_label,\n opts.object_name.lower(),\n self.template_name_suffix,\n self.page_template_suffix,\n )", "docstring": "Return the template name used for this request.\n\n Only called if *page_template* is not given as a kwarg of\n *self.as_view*." }, { "code": "def parse_keys(self, sn: \"DataNode\") -> Dict[InstanceName, ScalarValue]:\n res = {}\n for k in self.keys:\n knod = sn.get_data_child(*k)\n if knod is None:\n raise NonexistentSchemaNode(sn.qual_name, *k)\n kval = knod.type.parse_value(self.keys[k])\n if kval is None:\n raise InvalidKeyValue(self.keys[k])\n res[knod.iname()] = kval\n return res", "docstring": "Parse key dictionary in the context of a schema node.\n\n Args:\n sn: Schema node corresponding to a list." }, { "code": "def run_suite(self):\n if not self.phantomjs_runner:\n raise JsTestException('phantomjs_runner need to be defined')\n url = self.get_url()\n self.phantomjs(self.phantomjs_runner, url, title=self.title)\n self.cleanup()", "docstring": "Run a phantomjs test suite.\n\n - ``phantomjs_runner`` is mandatory.\n - Either ``url`` or ``url_name`` needs to be defined." }, { "code": "def _configuration(self, *args, **kwargs):\n data = dict()\n self.db.open()\n for pkg in self.db.get(Package):\n configs = list()\n for pkg_cfg in self.db.get(PackageCfgFile, eq={'pkgid': pkg.id}):\n configs.append(pkg_cfg.path)\n data[pkg.name] = configs\n if not data:\n raise InspectorQueryException(\"No inspected configuration yet available.\")\n return data", "docstring": "Return configuration files." }, { "code": "def values(self):\n results = {}\n results['use_calfile'] = self.ui.calfileRadio.isChecked()\n results['calname'] = str(self.ui.calChoiceCmbbx.currentText())\n results['frange'] = (self.ui.frangeLowSpnbx.value(), self.ui.frangeHighSpnbx.value())\n return results", "docstring": "Gets the values the user input to this dialog\n\n :returns: dict of inputs:\n | *'use_calfile'*: bool, -- whether to apply calibration at all\n | *'calname'*: str, -- the name of the calibration dataset to use\n | *'frange'*: (int, int), -- (min, max) of the frequency range to apply calibration to" }, { "code": "def _fingerprint_files(self, filepaths):\n hasher = sha1()\n for filepath in filepaths:\n filepath = self._assert_in_buildroot(filepath)\n hasher.update(os.path.relpath(filepath, get_buildroot()).encode('utf-8'))\n with open(filepath, 'rb') as f:\n hasher.update(f.read())\n return hasher.hexdigest()", "docstring": "Returns a fingerprint of the given filepaths and their contents.\n\n This assumes the files are small enough to be read into memory." }, { "code": "def draw_svg(self, svg_str):\n try:\n import rsvg\n except ImportError:\n self.draw_text(svg_str)\n return\n svg = rsvg.Handle(data=svg_str)\n svg_width, svg_height = svg.get_dimension_data()[:2]\n transx, transy = self._get_translation(svg_width, svg_height)\n scale_x, scale_y = self._get_scalexy(svg_width, svg_height)\n scale = min(scale_x, scale_y)\n angle = float(self.code_array.cell_attributes[self.key][\"angle\"])\n self.context.save()\n self.context.rotate(-angle / 360 * 2 * math.pi)\n self.context.translate(transx, transy)\n self.context.scale(scale, scale)\n svg.render_cairo(self.context)\n self.context.restore()", "docstring": "Draws svg string to cell" }, { "code": "def segments (self):\n for n in xrange(len(self.vertices) - 1):\n yield Line(self.vertices[n], self.vertices[n + 1])\n yield Line(self.vertices[-1], self.vertices[0])", "docstring": "Return the Line segments that comprise this Polygon." }, { "code": "def surface(x, y, z):\n data = [go.Surface(x=x, y=y, z=z)]\n return Chart(data=data)", "docstring": "Surface plot.\n\n Parameters\n ----------\n x : array-like, optional\n y : array-like, optional\n z : array-like, optional\n\n Returns\n -------\n Chart" }, { "code": "def add_criterion(self, name, priority, and_or, search_type, value):\n criterion = SearchCriteria(name, priority, and_or, search_type, value)\n self.criteria.append(criterion)", "docstring": "Add a search criteria object to a smart group.\n\n Args:\n name: String Criteria type name (e.g. \"Application Title\")\n priority: Int or Str number priority of criterion.\n and_or: Str, either \"and\" or \"or\".\n search_type: String Criteria search type. (e.g. \"is\", \"is\n not\", \"member of\", etc). Construct a SmartGroup with the\n criteria of interest in the web interface to determine\n what range of values are available.\n value: String value to search for/against." }, { "code": "def class_factory(name, base_class, class_dict):\n def __init__(self, tcex):\n base_class.__init__(self, tcex)\n for k, v in class_dict.items():\n setattr(self, k, v)\n newclass = type(str(name), (base_class,), {'__init__': __init__})\n return newclass", "docstring": "Internal method for dynamically building Custom Indicator classes." }, { "code": "def parse_all(self):\n tokens = self.split_tokens\n duration = self.duration\n datetime = self.datetime\n thread = self.thread\n operation = self.operation\n namespace = self.namespace\n pattern = self.pattern\n nscanned = self.nscanned\n nscannedObjects = self.nscannedObjects\n ntoreturn = self.ntoreturn\n nreturned = self.nreturned\n ninserted = self.ninserted\n ndeleted = self.ndeleted\n nupdated = self.nupdated\n numYields = self.numYields\n w = self.w\n r = self.r", "docstring": "Trigger extraction of all information.\n\n These values are usually evaluated lazily." }, { "code": "def execution_minutes_for_session(self, session_label):\n return self.minutes_in_range(\n start_minute=self.execution_time_from_open(\n self.schedule.at[session_label, 'market_open'],\n ),\n end_minute=self.execution_time_from_close(\n self.schedule.at[session_label, 'market_close'],\n ),\n )", "docstring": "Given a session label, return the execution minutes for that session.\n\n Parameters\n ----------\n session_label: pd.Timestamp (midnight UTC)\n A session label whose session's minutes are desired.\n\n Returns\n -------\n pd.DateTimeIndex\n All the execution minutes for the given session." }, { "code": "def clear_events(self, event_name):\n self.lock.acquire()\n try:\n q = self.get_event_q(event_name)\n q.queue.clear()\n except queue.Empty:\n return\n finally:\n self.lock.release()", "docstring": "Clear all events of a particular name.\n\n Args:\n event_name: Name of the events to be popped." }, { "code": "def add_text_to_image(fname, txt, opFilename):\n ft = ImageFont.load(\"T://user//dev//src//python//_AS_LIB//timR24.pil\")\n print(\"Adding text \", txt, \" to \", fname, \" pixels wide to file \" , opFilename)\n im = Image.open(fname)\n draw = ImageDraw.Draw(im)\n draw.text((0, 0), txt, fill=(0, 0, 0), font=ft)\n del draw \n im.save(opFilename)", "docstring": "convert an image by adding text" }, { "code": "def findOne(self, query=None, mode=FindOneMode.FIRST, **kwargs):\n results = self.find(query, **kwargs)\n if len(results) is 0:\n return None\n elif len(results) is 1 or mode == FindOneMode.FIRST:\n return results[0]\n elif mode == FindOneMode.LAST:\n return results[-1]", "docstring": "Perform a find, with the same options present, but only return a maximum of one result. If find returns\n an empty array, then None is returned.\n\n If there are multiple results from find, the one returned depends on the mode parameter. If mode is\n FindOneMode.FIRST, then the first result is returned. If the mode is FindOneMode.LAST, then the last is\n returned. If the mode is FindOneMode.ERROR, then a SlickCommunicationError is raised." }, { "code": "def get_my_hostname(self, split_hostname_on_first_period=False):\n hostname = self.init_config.get(\"os_host\") or self.hostname\n if split_hostname_on_first_period:\n hostname = hostname.split('.')[0]\n return hostname", "docstring": "Returns a best guess for the hostname registered with OpenStack for this host" }, { "code": "def create_contact(self, attrs, members=None, folder_id=None, tags=None):\n cn = {}\n if folder_id:\n cn['l'] = str(folder_id)\n if tags:\n tags = self._return_comma_list(tags)\n cn['tn'] = tags\n if members:\n cn['m'] = members\n attrs = [{'n': k, '_content': v} for k, v in attrs.items()]\n cn['a'] = attrs\n resp = self.request_single('CreateContact', {'cn': cn})\n return zobjects.Contact.from_dict(resp)", "docstring": "Create a contact\n\n Does not include VCARD nor group membership yet\n\n XML example :\n ## ContactSpec\n MARTIN\n Pierre\n pmartin@example.com\n \n Which would be in zimsoap : attrs = { 'lastname': 'MARTIN',\n 'firstname': 'Pierre',\n 'email': 'pmartin@example.com' }\n folder_id = 7\n\n :param folder_id: a string of the ID's folder where to create\n contact. Default '7'\n :param tags: comma-separated list of tag names\n :param attrs: a dictionary of attributes to set ({key:value,...}). At\n least one attr is required\n :returns: the created zobjects.Contact" }, { "code": "def parse_uinput_mapping(name, mapping):\n axes, buttons, mouse, mouse_options = {}, {}, {}, {}\n description = \"ds4drv custom mapping ({0})\".format(name)\n for key, attr in mapping.items():\n key = key.upper()\n if key.startswith(\"BTN_\") or key.startswith(\"KEY_\"):\n buttons[key] = attr\n elif key.startswith(\"ABS_\"):\n axes[key] = attr\n elif key.startswith(\"REL_\"):\n mouse[key] = attr\n elif key.startswith(\"MOUSE_\"):\n mouse_options[key] = attr\n create_mapping(name, description, axes=axes, buttons=buttons,\n mouse=mouse, mouse_options=mouse_options)", "docstring": "Parses a dict of mapping options." }, { "code": "def check( state_engine, nameop, block_id, checked_ops ):\n sender = nameop['sender']\n sending_blockchain_id = None\n found = False\n blockchain_namerec = None\n for blockchain_id in state_engine.get_announce_ids():\n blockchain_namerec = state_engine.get_name( blockchain_id )\n if blockchain_namerec is None:\n continue\n if str(sender) == str(blockchain_namerec['sender']):\n found = True\n sending_blockchain_id = blockchain_id\n break\n if not found:\n log.warning(\"Announcement not sent from our whitelist of blockchain IDs\")\n return False\n nameop['announcer_id'] = sending_blockchain_id\n process_announcement( blockchain_namerec, nameop, state_engine.working_dir )\n return True", "docstring": "Log an announcement from the blockstack developers,\n but first verify that it is correct.\n Return True if the announcement came from the announce IDs whitelist\n Return False otherwise" }, { "code": "def asdict(self):\n result = {}\n for key in self._fields:\n value = getattr(self, key)\n if isinstance(value, list):\n value = [i.asdict() if isinstance(i, Resource) else i for i in value]\n if isinstance(value, Resource):\n value = value.asdict()\n result[key] = value\n return result", "docstring": "Convert resource to dictionary" }, { "code": "def audit_with_request(**kwargs):\n def wrap(fn):\n @audit(**kwargs)\n def operation(parent_object, *args, **kw):\n return fn(parent_object.request, *args, **kw)\n @functools.wraps(fn)\n def advice_with_request(the_request, *args, **kw):\n class ParentObject:\n request = the_request\n return operation(ParentObject(), *args, **kw)\n return advice_with_request\n return wrap", "docstring": "use this decorator to audit an operation with a request as input variable" }, { "code": "def _validate(claims, validate_claims, expiry_seconds):\n if not validate_claims:\n return\n now = time()\n try:\n expiration_time = claims[CLAIM_EXPIRATION_TIME]\n except KeyError:\n pass\n else:\n _check_expiration_time(now, expiration_time)\n try:\n issued_at = claims[CLAIM_ISSUED_AT]\n except KeyError:\n pass\n else:\n if expiry_seconds is not None:\n _check_expiration_time(now, issued_at + expiry_seconds)\n try:\n not_before = claims[CLAIM_NOT_BEFORE]\n except KeyError:\n pass\n else:\n _check_not_before(now, not_before)", "docstring": "Validate expiry related claims.\n\n If validate_claims is False, do nothing.\n\n Otherwise, validate the exp and nbf claims if they are present, and\n validate the iat claim if expiry_seconds is provided." }, { "code": "def build_catalog_info(self, catalog_info):\n cat = SourceFactory.build_catalog(**catalog_info)\n catalog_info['catalog'] = cat\n catalog_info['catalog_table'] = cat.table\n catalog_info['roi_model'] =\\\n SourceFactory.make_fermipy_roi_model_from_catalogs([cat])\n catalog_info['srcmdl_name'] =\\\n self._name_factory.srcmdl_xml(sourcekey=catalog_info['catalog_name'])\n return CatalogInfo(**catalog_info)", "docstring": "Build a CatalogInfo object" }, { "code": "def update(cls, spec, updates, upsert=False):\n if 'key' in spec:\n previous = cls.get(spec['key'])\n else:\n previous = None\n if previous:\n current = cls(**previous.__dict__)\n elif upsert:\n current = cls(**spec)\n else:\n current = None\n if current:\n current.__dict__.update(updates)\n current.save()\n return current", "docstring": "The spec is used to search for the data to update, updates contains the\n values to be updated, and upsert specifies whether to do an insert if\n the original data is not found." }, { "code": "def should_copy(column):\n if not isinstance(column.type, Serial):\n return True\n if column.nullable:\n return True\n if not column.server_default:\n return True\n return False", "docstring": "Determine if a column should be copied." }, { "code": "def get_db_row(db, start, size):\n type_ = snap7.snap7types.wordlen_to_ctypes[snap7.snap7types.S7WLByte]\n data = client.db_read(db, start, type_, size)\n return data", "docstring": "Here you see and example of readying out a part of a DB\n\n Args:\n db (int): The db to use\n start (int): The index of where to start in db data\n size (int): The size of the db data to read" }, { "code": "def spkapo(targ, et, ref, sobs, abcorr):\n targ = ctypes.c_int(targ)\n et = ctypes.c_double(et)\n ref = stypes.stringToCharP(ref)\n abcorr = stypes.stringToCharP(abcorr)\n sobs = stypes.toDoubleVector(sobs)\n ptarg = stypes.emptyDoubleVector(3)\n lt = ctypes.c_double()\n libspice.spkapo_c(targ, et, ref, sobs, abcorr, ptarg, ctypes.byref(lt))\n return stypes.cVectorToPython(ptarg), lt.value", "docstring": "Return the position of a target body relative to an observer,\n optionally corrected for light time and stellar aberration.\n\n http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/spkapo_c.html\n\n :param targ: Target body.\n :type targ: int\n :param et: Observer epoch.\n :type et: float\n :param ref: Inertial reference frame of observer's state.\n :type ref: str\n :param sobs: State of observer wrt. solar system barycenter.\n :type sobs: 6-Element Array of floats\n :param abcorr: Aberration correction flag.\n :type abcorr: str\n :return:\n Position of target,\n One way light time between observer and target.\n :rtype: tuple" }, { "code": "def on_gtk_prefer_dark_theme_toggled(self, chk):\n self.settings.general.set_boolean('gtk-prefer-dark-theme', chk.get_active())\n select_gtk_theme(self.settings)", "docstring": "Set the `gtk_prefer_dark_theme' property in dconf" }, { "code": "def from_keys(cls, keys, loader_func, type_hint=None):\n return cls({k: LazyLoadedValue(\n lambda k=k: loader_func(k), type_hint=type_hint) for k in keys})", "docstring": "Factory method for `LazyLoadedDict`\n\n Accepts a ``loader_func`` that is to be applied to all ``keys``.\n\n :param keys: List of keys to create the dictionary with\n :type keys: iterable\n :param loader_func: Function to be applied to all keys\n :type loader_func: function\n :param type_hint: Expected type of lazy loaded values.\n Used by `LazyLoadedValue`. (Default value = None)\n :type type_hint: str\n :returns: A properly constructed lazy loaded dictionary\n :rtype: LazyLoadedDict" }, { "code": "def _bits_ports_and_isrom_from_memory(mem):\n is_rom = False\n bits = 2**mem.addrwidth * mem.bitwidth\n read_ports = len(mem.readport_nets)\n try:\n write_ports = len(mem.writeport_nets)\n except AttributeError:\n if not isinstance(mem, RomBlock):\n raise PyrtlInternalError('Mem with no writeport_nets attribute'\n ' but not a ROM? Thats an error')\n write_ports = 0\n is_rom = True\n ports = max(read_ports, write_ports)\n return bits, ports, is_rom", "docstring": "Helper to extract mem bits and ports for estimation." }, { "code": "def _lane_detail_to_ss(fcid, ldetail):\n return [fcid, ldetail[\"lane\"], ldetail[\"name\"], ldetail[\"genome_build\"],\n ldetail[\"bc_index\"], ldetail[\"description\"].encode(\"ascii\", \"ignore\"), \"N\", \"\", \"\",\n ldetail[\"project_name\"]]", "docstring": "Convert information about a lane into Illumina samplesheet output." }, { "code": "def _colorize(val, color):\n if termcolor is not None:\n val = termcolor.colored(val, color)\n elif colorama is not None:\n val = TERMCOLOR2COLORAMA[color] + val + colorama.Style.RESET_ALL\n return val", "docstring": "Colorize a string using termcolor or colorama.\n\n If any of them are available." }, { "code": "def build_from_energy_dict(cls, ebin_name, input_dict):\n psf_types = input_dict.pop('psf_types')\n output_list = []\n for psf_type, val_dict in sorted(psf_types.items()):\n fulldict = input_dict.copy()\n fulldict.update(val_dict)\n fulldict['evtype_name'] = psf_type\n fulldict['ebin_name'] = ebin_name\n component = cls(**fulldict)\n output_list += [component]\n return output_list", "docstring": "Build a list of components from a dictionary for a single energy range" }, { "code": "def admin_link(obj):\n if hasattr(obj, 'get_admin_link'):\n return mark_safe(obj.get_admin_link())\n return mark_safe(admin_link_fn(obj))", "docstring": "Returns a link to the admin URL of an object.\n\n No permissions checking is involved, so use with caution to avoid exposing\n the link to unauthorised users.\n\n Example::\n\n {{ foo_obj|admin_link }}\n\n renders as::\n\n Foo\n\n :param obj: A Django model instance.\n :return: A safe string expressing an HTML link to the admin page for an\n object." }, { "code": "def gzip_dir(path, compresslevel=6):\n for f in os.listdir(path):\n full_f = os.path.join(path, f)\n if not f.lower().endswith(\"gz\"):\n with open(full_f, 'rb') as f_in, \\\n GzipFile('{}.gz'.format(full_f), 'wb',\n compresslevel=compresslevel) as f_out:\n shutil.copyfileobj(f_in, f_out)\n shutil.copystat(full_f,'{}.gz'.format(full_f))\n os.remove(full_f)", "docstring": "Gzips all files in a directory. Note that this is different from\n shutil.make_archive, which creates a tar archive. The aim of this method\n is to create gzipped files that can still be read using common Unix-style\n commands like zless or zcat.\n\n Args:\n path (str): Path to directory.\n compresslevel (int): Level of compression, 1-9. 9 is default for\n GzipFile, 6 is default for gzip." }, { "code": "def poly_to_pwl(self, n_points=4):\n assert self.pcost_model == POLYNOMIAL\n p_min = self.p_min\n p_max = self.p_max\n p_cost = []\n if p_min > 0.0:\n step = (p_max - p_min) / (n_points - 2)\n y0 = self.total_cost(0.0)\n p_cost.append((0.0, y0))\n x = p_min\n n_points -= 1\n else:\n step = (p_max - p_min) / (n_points - 1)\n x = 0.0\n for _ in range(n_points):\n y = self.total_cost(x)\n p_cost.append((x, y))\n x += step\n self.pcost_model = PW_LINEAR\n self.p_cost = p_cost", "docstring": "Sets the piece-wise linear cost attribute, converting the\n polynomial cost variable by evaluating at zero and then at n_points\n evenly spaced points between p_min and p_max." }, { "code": "def create_event_subscription(self, instance, on_data, timeout=60):\n manager = WebSocketSubscriptionManager(self, resource='events')\n subscription = WebSocketSubscriptionFuture(manager)\n wrapped_callback = functools.partial(\n _wrap_callback_parse_event, on_data)\n manager.open(wrapped_callback, instance)\n subscription.reply(timeout=timeout)\n return subscription", "docstring": "Create a new subscription for receiving events of an instance.\n\n This method returns a future, then returns immediately. Stop the\n subscription by canceling the future.\n\n :param str instance: A Yamcs instance name\n\n :param on_data: Function that gets called on each :class:`.Event`.\n :type on_data: Optional[Callable[.Event])\n\n :param timeout: The amount of seconds to wait for the request to\n complete.\n :type timeout: Optional[float]\n\n :return: Future that can be used to manage the background websocket\n subscription.\n :rtype: .WebSocketSubscriptionFuture" }, { "code": "def get_context(self, **kwargs):\n context = self.get_context_data(form=self.form_obj, **kwargs)\n context.update(super(FormAdminView, self).get_context())\n return context", "docstring": "Use this method to built context data for the template\n\n Mix django wizard context data with django-xadmin context" }, { "code": "def validate(self) :\n if not self.mustValidate :\n return True\n res = {}\n for field in self.validators.keys() :\n try :\n if isinstance(self.validators[field], dict) and field not in self.store :\n self.store[field] = DocumentStore(self.collection, validators = self.validators[field], initDct = {}, subStore=True, validateInit=self.validateInit)\n self.validateField(field)\n except InvalidDocument as e :\n res.update(e.errors)\n except (ValidationError, SchemaViolation) as e:\n res[field] = str(e)\n if len(res) > 0 :\n raise InvalidDocument(res)\n return True", "docstring": "Validate the whole document" }, { "code": "def analysis(self):\n if self._analysis is None:\n with open(self.path, 'rb') as f:\n self.read_analysis(f)\n return self._analysis", "docstring": "Get ANALYSIS segment of the FCS file." }, { "code": "def startLoading(self):\r\n if self._loading:\r\n return False\r\n tree = self.treeWidget()\r\n if not tree:\r\n return\r\n self._loading = True\r\n self.setText(0, '')\r\n lbl = QtGui.QLabel(self.treeWidget())\r\n lbl.setMovie(XLoaderWidget.getMovie())\r\n lbl.setAlignment(QtCore.Qt.AlignCenter)\r\n tree.setItemWidget(self, 0, lbl)\r\n try:\r\n tree.loadStarted.emit(self)\r\n except AttributeError:\r\n pass\r\n return True", "docstring": "Updates this item to mark the item as loading. This will create\r\n a QLabel with the loading ajax spinner to indicate that progress\r\n is occurring." }, { "code": "def get_processing_block_ids(self):\n _processing_block_ids = []\n pattern = '*:processing_block:*'\n block_ids = self._db.get_ids(pattern)\n for block_id in block_ids:\n id_split = block_id.split(':')[-1]\n _processing_block_ids.append(id_split)\n return sorted(_processing_block_ids)", "docstring": "Get list of processing block ids using the processing block id" }, { "code": "def _load_version(cls, state, version):\n from ._audio_feature_extractor import _get_feature_extractor\n from .._mxnet import _mxnet_utils\n state['_feature_extractor'] = _get_feature_extractor(state['feature_extractor_name'])\n num_classes = state['num_classes']\n num_inputs = state['_feature_extractor'].output_length\n if 'custom_layer_sizes' in state:\n custom_layer_sizes = list(map(int, state['custom_layer_sizes']))\n else:\n custom_layer_sizes = [100, 100]\n state['custom_layer_sizes'] = custom_layer_sizes\n net = SoundClassifier._build_custom_neural_network(num_inputs, num_classes, custom_layer_sizes)\n net_params = net.collect_params()\n ctx = _mxnet_utils.get_mxnet_context()\n _mxnet_utils.load_net_params_from_state(net_params, state['_custom_classifier'], ctx=ctx)\n state['_custom_classifier'] = net\n return SoundClassifier(state)", "docstring": "A function to load a previously saved SoundClassifier instance." }, { "code": "def detach_all(self):\n self.detach_all_classes()\n self.objects.clear()\n self.index.clear()\n self._keepalive[:] = []", "docstring": "Detach from all tracked classes and objects.\n Restore the original constructors and cleanse the tracking lists." }, { "code": "def _get_action_urls(self):\n actions = {}\n model_name = self.model._meta.model_name\n base_url_name = '%s_%s' % (self.model._meta.app_label, model_name)\n model_actions_url_name = '%s_actions' % base_url_name\n self.tools_view_name = 'admin:' + model_actions_url_name\n for action in chain(self.change_actions, self.changelist_actions):\n actions[action] = getattr(self, action)\n return [\n url(r'^(?P.+)/actions/(?P\\w+)/$',\n self.admin_site.admin_view(\n ChangeActionView.as_view(\n model=self.model,\n actions=actions,\n back='admin:%s_change' % base_url_name,\n current_app=self.admin_site.name,\n )\n ),\n name=model_actions_url_name),\n url(r'^actions/(?P\\w+)/$',\n self.admin_site.admin_view(\n ChangeListActionView.as_view(\n model=self.model,\n actions=actions,\n back='admin:%s_changelist' % base_url_name,\n current_app=self.admin_site.name,\n )\n ),\n name=model_actions_url_name),\n ]", "docstring": "Get the url patterns that route each action to a view." }, { "code": "def get_config_section(self, name):\n if self.config.has_section(name):\n return self.config.items(name)\n return []", "docstring": "Get a section of a configuration" }, { "code": "def find_all_files(self):\n\t\tfiles = self.find_files()\n\t\tsubrepo_files = (\n\t\t\tposixpath.join(subrepo.location, filename)\n\t\t\tfor subrepo in self.subrepos()\n\t\t\tfor filename in subrepo.find_files()\n\t\t)\n\t\treturn itertools.chain(files, subrepo_files)", "docstring": "Find files including those in subrepositories." }, { "code": "def one_way_portal(self, other, **stats):\n return self.character.new_portal(\n self, other, symmetrical=False, **stats\n )", "docstring": "Connect a portal from here to another node, and return it." }, { "code": "def _live_receivers(self, sender):\n receivers = None\n if self.use_caching and not self._dead_receivers:\n receivers = self.sender_receivers_cache.get(sender)\n if receivers is NO_RECEIVERS:\n return []\n if receivers is None:\n with self.lock:\n self._clear_dead_receivers()\n senderkey = _make_id(sender)\n receivers = []\n for (receiverkey, r_senderkey), receiver in self.receivers:\n if r_senderkey == NONE_ID or r_senderkey == senderkey:\n receivers.append(receiver)\n if self.use_caching:\n if not receivers:\n self.sender_receivers_cache[sender] = NO_RECEIVERS\n else:\n self.sender_receivers_cache[sender] = receivers\n non_weak_receivers = []\n for receiver in receivers:\n if isinstance(receiver, weakref.ReferenceType):\n receiver = receiver()\n if receiver is not None:\n non_weak_receivers.append(receiver)\n else:\n non_weak_receivers.append(receiver)\n return non_weak_receivers", "docstring": "Filter sequence of receivers to get resolved, live receivers.\n\n This checks for weak references and resolves them, then returning only\n live receivers." }, { "code": "def smear(idx, factor):\n s = [idx]\n for i in range(factor+1):\n a = i - factor/2\n s += [idx + a]\n return numpy.unique(numpy.concatenate(s))", "docstring": "This function will take as input an array of indexes and return every\n unique index within the specified factor of the inputs.\n\n E.g.: smear([5,7,100],2) = [3,4,5,6,7,8,9,98,99,100,101,102]\n\n Parameters\n -----------\n idx : numpy.array of ints\n The indexes to be smeared.\n factor : idx\n The factor by which to smear out the input array.\n\n Returns\n --------\n new_idx : numpy.array of ints\n The smeared array of indexes." }, { "code": "def nla_put(msg, attrtype, datalen, data):\n nla = nla_reserve(msg, attrtype, datalen)\n if not nla:\n return -NLE_NOMEM\n if datalen <= 0:\n return 0\n nla_data(nla)[:datalen] = data[:datalen]\n _LOGGER.debug('msg 0x%x: attr <0x%x> %d: Wrote %d bytes at offset +%d', id(msg), id(nla), nla.nla_type, datalen,\n nla.bytearray.slice.start - nlmsg_data(msg.nm_nlh).slice.start)\n return 0", "docstring": "Add a unspecific attribute to Netlink message.\n\n https://github.com/thom311/libnl/blob/libnl3_2_25/lib/attr.c#L497\n\n Reserves room for an unspecific attribute and copies the provided data into the message as payload of the attribute.\n Returns an error if there is insufficient space for the attribute.\n\n Positional arguments:\n msg -- Netlink message (nl_msg class instance).\n attrtype -- attribute type (integer).\n datalen -- length of data to be used as payload (integer).\n data -- data to be used as attribute payload (bytearray).\n\n Returns:\n 0 on success or a negative error code." }, { "code": "def mod_watch(name, **kwargs):\n ret = {'name': name,\n 'changes': {},\n 'result': False,\n 'comment': ''}\n if kwargs['sfun'] == 'watch':\n for p in ['sfun', '__reqs__']:\n del kwargs[p]\n kwargs['name'] = name\n ret = present(**kwargs)\n return ret", "docstring": "The at watcher, called to invoke the watch command.\n\n .. note::\n This state exists to support special handling of the ``watch``\n :ref:`requisite `. It should not be called directly.\n\n Parameters for this function should be set by the state being triggered.\n\n name\n The name of the atjob" }, { "code": "def estimate_frequency(self, start: int, end: int, sample_rate: float):\n length = 2 ** int(math.log2(end - start))\n data = self.data[start:start + length]\n try:\n w = np.fft.fft(data)\n frequencies = np.fft.fftfreq(len(w))\n idx = np.argmax(np.abs(w))\n freq = frequencies[idx]\n freq_in_hertz = abs(freq * sample_rate)\n except ValueError:\n freq_in_hertz = 100e3\n return freq_in_hertz", "docstring": "Estimate the frequency of the baseband signal using FFT\n\n :param start: Start of the area that shall be investigated\n :param end: End of the area that shall be investigated\n :param sample_rate: Sample rate of the signal\n :return:" }, { "code": "def read(self):\n\t\twith open(self.default_file) as json_file:\n\t\t\ttry:\n\t\t\t\treturn json.load(json_file)\n\t\t\texcept Exception as e:\n\t\t\t\traise 'empty file'", "docstring": "read default csp settings from json file" }, { "code": "def get_development_container_name(self):\n if self.__prefix:\n return \"{0}:{1}-{2}-dev\".format(\n self.__repository,\n self.__prefix,\n self.__branch)\n else:\n return \"{0}:{1}-dev\".format(\n self.__repository,\n self.__branch)", "docstring": "Returns the development container name" }, { "code": "def changeable(self, request):\n return self.apply_changeable(self.get_queryset(), request) if self.check_changeable(self.model, request) is not False else self.get_queryset().none()", "docstring": "Checks the both, check_changeable and apply_changeable, against the owned model and it's instance set" }, { "code": "def is_digit(obj):\n return isinstance(obj, (numbers.Integral, numbers.Complex, numbers.Real))", "docstring": "Check if an object is Number" }, { "code": "def get(self, url, params={}, headers={}, auth=(), certificate_path=None):\n certificate_path = certificate_path if certificate_path else False\n return self.session.get(url, params=params, headers=headers, verify=certificate_path, auth=auth,\n timeout=self.timeout)", "docstring": "Returns the response payload from the request to the given URL.\n\n Args:\n url (str): The URL for the WEB API that the request is being made too.\n params (dict): Dictionary containing the query string parameters.\n headers (dict): HTTP Headers that may be needed for the request.\n auth (tuple): User ID and password for Basic Auth\n certificate_path (str): Path to the ssl certificate.\n\n Returns:\n response: (HttpResponse): Response object from requests.get api request" }, { "code": "def softmax(w, t=1.0):\n w = [Decimal(el) for el in w]\n e = numpy.exp(numpy.array(w) / Decimal(t))\n dist = e / numpy.sum(e)\n return dist", "docstring": "Calculate the softmax of a list of numbers w.\n\n Parameters\n ----------\n w : list of numbers\n\n Returns\n -------\n a list of the same length as w of non-negative numbers\n\n Examples\n --------\n >>> softmax([0.1, 0.2])\n array([ 0.47502081, 0.52497919])\n >>> softmax([-0.1, 0.2])\n array([ 0.42555748, 0.57444252])\n >>> softmax([0.9, -10])\n array([ 9.99981542e-01, 1.84578933e-05])\n >>> softmax([0, 10])\n array([ 4.53978687e-05, 9.99954602e-01])" }, { "code": "def create_usuario(self):\n return Usuario(\n self.networkapi_url,\n self.user,\n self.password,\n self.user_ldap)", "docstring": "Get an instance of usuario services facade." }, { "code": "def samples(self):\n if self._samples is None:\n self._samples = SampleList(\n self._version,\n assistant_sid=self._solution['assistant_sid'],\n task_sid=self._solution['sid'],\n )\n return self._samples", "docstring": "Access the samples\n\n :returns: twilio.rest.autopilot.v1.assistant.task.sample.SampleList\n :rtype: twilio.rest.autopilot.v1.assistant.task.sample.SampleList" }, { "code": "def get_missing_required_annotations(self) -> List[str]:\n return [\n required_annotation\n for required_annotation in self.required_annotations\n if required_annotation not in self.annotations\n ]", "docstring": "Return missing required annotations." }, { "code": "def service(self, name=None, pk=None, scope=None, **kwargs):\n _services = self.services(name=name, pk=pk, scope=scope, **kwargs)\n if len(_services) == 0:\n raise NotFoundError(\"No service fits criteria\")\n if len(_services) != 1:\n raise MultipleFoundError(\"Multiple services fit criteria\")\n return _services[0]", "docstring": "Retrieve single KE-chain Service.\n\n Uses the same interface as the :func:`services` method but returns only a single pykechain\n :class:`models.Service` instance.\n\n :param name: (optional) name to limit the search for\n :type name: basestring or None\n :param pk: (optional) primary key or id (UUID) of the service to search for\n :type pk: basestring or None\n :param scope: (optional) id (UUID) of the scope to search in\n :type scope: basestring or None\n :param kwargs: (optional) additional search keyword arguments\n :type kwargs: dict or None\n :return: a single :class:`models.Service` object\n :raises NotFoundError: When no `Service` object is found\n :raises MultipleFoundError: When more than a single `Service` object is found" }, { "code": "def options(self, parser, env=os.environ):\n \"Add options to nosetests.\"\n parser.add_option(\"--%s-record\" % self.name,\n action=\"store\",\n metavar=\"FILE\",\n dest=\"record_filename\",\n help=\"Record actions to this file.\")\n parser.add_option(\"--%s-playback\" % self.name,\n action=\"store\",\n metavar=\"FILE\",\n dest=\"playback_filename\",\n help=\"Playback actions from this file.\")", "docstring": "Add options to nosetests." }, { "code": "def get_loss(self, y_pred, y_true, X=None, training=False):\n y_true = to_tensor(y_true, device=self.device)\n return self.criterion_(y_pred, y_true)", "docstring": "Return the loss for this batch.\n\n Parameters\n ----------\n y_pred : torch tensor\n Predicted target values\n\n y_true : torch tensor\n True target values.\n\n X : input data, compatible with skorch.dataset.Dataset\n By default, you should be able to pass:\n\n * numpy arrays\n * torch tensors\n * pandas DataFrame or Series\n * scipy sparse CSR matrices\n * a dictionary of the former three\n * a list/tuple of the former three\n * a Dataset\n\n If this doesn't work with your data, you have to pass a\n ``Dataset`` that can deal with the data.\n\n training : bool (default=False)\n Whether train mode should be used or not." }, { "code": "def uncomplete(self):\n args = {\n 'project_id': self.project.id,\n 'ids': [self.id]\n }\n owner = self.project.owner\n _perform_command(owner, 'item_uncomplete', args)", "docstring": "Mark the task uncomplete.\n\n >>> from pytodoist import todoist\n >>> user = todoist.login('john.doe@gmail.com', 'password')\n >>> project = user.get_project('PyTodoist')\n >>> task = project.add_task('Install PyTodoist')\n >>> task.uncomplete()" }, { "code": "def assert_succeeds(exception, msg_fmt=\"{msg}\"):\n class _AssertSucceeds(object):\n def __enter__(self):\n pass\n def __exit__(self, exc_type, exc_val, exc_tb):\n if exc_type and issubclass(exc_type, exception):\n msg = exception.__name__ + \" was unexpectedly raised\"\n fail(\n msg_fmt.format(\n msg=msg,\n exc_type=exception,\n exc_name=exception.__name__,\n exception=exc_val,\n )\n )\n return _AssertSucceeds()", "docstring": "Fail if a specific exception is raised within the context.\n\n This assertion should be used for cases, where successfully running a\n function signals a successful test, and raising the exception of a\n certain type signals a test failure. All other raised exceptions are\n passed on and will usually still result in a test error. This can be\n used to signal the intent of a block.\n\n >>> l = [\"foo\", \"bar\"]\n >>> with assert_succeeds(ValueError):\n ... i = l.index(\"foo\")\n ...\n >>> with assert_succeeds(ValueError):\n ... raise ValueError()\n ...\n Traceback (most recent call last):\n ...\n AssertionError: ValueError was unexpectedly raised\n >>> with assert_succeeds(ValueError):\n ... raise TypeError(\"Wrong Error\")\n ...\n Traceback (most recent call last):\n ...\n TypeError: Wrong Error\n\n The following msg_fmt arguments are supported:\n * msg - the default error message\n * exc_type - exception type\n * exc_name - exception type name\n * exception - exception that was raised" }, { "code": "def add_vlan_firewall(self, vlan_id, ha_enabled=False):\n package = self.get_dedicated_package(ha_enabled)\n product_order = {\n 'complexType': 'SoftLayer_Container_Product_Order_Network_'\n 'Protection_Firewall_Dedicated',\n 'quantity': 1,\n 'packageId': 0,\n 'vlanId': vlan_id,\n 'prices': [{'id': package[0]['prices'][0]['id']}]\n }\n return self.client['Product_Order'].placeOrder(product_order)", "docstring": "Creates a firewall for the specified vlan.\n\n :param int vlan_id: The ID of the vlan to create the firewall for\n :param bool ha_enabled: If True, an HA firewall will be created\n\n :returns: A dictionary containing the VLAN firewall order" }, { "code": "def _detect_line_ending(self):\n candidate_value = '\\n'\n candidate_count = 0\n for line_ending in UniversalCsvReader.line_endings:\n count = self._sample.count(line_ending)\n if count > candidate_count:\n candidate_value = line_ending\n candidate_count = count\n self._formatting_parameters['line_terminator'] = candidate_value", "docstring": "Detects the line ending in the sample data." }, { "code": "def ping():\n if _worker_name() not in DETAILS:\n init()\n try:\n return DETAILS[_worker_name()].conn.isalive()\n except TerminalException as e:\n log.error(e)\n return False", "docstring": "Ping the device on the other end of the connection\n\n .. code-block: bash\n\n salt '*' onyx.cmd ping" }, { "code": "def handle_cancellation(session: CommandSession):\n def control(value):\n if _is_cancellation(value) is True:\n session.finish(render_expression(\n session.bot.config.SESSION_CANCEL_EXPRESSION))\n return value\n return control", "docstring": "If the input is a string of cancellation word, finish the command session." }, { "code": "def __get_connection(self) -> redis.Redis:\n if self.__redis_use_socket:\n r = redis.from_url(\n 'unix://{:s}?db={:d}'.format(\n self.__redis_host,\n self.__redis_db\n )\n )\n else:\n r = redis.from_url(\n 'redis://{:s}:{:d}/{:d}'.format(\n self.__redis_host,\n self.__redis_port,\n self.__redis_db\n )\n )\n if BlackRed.Settings.REDIS_AUTH is not None:\n r.execute_command('AUTH {:s}'.format(BlackRed.Settings.REDIS_AUTH))\n return r", "docstring": "Get a Redis connection\n\n :return: Redis connection instance\n :rtype: redis.Redis" }, { "code": "def load_brain_metadata(proxy, include_fields):\n ret = {}\n for index in proxy.indexes():\n if index not in proxy:\n continue\n if include_fields and index not in include_fields:\n continue\n val = getattr(proxy, index)\n if val != Missing.Value:\n try:\n json.dumps(val)\n except:\n continue\n ret[index] = val\n return ret", "docstring": "Load values from the catalog metadata into a list of dictionaries" }, { "code": "def select_single_column(engine, column):\n s = select([column])\n return column.name, [row[0] for row in engine.execute(s)]", "docstring": "Select data from single column.\n\n Example::\n\n >>> select_single_column(engine, table_user.c.id)\n [1, 2, 3]\n\n >>> select_single_column(engine, table_user.c.name)\n [\"Alice\", \"Bob\", \"Cathy\"]" }, { "code": "def gopro_set_response_send(self, cmd_id, status, force_mavlink1=False):\n return self.send(self.gopro_set_response_encode(cmd_id, status), force_mavlink1=force_mavlink1)", "docstring": "Response from a GOPRO_COMMAND set request\n\n cmd_id : Command ID (uint8_t)\n status : Status (uint8_t)" }, { "code": "def truth(f):\n @wraps(f)\n def check(v):\n t = f(v)\n if not t:\n raise ValueError\n return v\n return check", "docstring": "Convenience decorator to convert truth functions into validators.\n\n >>> @truth\n ... def isdir(v):\n ... return os.path.isdir(v)\n >>> validate = Schema(isdir)\n >>> validate('/')\n '/'\n >>> with raises(MultipleInvalid, 'not a valid value'):\n ... validate('/notavaliddir')" }, { "code": "def parenthesize(self, expr, level, *args, strict=False, **kwargs):\n needs_parenths = (\n (precedence(expr) < level) or\n (strict and precedence(expr) == level))\n if needs_parenths:\n return (\n self._parenth_left + self.doprint(expr, *args, **kwargs) +\n self._parenth_right)\n else:\n return self.doprint(expr, *args, **kwargs)", "docstring": "Render `expr` and wrap the result in parentheses if the precedence\n of `expr` is below the given `level` (or at the given `level` if\n `strict` is True. Extra `args` and `kwargs` are passed to the internal\n `doit` renderer" }, { "code": "def main():\n print()\n print(\"-~*~--~*~--~*~--~*~--~*~--~*~--~*~--~*~--~*~--~*~-\")\n print(lorem_gotham_title().center(50))\n print(\"-~*~--~*~--~*~--~*~--~*~--~*~--~*~--~*~--~*~--~*~-\")\n print()\n poem = lorem_gotham()\n for n in range(16):\n if n in (4, 8, 12):\n print()\n print(next(poem))\n print()", "docstring": "I provide a command-line interface for this module" }, { "code": "def write(self, **kwargs):\n if 'id' in kwargs and 'data' in kwargs:\n result = self.write_raw(kwargs['id'], kwargs['data'],\n bus=kwargs.get('bus', None),\n frame_format=kwargs.get('frame_format', None))\n else:\n result = self.write_translated(kwargs['name'], kwargs['value'],\n event=kwargs.get('event', None))\n return result", "docstring": "Serialize a raw or translated write request and send it to the VI,\n following the OpenXC message format." }, { "code": "def autopage(self):\n while self.items:\n yield from self.items\n self.items = self.fetch_next()", "docstring": "Iterate through results from all pages.\n\n :return: all results\n :rtype: generator" }, { "code": "def evaluate_at(self, eval_at, testcases, mode=None):\n self.eval_at = eval_at\n self.log.eval_at = eval_at\n if mode is None:\n if self.context_mode is None or (self.context_mode.has_key('choose_m') and self.context_mode['choose_m']):\n mode = 'inverse'\n else:\n mode = self.context_mode[\"mode\"]\n self.evaluation = Evaluation(self.ag, self.env, testcases, mode=mode)\n for test in testcases:\n self.log.add('testcases', test)", "docstring": "Sets the evaluation interation indices.\n\n :param list eval_at: iteration indices where an evaluation should be performed\n :param numpy.array testcases: testcases used for evaluation" }, { "code": "def relpath(self, path, start=None):\n if not path:\n raise ValueError(\"no path specified\")\n path = make_string_path(path)\n if start is not None:\n start = make_string_path(start)\n else:\n start = self.filesystem.cwd\n if self.filesystem.alternative_path_separator is not None:\n path = path.replace(self.filesystem.alternative_path_separator,\n self._os_path.sep)\n start = start.replace(self.filesystem.alternative_path_separator,\n self._os_path.sep)\n path = path.replace(self.filesystem.path_separator, self._os_path.sep)\n start = start.replace(\n self.filesystem.path_separator, self._os_path.sep)\n path = self._os_path.relpath(path, start)\n return path.replace(self._os_path.sep, self.filesystem.path_separator)", "docstring": "We mostly rely on the native implementation and adapt the\n path separator." }, { "code": "def _parse_mods(mods):\n if isinstance(mods, six.string_types):\n mods = [item.strip() for item in mods.split(',') if item.strip()]\n return mods", "docstring": "Parse modules." }, { "code": "def _handle_requests_params(self, kwargs):\n requests_params = kwargs.pop('requests_params', {})\n for param in requests_params:\n if param in kwargs:\n error_message = 'Requests Parameter %r collides with a load'\\\n ' parameter of the same name.' % param\n raise RequestParamKwargCollision(error_message)\n if self._meta_data['icontrol_version']:\n params = requests_params.pop('params', {})\n params.update({'ver': self._meta_data['icontrol_version']})\n requests_params.update({'params': params})\n return requests_params", "docstring": "Validate parameters that will be passed to the requests verbs.\n\n This method validates that there is no conflict in the names of the\n requests_params passed to the function and the other kwargs. It also\n ensures that the required request parameters for the object are\n added to the request params that are passed into the verbs. An\n example of the latter is ensuring that a certain version of the API\n is always called to add 'ver=11.6.0' to the url." }, { "code": "def record(self):\n if not self._initialized:\n raise pycdlibexception.PyCdlibInternalError('UDF Timestamp not initialized')\n tmp = ((1 << 16) - 1) & self.tz\n newtz = tmp & 0xff\n newtimetype = ((tmp >> 8) & 0x0f) | (self.timetype << 4)\n return struct.pack(self.FMT, newtz, newtimetype, self.year, self.month,\n self.day, self.hour, self.minute, self.second,\n self.centiseconds, self.hundreds_microseconds,\n self.microseconds)", "docstring": "A method to generate the string representing this UDF Timestamp.\n\n Parameters:\n None.\n Returns:\n A string representing this UDF Timestamp." }, { "code": "def _remove_overlaps(in_file, out_dir, data):\n out_file = os.path.join(out_dir, \"%s-nooverlaps%s\" % utils.splitext_plus(os.path.basename(in_file)))\n if not utils.file_uptodate(out_file, in_file):\n with file_transaction(data, out_file) as tx_out_file:\n with open(in_file) as in_handle:\n with open(tx_out_file, \"w\") as out_handle:\n prev_line = None\n for line in in_handle:\n if prev_line:\n pchrom, pstart, pend = prev_line.split(\"\\t\", 4)[:3]\n cchrom, cstart, cend = line.split(\"\\t\", 4)[:3]\n if pchrom == cchrom and int(pend) > int(cstart):\n pass\n else:\n out_handle.write(prev_line)\n prev_line = line\n out_handle.write(prev_line)\n return out_file", "docstring": "Remove regions that overlap with next region, these result in issues with PureCN." }, { "code": "def on_epoch_end(self, epoch, **kwargs:Any)->None:\n \"Compare the value monitored to its best and maybe reduce lr.\"\n current = self.get_monitor_value()\n if current is None: return\n if self.operator(current - self.min_delta, self.best): self.best,self.wait = current,0\n else:\n self.wait += 1\n if self.wait > self.patience:\n self.opt.lr *= self.factor\n self.wait = 0\n print(f'Epoch {epoch}: reducing lr to {self.opt.lr}')", "docstring": "Compare the value monitored to its best and maybe reduce lr." }, { "code": "def parse_dsn(dsn):\n parsed_dsn = urlparse(dsn)\n parsed_path = parse_path(parsed_dsn.path)\n return {\n 'scheme': parsed_dsn.scheme,\n 'sender': parsed_dsn.username,\n 'token': parsed_dsn.password,\n 'domain': parsed_dsn.hostname,\n 'port': parsed_dsn.port or 80,\n 'version': parsed_path.get('version'),\n 'project': parsed_path.get('project'),\n }", "docstring": "Parse dsn string." }, { "code": "def _key_to_address(key):\n key_parts = key.split('.', maxsplit=_MAX_KEY_PARTS - 1)\n key_parts.extend([''] * (_MAX_KEY_PARTS - len(key_parts)))\n return SETTINGS_NAMESPACE + ''.join(_short_hash(x) for x in key_parts)", "docstring": "Creates the state address for a given setting key." }, { "code": "def flightmode_colours():\n from MAVProxy.modules.lib.grapher import flightmode_colours\n mapping = {}\n idx = 0\n for (mode,t0,t1) in flightmodes:\n if not mode in mapping:\n mapping[mode] = flightmode_colours[idx]\n idx += 1\n if idx >= len(flightmode_colours):\n idx = 0\n return mapping", "docstring": "return mapping of flight mode to colours" }, { "code": "def import_task(self, img, cont, img_format=None, img_name=None):\n return self._tasks_manager.create(\"import\", img=img, cont=cont,\n img_format=img_format, img_name=img_name)", "docstring": "Creates a task to import the specified image from the swift container\n named in the 'cont' parameter. The new image will be named the same as\n the object in the container unless you specify a value for the\n 'img_name' parameter.\n\n By default it is assumed that the image is in 'vhd' format; if it is\n another format, you must specify that in the 'img_format' parameter." }, { "code": "def find_user(self, username=None, email=None):\n if username:\n return (\n self.get_session.query(self.user_model)\n .filter(func.lower(self.user_model.username) == func.lower(username))\n .first()\n )\n elif email:\n return (\n self.get_session.query(self.user_model).filter_by(email=email).first()\n )", "docstring": "Finds user by username or email" }, { "code": "def get(self, section, option, default = None):\r\n if self.has_section(section):\r\n try:\r\n return self.config[section][option].get('value', None)\r\n except KeyError:\r\n if default == None:\r\n raise NoOptionError(option)\r\n else:\r\n return default\r\n else:\r\n raise NoSectionError(section)", "docstring": "Returns the option's value converted into it's intended type. If default is specified, return that on failure, else raise NoOptionError." }, { "code": "def adapt_files(solver):\n print(\"adapting {0}'s files\".format(solver))\n root = os.path.join('solvers', solver)\n for arch in to_extract[solver]:\n arch = os.path.join(root, arch)\n extract_archive(arch, solver, put_inside=True)\n for fnames in to_move[solver]:\n old = os.path.join(root, fnames[0])\n new = os.path.join(root, fnames[1])\n os.rename(old, new)\n for f in to_remove[solver]:\n f = os.path.join(root, f)\n if os.path.isdir(f):\n shutil.rmtree(f)\n else:\n os.remove(f)", "docstring": "Rename and remove files whenever necessary." }, { "code": "def fillna(self, value=None, method=None, limit=None):\n if ((method is None and value is None) or\n (method is not None and value is not None)):\n raise ValueError(\"Must specify one of 'method' or 'value'.\")\n elif method is not None:\n msg = \"fillna with 'method' requires high memory usage.\"\n warnings.warn(msg, PerformanceWarning)\n filled = interpolate_2d(np.asarray(self), method=method,\n limit=limit)\n return type(self)(filled, fill_value=self.fill_value)\n else:\n new_values = np.where(isna(self.sp_values), value, self.sp_values)\n if self._null_fill_value:\n new_dtype = SparseDtype(self.dtype.subtype, fill_value=value)\n else:\n new_dtype = self.dtype\n return self._simple_new(new_values, self._sparse_index, new_dtype)", "docstring": "Fill missing values with `value`.\n\n Parameters\n ----------\n value : scalar, optional\n method : str, optional\n\n .. warning::\n\n Using 'method' will result in high memory use,\n as all `fill_value` methods will be converted to\n an in-memory ndarray\n\n limit : int, optional\n\n Returns\n -------\n SparseArray\n\n Notes\n -----\n When `value` is specified, the result's ``fill_value`` depends on\n ``self.fill_value``. The goal is to maintain low-memory use.\n\n If ``self.fill_value`` is NA, the result dtype will be\n ``SparseDtype(self.dtype, fill_value=value)``. This will preserve\n amount of memory used before and after filling.\n\n When ``self.fill_value`` is not NA, the result dtype will be\n ``self.dtype``. Again, this preserves the amount of memory used." }, { "code": "def _get_lrs(self, indices):\n if self.lr_scheduler is not None:\n lr = self.lr_scheduler(self.num_update)\n else:\n lr = self.lr\n lrs = [lr for _ in indices]\n for i, index in enumerate(indices):\n if index in self.param_dict:\n lrs[i] *= self.param_dict[index].lr_mult\n elif index in self.lr_mult:\n lrs[i] *= self.lr_mult[index]\n elif index in self.idx2name:\n lrs[i] *= self.lr_mult.get(self.idx2name[index], 1.0)\n return lrs", "docstring": "Gets the learning rates given the indices of the weights.\n\n Parameters\n ----------\n indices : list of int\n Indices corresponding to weights.\n\n Returns\n -------\n lrs : list of float\n Learning rates for those indices." }, { "code": "def huffman_encode(cls, s):\n i = 0\n ibl = 0\n for c in s:\n val, bl = cls._huffman_encode_char(c)\n i = (i << bl) + val\n ibl += bl\n padlen = 8 - (ibl % 8)\n if padlen != 8:\n val, bl = cls._huffman_encode_char(EOS())\n i = (i << padlen) + (val >> (bl - padlen))\n ibl += padlen\n ret = i, ibl\n assert(ret[0] >= 0)\n assert (ret[1] >= 0)\n return ret", "docstring": "huffman_encode returns the bitstring and the bitlength of the\n bitstring representing the string provided as a parameter\n\n @param str s: the string to encode\n @return (int, int): the bitstring of s and its bitlength\n @raise AssertionError" }, { "code": "def _call(self, x, out=None):\n if out is None:\n out = x[self.index].copy()\n else:\n out.assign(x[self.index])\n return out", "docstring": "Project ``x`` onto the subspace." }, { "code": "def setup_prj_page(self, ):\n self.prj_seq_tablev.horizontalHeader().setResizeMode(QtGui.QHeaderView.ResizeToContents)\n self.prj_atype_tablev.horizontalHeader().setResizeMode(QtGui.QHeaderView.ResizeToContents)\n self.prj_dep_tablev.horizontalHeader().setResizeMode(QtGui.QHeaderView.ResizeToContents)\n self.prj_user_tablev.horizontalHeader().setResizeMode(QtGui.QHeaderView.ResizeToContents)", "docstring": "Create and set the model on the project page\n\n :returns: None\n :rtype: None\n :raises: None" }, { "code": "def to_dict(self):\n mydict = {'id': self.id, 'name': self.name,\n 'description': self.description,\n 'kbtype': self.kbtype}\n if self.kbtype == 'd':\n mydict.update((self.kbdefs.to_dict() if self.kbdefs else {}) or {})\n return mydict", "docstring": "Return a dict representation of KnwKB." }, { "code": "def delete_insight(self, project_key, insight_id):\n projectOwner, projectId = parse_dataset_key(project_key)\n try:\n self._insights_api.delete_insight(projectOwner,\n projectId,\n insight_id)\n except _swagger.rest.ApiException as e:\n raise RestApiError(cause=e)", "docstring": "Delete an existing insight.\n\n :params project_key: Project identifier, in the form of\n projectOwner/projectId\n :type project_key: str\n :params insight_id: Insight unique id\n :type insight_id: str\n :raises RestApiException: If a server error occurs\n\n Examples\n --------\n >>> import datadotworld as dw\n >>> api_client = dw.api_client()\n >>> del_insight = api_client.delete_insight(\n ... 'username/project', 'insightid') # doctest: +SKIP" }, { "code": "def dump(obj, fp):\n encoder = ArffEncoder()\n generator = encoder.iter_encode(obj)\n last_row = next(generator)\n for row in generator:\n fp.write(last_row + u'\\n')\n last_row = row\n fp.write(last_row)\n return fp", "docstring": "Serialize an object representing the ARFF document to a given file-like\n object.\n\n :param obj: a dictionary.\n :param fp: a file-like object." }, { "code": "def power(base, exp):\n return _ufunc_helper(\n base,\n exp,\n op.broadcast_power,\n operator.pow,\n _internal._power_scalar,\n _internal._rpower_scalar)", "docstring": "Returns result of first array elements raised to powers from second array, element-wise\n with broadcasting.\n\n Equivalent to ``base ** exp`` and ``mx.nd.broadcast_power(lhs, rhs)``.\n\n .. note::\n\n If the corresponding dimensions of two arrays have the same size or one of them has size 1,\n then the arrays are broadcastable to a common shape.\n\n Parameters\n ----------\n base : scalar or NDArray\n The base array\n exp : scalar or NDArray\n The exponent array. If ``base.shape != exp.shape``, they must be\n broadcastable to a common shape.\n\n Returns\n --------\n NDArray\n The bases in x raised to the exponents in y.\n\n Examples\n --------\n >>> x = mx.nd.ones((2,3))*2\n >>> y = mx.nd.arange(1,3).reshape((2,1))\n >>> z = mx.nd.arange(1,3).reshape((2,1))\n >>> x.asnumpy()\n array([[ 2., 2., 2.],\n [ 2., 2., 2.]], dtype=float32)\n >>> y.asnumpy()\n array([[ 1.],\n [ 2.]], dtype=float32)\n >>> z.asnumpy()\n array([[ 1.],\n [ 2.]], dtype=float32)\n >>> (x**2).asnumpy()\n array([[ 4., 4., 4.],\n [ 4., 4., 4.]], dtype=float32)\n >>> (x**y).asnumpy()\n array([[ 2., 2., 2.],\n [ 4., 4., 4.]], dtype=float32)\n >>> mx.nd.power(x,y).asnumpy()\n array([[ 2., 2., 2.],\n [ 4., 4., 4.]], dtype=float32)\n >>> (z**y).asnumpy()\n array([[ 1.],\n [ 4.]], dtype=float32)" }, { "code": "def gradient(poly):\n return differential(poly, chaospy.poly.collection.basis(1, 1, poly.dim))", "docstring": "Gradient of a polynomial.\n\n Args:\n poly (Poly) : polynomial to take gradient of.\n\n Returns:\n (Poly) : The resulting gradient.\n\n Examples:\n >>> q0, q1, q2 = chaospy.variable(3)\n >>> poly = 2*q0 + q1*q2\n >>> print(chaospy.gradient(poly))\n [2, q2, q1]" }, { "code": "async def get_alarms():\n async with aiohttp.ClientSession() as session:\n ghlocalapi = Alarms(LOOP, session, IPADDRESS)\n await ghlocalapi.get_alarms()\n print(\"Alarms:\", ghlocalapi.alarms)", "docstring": "Get alarms and timers from GH." }, { "code": "def winddir_text(pts):\n \"Convert wind direction from 0..15 to compass point text\"\n global _winddir_text_array\n if pts is None:\n return None\n if not isinstance(pts, int):\n pts = int(pts + 0.5) % 16\n if not _winddir_text_array:\n _ = pywws.localisation.translation.ugettext\n _winddir_text_array = (\n _(u'N'), _(u'NNE'), _(u'NE'), _(u'ENE'),\n _(u'E'), _(u'ESE'), _(u'SE'), _(u'SSE'),\n _(u'S'), _(u'SSW'), _(u'SW'), _(u'WSW'),\n _(u'W'), _(u'WNW'), _(u'NW'), _(u'NNW'),\n )\n return _winddir_text_array[pts]", "docstring": "Convert wind direction from 0..15 to compass point text" }, { "code": "def _format_metric_name(self, m_name, cfunc):\n try:\n aggr = CFUNC_TO_AGGR[cfunc]\n except KeyError:\n aggr = cfunc.lower()\n try:\n m_name = CACTI_TO_DD[m_name]\n if aggr != 'avg':\n m_name += '.{}'.format(aggr)\n return m_name\n except KeyError:\n return \"cacti.{}.{}\".format(m_name.lower(), aggr)", "docstring": "Format a cacti metric name into a Datadog-friendly name" }, { "code": "def fit_gaussian(x, y, yerr, p0):\n try:\n popt, pcov = curve_fit(gaussian, x, y, sigma=yerr, p0=p0, absolute_sigma=True)\n except RuntimeError:\n return [0],[0]\n return popt, pcov", "docstring": "Fit a Gaussian to the data" }, { "code": "def _align_bags(predicted: List[Set[str]], gold: List[Set[str]]) -> List[float]:\n f1_scores = []\n for gold_index, gold_item in enumerate(gold):\n max_f1 = 0.0\n max_index = None\n best_alignment: Tuple[Set[str], Set[str]] = (set(), set())\n if predicted:\n for pred_index, pred_item in enumerate(predicted):\n current_f1 = _compute_f1(pred_item, gold_item)\n if current_f1 >= max_f1:\n best_alignment = (gold_item, pred_item)\n max_f1 = current_f1\n max_index = pred_index\n match_flag = _match_numbers_if_present(*best_alignment)\n gold[gold_index] = set()\n predicted[max_index] = set()\n else:\n match_flag = False\n if match_flag:\n f1_scores.append(max_f1)\n else:\n f1_scores.append(0.0)\n return f1_scores", "docstring": "Takes gold and predicted answer sets and first finds a greedy 1-1 alignment\n between them and gets maximum metric values over all the answers" }, { "code": "def _on_report(_loop, adapter, conn_id, report):\n conn_string = None\n if conn_id is not None:\n conn_string = adapter._get_property(conn_id, 'connection_string')\n if isinstance(report, BroadcastReport):\n adapter.notify_event_nowait(conn_string, 'broadcast', report)\n elif conn_string is not None:\n adapter.notify_event_nowait(conn_string, 'report', report)\n else:\n adapter._logger.debug(\"Dropping report with unknown conn_id=%s\", conn_id)", "docstring": "Callback when a report is received." }, { "code": "def calc_progress(self, completed_count, total_count):\n self.logger.debug(\n \"calc_progress(%s, %s)\",\n completed_count,\n total_count,\n )\n current_time = time.time()\n time_spent = current_time - self.start_time\n self.logger.debug(\"Progress time spent: %s\", time_spent)\n if total_count == 0:\n return 100, 1\n completion_fraction = completed_count / total_count\n if completion_fraction == 0:\n completion_fraction = 1\n total_time = 0\n total_time = time_spent / completion_fraction\n time_remaining = total_time - time_spent\n completion_display = completion_fraction * 100\n if completion_display == 100:\n return 100, 1\n return completion_display, time_remaining", "docstring": "Calculate the percentage progress and estimated remaining time based on\n the current number of items completed of the total.\n\n Returns a tuple of ``(percentage_complete, seconds_remaining)``." }, { "code": "def createService(self, createServiceParameter,\n description=None,\n tags=\"Feature Service\",\n snippet=None):\n url = \"%s/createService\" % self.location\n val = createServiceParameter.value\n params = {\n \"f\" : \"json\",\n \"outputType\" : \"featureService\",\n \"createParameters\" : json.dumps(val),\n \"tags\" : tags\n }\n if snippet is not None:\n params['snippet'] = snippet\n if description is not None:\n params['description'] = description\n res = self._post(url=url,\n param_dict=params,\n securityHandler=self._securityHandler,\n proxy_port=self._proxy_port,\n proxy_url=self._proxy_url)\n if 'id' in res or \\\n 'serviceItemId' in res:\n if 'id' in res:\n url = \"%s/items/%s\" % (self.location, res['id'])\n else:\n url = \"%s/items/%s\" % (self.location, res['serviceItemId'])\n return UserItem(url=url,\n securityHandler=self._securityHandler,\n proxy_url=self._proxy_url,\n proxy_port=self._proxy_port)\n return res", "docstring": "The Create Service operation allows users to create a hosted\n feature service. You can use the API to create an empty hosted\n feaure service from feature service metadata JSON.\n\n Inputs:\n createServiceParameter - create service object" }, { "code": "def _get_best_prediction(self, record, train=True):\n if not self.trees:\n return\n best = (+1e999999, None)\n for tree in self.trees:\n best = min(best, (tree.mae.mean, tree))\n _, best_tree = best\n prediction, tree_mae = best_tree.predict(record, train=train)\n return prediction.mean", "docstring": "Gets the prediction from the tree with the lowest mean absolute error." }, { "code": "def check_in(choices, **params):\n for p in params:\n if params[p] not in choices:\n raise ValueError(\n \"{} value {} not recognized. Choose from {}\".format(\n p, params[p], choices))", "docstring": "Checks parameters are in a list of allowed parameters\n\n Parameters\n ----------\n\n choices : array-like, accepted values\n\n params : object\n Named arguments, parameters to be checked\n\n Raises\n ------\n ValueError : unacceptable choice of parameters" }, { "code": "def write_frames(self, frames_out):\n self.check_for_errors()\n self._connection.write_frames(self.channel_id, frames_out)", "docstring": "Write multiple pamqp frames from the current channel.\n\n :param list frames_out: A list of pamqp frames.\n\n :return:" }, { "code": "def connections(self):\n conn = lambda x: str(x).replace('connection:', '')\n return [conn(name) for name in self.sections()]", "docstring": "Returns all of the loaded connections names as a list" }, { "code": "def circuit_to_pyquil(circuit: Circuit) -> pyquil.Program:\n prog = pyquil.Program()\n for elem in circuit.elements:\n if isinstance(elem, Gate) and elem.name in QUIL_GATES:\n params = list(elem.params.values()) if elem.params else []\n prog.gate(elem.name, params, elem.qubits)\n elif isinstance(elem, Measure):\n prog.measure(elem.qubit, elem.cbit)\n else:\n raise ValueError('Cannot convert operation to pyquil')\n return prog", "docstring": "Convert a QuantumFlow circuit to a pyQuil program" }, { "code": "def getBounds(self, tzinfo=None):\n if self.resolution >= datetime.timedelta(days=1) \\\n and tzinfo is not None:\n time = self._time.replace(tzinfo=tzinfo)\n else:\n time = self._time\n return (\n min(self.fromDatetime(time), self.fromDatetime(self._time)),\n max(self.fromDatetime(time + self.resolution),\n self.fromDatetime(self._time + self.resolution))\n )", "docstring": "Return a pair describing the bounds of self.\n\n This returns a pair (min, max) of Time instances. It is not quite the\n same as (self, self + self.resolution). This is because timezones are\n insignificant for instances with a resolution greater or equal to 1\n day.\n\n To illustrate the problem, consider a Time instance::\n\n T = Time.fromHumanly('today', tzinfo=anything)\n\n This will return an equivalent instance independent of the tzinfo used.\n The hour, minute, and second of this instance are 0, and its resolution\n is one day.\n\n Now say we have a sorted list of times, and we want to get all times\n for 'today', where whoever said 'today' is in a timezone that's 5 hours\n ahead of UTC. The start of 'today' in this timezone is UTC 05:00. The\n example instance T above is before this, but obviously it is today.\n\n The min and max times this returns are such that all potentially\n matching instances are within this range. However, this range might\n contain unmatching instances.\n\n As an example of this, if 'today' is April first 2005, then\n Time.fromISO8601TimeAndDate('2005-04-01T00:00:00') sorts in the same\n place as T from above, but is not in the UTC+5 'today'.\n\n TIME IS FUN!" }, { "code": "def Analyze(self, hashes):\n hash_analyses = []\n for digest in hashes:\n json_response = self._QueryHash(digest)\n hash_analysis = interface.HashAnalysis(digest, json_response)\n hash_analyses.append(hash_analysis)\n return hash_analyses", "docstring": "Looks up hashes in Viper using the Viper HTTP API.\n\n Args:\n hashes (list[str]): hashes to look up.\n\n Returns:\n list[HashAnalysis]: hash analysis.\n\n Raises:\n RuntimeError: If no host has been set for Viper." }, { "code": "def check_url (aggregate):\n while True:\n try:\n aggregate.urlqueue.join(timeout=30)\n break\n except urlqueue.Timeout:\n aggregate.remove_stopped_threads()\n if not any(aggregate.get_check_threads()):\n break", "docstring": "Helper function waiting for URL queue." }, { "code": "def save(self, t, base=0, heap=False):\n c, k = _keytuple(t)\n if k and k not in _typedefs:\n _typedefs[k] = self\n if c and c not in _typedefs:\n if t.__module__ in _builtin_modules:\n k = _kind_ignored\n else:\n k = self.kind\n _typedefs[c] = _Typedef(base=_basicsize(type(t), base=base, heap=heap),\n refs=_type_refs,\n both=False, kind=k, type=t)\n elif isbuiltin(t) and t not in _typedefs:\n _typedefs[t] = _Typedef(base=_basicsize(t, base=base),\n both=False, kind=_kind_ignored, type=t)\n else:\n raise KeyError('asizeof typedef %r bad: %r %r' % (self, (c, k), self.both))", "docstring": "Save this typedef plus its class typedef." }, { "code": "def cleanup_virtualenv(bare=True):\n if not bare:\n click.echo(crayons.red(\"Environment creation aborted.\"))\n try:\n vistir.path.rmtree(project.virtualenv_location)\n except OSError as e:\n click.echo(\n \"{0} An error occurred while removing {1}!\".format(\n crayons.red(\"Error: \", bold=True),\n crayons.green(project.virtualenv_location),\n ),\n err=True,\n )\n click.echo(crayons.blue(e), err=True)", "docstring": "Removes the virtualenv directory from the system." }, { "code": "def calendar_dates(self, val):\n self._calendar_dates = val\n if val is not None and not val.empty:\n self._calendar_dates_g = self._calendar_dates.groupby(\n [\"service_id\", \"date\"]\n )\n else:\n self._calendar_dates_g = None", "docstring": "Update ``self._calendar_dates_g``\n if ``self.calendar_dates`` changes." }, { "code": "def configure_sources(update=False,\n sources_var='install_sources',\n keys_var='install_keys'):\n sources = safe_load((config(sources_var) or '').strip()) or []\n keys = safe_load((config(keys_var) or '').strip()) or None\n if isinstance(sources, six.string_types):\n sources = [sources]\n if keys is None:\n for source in sources:\n add_source(source, None)\n else:\n if isinstance(keys, six.string_types):\n keys = [keys]\n if len(sources) != len(keys):\n raise SourceConfigError(\n 'Install sources and keys lists are different lengths')\n for source, key in zip(sources, keys):\n add_source(source, key)\n if update:\n _fetch_update(fatal=True)", "docstring": "Configure multiple sources from charm configuration.\n\n The lists are encoded as yaml fragments in the configuration.\n The fragment needs to be included as a string. Sources and their\n corresponding keys are of the types supported by add_source().\n\n Example config:\n install_sources: |\n - \"ppa:foo\"\n - \"http://example.com/repo precise main\"\n install_keys: |\n - null\n - \"a1b2c3d4\"\n\n Note that 'null' (a.k.a. None) should not be quoted." }, { "code": "def _check_certificate(self):\n if (self.file_name.startswith(\"jdk-\") and self.repo == \"sbo\" and\n self.downder == \"wget\"):\n certificate = (' --no-check-certificate --header=\"Cookie: '\n 'oraclelicense=accept-securebackup-cookie\"')\n self.msg.template(78)\n print(\"| '{0}' need to go ahead downloading\".format(\n certificate[:23].strip()))\n self.msg.template(78)\n print(\"\")\n self.downder_options += certificate\n if not self.msg.answer() in [\"y\", \"Y\"]:\n raise SystemExit()", "docstring": "Check for certificates options for wget" }, { "code": "def _filter_data(self, pattern):\n removed = []\n filtered = []\n for param in self.data:\n if not param[0].startswith(pattern):\n filtered.append(param)\n else:\n removed.append(param)\n self.data = filtered\n return removed", "docstring": "Removes parameters which match the pattern from the config data" }, { "code": "def context(self, name):\n data = self._context(name)\n context = data.get(\"context\")\n if context:\n return context\n assert self.load_path\n context_path = os.path.join(self.load_path, \"contexts\", \"%s.rxt\" % name)\n context = ResolvedContext.load(context_path)\n data[\"context\"] = context\n data[\"loaded\"] = True\n return context", "docstring": "Get a context.\n\n Args:\n name (str): Name to store the context under.\n\n Returns:\n `ResolvedContext` object." }, { "code": "def get_following(self, auth_secret):\n result = {pytwis_constants.ERROR_KEY: None}\n loggedin, userid = self._is_loggedin(auth_secret)\n if not loggedin:\n result[pytwis_constants.ERROR_KEY] = pytwis_constants.ERROR_NOT_LOGGED_IN\n return (False, result)\n following_zset_key = pytwis_constants.FOLLOWING_KEY_FORMAT.format(userid)\n following_userids = self._rc.zrange(following_zset_key, 0, -1)\n if following_userids is None or not following_userids:\n result[pytwis_constants.FOLLOWING_LIST_KEY] = []\n return (True, result)\n with self._rc.pipeline() as pipe:\n pipe.multi()\n for following_userid in following_userids:\n following_userid_profile_key = \\\n pytwis_constants.USER_PROFILE_KEY_FORMAT.format(following_userid)\n pipe.hget(following_userid_profile_key, pytwis_constants.USERNAME_KEY)\n result[pytwis_constants.FOLLOWING_LIST_KEY] = pipe.execute()\n return (True, result)", "docstring": "Get the following list of a logged-in user.\n\n Parameters\n ----------\n auth_secret: str\n The authentication secret of the logged-in user.\n\n Returns\n -------\n bool\n True if the following list is successfully obtained, False otherwise.\n result\n A dict containing the following list with the key FOLLOWING_LIST_KEY\n if the follower list is successfully obtained, a dict containing\n the error string with the key ERROR_KEY otherwise.\n\n Note\n ----\n Possible error strings are listed as below:\n\n - ERROR_NOT_LOGGED_IN" }, { "code": "def get_copy_folder_location():\n copy_settings_path = 'Library/Application Support/Copy Agent/config.db'\n copy_home = None\n copy_settings = os.path.join(os.environ['HOME'], copy_settings_path)\n if os.path.isfile(copy_settings):\n database = sqlite3.connect(copy_settings)\n if database:\n cur = database.cursor()\n query = (\"SELECT value \"\n \"FROM config2 \"\n \"WHERE option = 'csmRootPath';\")\n cur.execute(query)\n data = cur.fetchone()\n copy_home = str(data[0])\n cur.close()\n if not copy_home:\n error(\"Unable to find your Copy install =(\")\n return copy_home", "docstring": "Try to locate the Copy folder.\n\n Returns:\n (str) Full path to the current Copy folder" }, { "code": "def iq_handler(type_, payload_cls, *, with_send_reply=False):\n if (not hasattr(payload_cls, \"TAG\") or\n (aioxmpp.IQ.CHILD_MAP.get(payload_cls.TAG) is not\n aioxmpp.IQ.payload.xq_descriptor) or\n payload_cls not in aioxmpp.IQ.payload._classes):\n raise ValueError(\n \"{!r} is not a valid IQ payload \"\n \"(use IQ.as_payload_class decorator)\".format(\n payload_cls,\n )\n )\n def decorator(f):\n add_handler_spec(\n f,\n HandlerSpec(\n (_apply_iq_handler, (type_, payload_cls)),\n require_deps=(),\n ),\n kwargs=dict(with_send_reply=with_send_reply),\n )\n return f\n return decorator", "docstring": "Register the decorated function or coroutine function as IQ request\n handler.\n\n :param type_: IQ type to listen for\n :type type_: :class:`~.IQType`\n :param payload_cls: Payload XSO class to listen for\n :type payload_cls: :class:`~.XSO` subclass\n :param with_send_reply: Whether to pass a function to send a reply\n to the decorated callable as second argument.\n :type with_send_reply: :class:`bool`\n\n :raises ValueError: if `payload_cls` is not a registered IQ payload\n\n If the decorated function is not a coroutine function, it must return an\n awaitable instead.\n\n .. seealso::\n\n :meth:`~.StanzaStream.register_iq_request_handler` for more\n details on the `type_`, `payload_cls` and\n `with_send_reply` arguments, as well as behaviour expected\n from the decorated function.\n\n :meth:`aioxmpp.IQ.as_payload_class`\n for a way to register a XSO as IQ payload\n\n .. versionadded:: 0.11\n\n The `with_send_reply` argument.\n\n .. versionchanged:: 0.10\n\n The decorator now checks if `payload_cls` is a valid, registered IQ\n payload and raises :class:`ValueError` if not." }, { "code": "def get_splitext_basename(path):\n basename = foundations.common.get_first_item(os.path.splitext(os.path.basename(os.path.normpath(path))))\n LOGGER.debug(\"> Splitext basename: '{0}'.\".format(basename))\n return basename", "docstring": "Gets the basename of a path without its extension.\n\n Usage::\n\n >>> get_splitext_basename(\"/Users/JohnDoe/Documents/Test.txt\")\n u'Test'\n\n :param path: Path to extract the basename without extension.\n :type path: unicode\n :return: Splitext basename.\n :rtype: unicode" }, { "code": "def as_statements(lines: Iterator[str]) -> Iterator[str]:\n lines = (l.strip() for l in lines if l)\n lines = (l for l in lines if l and not l.startswith('--'))\n parts = []\n for line in lines:\n parts.append(line.rstrip(';'))\n if line.endswith(';'):\n yield ' '.join(parts)\n parts.clear()\n if parts:\n yield ' '.join(parts)", "docstring": "Create an iterator that transforms lines into sql statements.\n\n Statements within the lines must end with \";\"\n The last statement will be included even if it does not end in ';'\n\n >>> list(as_statements(['select * from', '-- comments are filtered', 't;']))\n ['select * from t']\n\n >>> list(as_statements(['a;', 'b', 'c;', 'd', ' ']))\n ['a', 'b c', 'd']" }, { "code": "def retrieve(customer_id):\n http_client = HttpClient()\n response, __ = http_client.get(routes.url(routes.CUSTOMER_RESOURCE, resource_id=customer_id))\n return resources.Customer(**response)", "docstring": "Retrieve a customer from its id.\n\n :param customer_id: The customer id\n :type customer_id: string\n\n :return: The customer resource\n :rtype: resources.Customer" }, { "code": "def read(self, size):\n raw_read = super(USBRawDevice, self).read\n received = bytearray()\n while not len(received) >= size:\n resp = raw_read(self.RECV_CHUNK)\n received.extend(resp)\n return bytes(received)", "docstring": "Read raw bytes from the instrument.\n\n :param size: amount of bytes to be sent to the instrument\n :type size: integer\n :return: received bytes\n :return type: bytes" }, { "code": "def _start_thread(self):\n self._stopping_event = Event()\n self._enqueueing_thread = Thread(target=self._enqueue_batches, args=(self._stopping_event,))\n self._enqueueing_thread.start()", "docstring": "Start an enqueueing thread." }, { "code": "def _createEmptyJobGraphForJob(self, jobStore, command=None, predecessorNumber=0):\n self._config = jobStore.config\n return jobStore.create(JobNode.fromJob(self, command=command,\n predecessorNumber=predecessorNumber))", "docstring": "Create an empty job for the job." }, { "code": "def docsfor(self, rel):\n prefix, _rel = rel.split(':')\n if prefix in self.curies:\n doc_url = uritemplate.expand(self.curies[prefix], {'rel': _rel})\n else:\n doc_url = rel\n print('opening', doc_url)\n webbrowser.open(doc_url)", "docstring": "Obtains the documentation for a link relation. Opens in a webbrowser\n window" }, { "code": "def search_suggestion(self, query):\n\t\tresponse = self._call(\n\t\t\tmc_calls.QuerySuggestion,\n\t\t\tquery\n\t\t)\n\t\tsuggested_queries = response.body.get('suggested_queries', [])\n\t\treturn [\n\t\t\tsuggested_query['suggestion_string']\n\t\t\tfor suggested_query in suggested_queries\n\t\t]", "docstring": "Get search query suggestions for query.\n\n\t\tParameters:\n\t\t\tquery (str): Search text.\n\n\t\tReturns:\n\t\t\tlist: Suggested query strings." }, { "code": "def remove(self, oid):\n uri = self._resources[oid].uri\n del self._resources[oid]\n del self._hmc.all_resources[uri]", "docstring": "Remove a faked resource from this manager.\n\n Parameters:\n\n oid (string):\n The object ID of the resource (e.g. value of the 'object-uri'\n property)." }, { "code": "def _handle_error(self, data, params):\n error = data.get('error', 'API call failed')\n mode = params.get('mode')\n raise SabnzbdApiException(error, mode=mode)", "docstring": "Handle an error response from the SABnzbd API" }, { "code": "def _setup_xauth(self):\n handle, filename = tempfile.mkstemp(prefix='PyVirtualDisplay.',\n suffix='.Xauthority')\n self._xauth_filename = filename\n os.close(handle)\n self._old_xauth = {}\n self._old_xauth['AUTHFILE'] = os.getenv('AUTHFILE')\n self._old_xauth['XAUTHORITY'] = os.getenv('XAUTHORITY')\n os.environ['AUTHFILE'] = os.environ['XAUTHORITY'] = filename\n cookie = xauth.generate_mcookie()\n xauth.call('add', self.new_display_var, '.', cookie)", "docstring": "Set up the Xauthority file and the XAUTHORITY environment variable." }, { "code": "def get_qemu_info(path, backing_chain=False, fail_on_error=True):\n cmd = ['qemu-img', 'info', '--output=json', path]\n if backing_chain:\n cmd.insert(-1, '--backing-chain')\n result = run_command_with_validation(\n cmd, fail_on_error, msg='Failed to get info for {}'.format(path)\n )\n return json.loads(result.out)", "docstring": "Get info on a given qemu disk\n\n Args:\n path(str): Path to the required disk\n backing_chain(boo): if true, include also info about\n the image predecessors.\n Return:\n object: if backing_chain == True then a list of dicts else a dict" }, { "code": "def copy(self):\n if self._global_condition is not None:\n raise SimStateError(\"global condition was not cleared before state.copy().\")\n c_plugins = self._copy_plugins()\n state = SimState(project=self.project, arch=self.arch, plugins=c_plugins, options=self.options.copy(),\n mode=self.mode, os_name=self.os_name)\n if self._is_java_jni_project:\n state.ip_is_soot_addr = self.ip_is_soot_addr\n state.uninitialized_access_handler = self.uninitialized_access_handler\n state._special_memory_filler = self._special_memory_filler\n state.ip_constraints = self.ip_constraints\n return state", "docstring": "Returns a copy of the state." }, { "code": "def _match_exists(self, searchable):\n position_searchable = self.get_position_searchable()\n for pos,val in position_searchable.iteritems():\n if val == searchable:\n return pos\n return False", "docstring": "Make sure the searchable description doesn't already exist" }, { "code": "def extract_objects(self, fname, type_filter=None):\n objects = []\n if fname in self.object_cache:\n objects = self.object_cache[fname]\n else:\n with io.open(fname, 'rt', encoding='utf-8') as fh:\n text = fh.read()\n objects = parse_verilog(text)\n self.object_cache[fname] = objects\n if type_filter:\n objects = [o for o in objects if isinstance(o, type_filter)]\n return objects", "docstring": "Extract objects from a source file\n\n Args:\n fname(str): Name of file to read from\n type_filter (class, optional): Object class to filter results\n Returns:\n List of objects extracted from the file." }, { "code": "def get_synth_input_fn(height, width, num_channels, num_classes):\n def input_fn(is_training, data_dir, batch_size, *args, **kwargs):\n images = tf.zeros((batch_size, height, width, num_channels), tf.float32)\n labels = tf.zeros((batch_size, num_classes), tf.int32)\n return tf.data.Dataset.from_tensors((images, labels)).repeat()\n return input_fn", "docstring": "Returns an input function that returns a dataset with zeroes.\n\n This is useful in debugging input pipeline performance, as it removes all\n elements of file reading and image preprocessing.\n\n Args:\n height: Integer height that will be used to create a fake image tensor.\n width: Integer width that will be used to create a fake image tensor.\n num_channels: Integer depth that will be used to create a fake image tensor.\n num_classes: Number of classes that should be represented in the fake labels\n tensor\n\n Returns:\n An input_fn that can be used in place of a real one to return a dataset\n that can be used for iteration." }, { "code": "def bootstrap(score_objs, n_boot=1000):\n all_samples = np.random.choice(score_objs, size=(n_boot, len(score_objs)), replace=True)\n return all_samples.sum(axis=1)", "docstring": "Given a set of DistributedROC or DistributedReliability objects, this function performs a\n bootstrap resampling of the objects and returns n_boot aggregations of them.\n\n Args:\n score_objs: A list of DistributedROC or DistributedReliability objects. Objects must have an __add__ method\n n_boot (int): Number of bootstrap samples\n\n Returns:\n An array of DistributedROC or DistributedReliability" }, { "code": "def _get_calling_module(self):\n for frame in inspect.stack():\n mod = inspect.getmodule(frame[0])\n logger.debug(f'calling module: {mod}')\n if mod is not None:\n mod_name = mod.__name__\n if mod_name != __name__:\n return mod", "docstring": "Get the last module in the call stack that is not this module or ``None`` if\n the call originated from this module." }, { "code": "def lookup(self, req, parent, name):\n self.reply_err(req, errno.ENOENT)", "docstring": "Look up a directory entry by name and get its attributes.\n\n Valid replies:\n reply_entry\n reply_err" }, { "code": "def get_comment_create_data(self):\n user_model = get_user_model()\n return dict(\n content_type=ContentType.objects.get_for_model(self.target_object),\n object_pk=force_text(self.target_object._get_pk_val()),\n text=self.cleaned_data[\"text\"],\n user=user_model.objects.latest('id'),\n post_date=timezone.now(),\n site_id=settings.SITE_ID,\n is_public=True,\n is_removed=False,\n )", "docstring": "Returns the dict of data to be used to create a comment. Subclasses in\n custom comment apps that override get_comment_model can override this\n method to add extra fields onto a custom comment model." }, { "code": "def _process_state_change_events():\n sdp_state = SDPState()\n service_states = get_service_state_list()\n state_events = sdp_state.get_event_queue(subscriber=__service_name__)\n state_is_off = sdp_state.current_state == 'off'\n counter = 0\n while True:\n time.sleep(0.1)\n if not state_is_off:\n if counter % 1000 == 0:\n LOG.debug('Checking published events ... %d', counter / 1000)\n _published_events = state_events.get_published_events(\n process=True)\n for _state_event in _published_events:\n _process_event(_state_event, sdp_state, service_states)\n else:\n _state_event = state_events.get()\n if _state_event:\n _process_event(_state_event, sdp_state, service_states)\n state_is_off = sdp_state.current_state == 'off'\n counter += 1", "docstring": "Process events relating to the overall state of SDP.\n\n This function starts and event loop which continually checks for\n and responds to SDP state change events." }, { "code": "def get_object(self, identifier, include_inactive=False):\n query = {'_id': identifier}\n if not include_inactive:\n query['active'] = True\n cursor = self.collection.find(query)\n if cursor.count() > 0:\n return self.from_dict(cursor.next())\n else:\n return None", "docstring": "Retrieve object with given identifier from the database.\n\n Parameters\n ----------\n identifier : string\n Unique object identifier\n include_inactive : Boolean\n Flag indicating whether inactive (i.e., deleted) object should be\n included in the search (i.e., return an object with given\n identifier if it has been deleted or return None)\n\n Returns\n -------\n (Sub-class of)ObjectHandle\n The database object with given identifier or None if no object\n with identifier exists." }, { "code": "def require(self, lock, guard_func, *guard_args, **guard_kw):\n def decorator(f):\n @wraps(f)\n def wrapper(*args, **kw):\n if self.granted(lock):\n self.msg('Granted {}'.format(lock))\n return f(*args, **kw)\n if guard_func(*guard_args, **guard_kw) and self.acquire(lock):\n return f(*args, **kw)\n return None\n return wrapper\n return decorator", "docstring": "Decorate a function to be run only when a lock is acquired.\n\n The lock is requested if the guard function returns True.\n\n The decorated function is called if the lock has been granted." }, { "code": "def get_resourcegroupitems(group_id, scenario_id, **kwargs):\n rgi_qry = db.DBSession.query(ResourceGroupItem).\\\n filter(ResourceGroupItem.scenario_id==scenario_id)\n if group_id is not None:\n rgi_qry = rgi_qry.filter(ResourceGroupItem.group_id==group_id)\n rgi = rgi_qry.all()\n return rgi", "docstring": "Get all the items in a group, in a scenario. If group_id is None, return\n all items across all groups in the scenario." }, { "code": "def publish_topology_opened(self, topology_id):\n event = TopologyOpenedEvent(topology_id)\n for subscriber in self.__topology_listeners:\n try:\n subscriber.opened(event)\n except Exception:\n _handle_exception()", "docstring": "Publish a TopologyOpenedEvent to all topology listeners.\n\n :Parameters:\n - `topology_id`: A unique identifier for the topology this server\n is a part of." }, { "code": "def uncompress_file(inputfile, filename):\n zipfile = gzip.GzipFile(fileobj=inputfile, mode=\"rb\")\n try:\n outputfile = create_spooled_temporary_file(fileobj=zipfile)\n finally:\n zipfile.close()\n new_basename = os.path.basename(filename).replace('.gz', '')\n return outputfile, new_basename", "docstring": "Uncompress this file using gzip and change its name.\n\n :param inputfile: File to compress\n :type inputfile: ``file`` like object\n\n :param filename: File's name\n :type filename: ``str``\n\n :returns: Tuple with file and new file's name\n :rtype: :class:`tempfile.SpooledTemporaryFile`, ``str``" }, { "code": "def load_api_folder(api_folder_path):\n api_definition_mapping = {}\n api_items_mapping = load_folder_content(api_folder_path)\n for api_file_path, api_items in api_items_mapping.items():\n if isinstance(api_items, list):\n for api_item in api_items:\n key, api_dict = api_item.popitem()\n api_id = api_dict.get(\"id\") or api_dict.get(\"def\") or api_dict.get(\"name\")\n if key != \"api\" or not api_id:\n raise exceptions.ParamsError(\n \"Invalid API defined in {}\".format(api_file_path))\n if api_id in api_definition_mapping:\n raise exceptions.ParamsError(\n \"Duplicated API ({}) defined in {}\".format(api_id, api_file_path))\n else:\n api_definition_mapping[api_id] = api_dict\n elif isinstance(api_items, dict):\n if api_file_path in api_definition_mapping:\n raise exceptions.ParamsError(\n \"Duplicated API defined: {}\".format(api_file_path))\n else:\n api_definition_mapping[api_file_path] = api_items\n return api_definition_mapping", "docstring": "load api definitions from api folder.\n\n Args:\n api_folder_path (str): api files folder.\n\n api file should be in the following format:\n [\n {\n \"api\": {\n \"def\": \"api_login\",\n \"request\": {},\n \"validate\": []\n }\n },\n {\n \"api\": {\n \"def\": \"api_logout\",\n \"request\": {},\n \"validate\": []\n }\n }\n ]\n\n Returns:\n dict: api definition mapping.\n\n {\n \"api_login\": {\n \"function_meta\": {\"func_name\": \"api_login\", \"args\": [], \"kwargs\": {}}\n \"request\": {}\n },\n \"api_logout\": {\n \"function_meta\": {\"func_name\": \"api_logout\", \"args\": [], \"kwargs\": {}}\n \"request\": {}\n }\n }" }, { "code": "def to_html(self, codebase):\n body = ''\n for section in ('params', 'options', 'exceptions'):\n val = getattr(self, section)\n if val:\n body += '
%s
\\n
%s
' % (\n printable(section), section, \n '\\n'.join(param.to_html() for param in val))\n body += codebase.build_see_html(self.see, 'h5', self)\n return ('\\n
\\n' + \n '

%s

\\n%s\\n%s\\n
\\n') % (self.name, self.name, \n htmlize_paragraphs(codebase.translate_links(self.doc, self)), body)", "docstring": "Convert this `FunctionDoc` to HTML." }, { "code": "def get_relations_cnt(self):\n return cx.Counter([e.relation for es in self.exts for e in es])", "docstring": "Get the set of all relations." }, { "code": "def timdef(action, item, lenout, value=None):\n action = stypes.stringToCharP(action)\n item = stypes.stringToCharP(item)\n lenout = ctypes.c_int(lenout)\n if value is None:\n value = stypes.stringToCharP(lenout)\n else:\n value = stypes.stringToCharP(value)\n libspice.timdef_c(action, item, lenout, value)\n return stypes.toPythonString(value)", "docstring": "Set and retrieve the defaults associated with calendar input strings.\n\n http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/timdef_c.html\n\n :param action: the kind of action to take \"SET\" or \"GET\".\n :type action: str\n :param item: the default item of interest.\n :type item: str\n :param lenout: the length of list for output.\n :type lenout: int\n :param value: the optional string used if action is \"SET\"\n :type value: str\n :return: the value associated with the default item.\n :rtype: str" }, { "code": "def is_obsoleted_by_pid(pid):\n return d1_gmn.app.models.ScienceObject.objects.filter(\n obsoleted_by__did=pid\n ).exists()", "docstring": "Return True if ``pid`` is referenced in the obsoletedBy field of any object.\n\n This will return True even if the PID is in the obsoletes field of an object that\n does not exist on the local MN, such as replica that is in an incomplete chain." }, { "code": "def remove_prefix(self, prefix):\n self._req('prefix remove %s' % prefix)\n time.sleep(1)\n self._req('netdataregister')", "docstring": "Remove network prefix." }, { "code": "def register_computer_view(request):\n if request.method == \"POST\":\n form = ComputerRegistrationForm(request.POST)\n logger.debug(form)\n if form.is_valid():\n obj = form.save()\n obj.user = request.user\n obj.save()\n messages.success(request, \"Successfully added computer.\")\n return redirect(\"itemreg\")\n else:\n messages.error(request, \"Error adding computer.\")\n else:\n form = ComputerRegistrationForm()\n return render(request, \"itemreg/register_form.html\", {\"form\": form, \"action\": \"add\", \"type\": \"computer\", \"form_route\": \"itemreg_computer\"})", "docstring": "Register a computer." }, { "code": "def random_possible_hands(self):\n missing = self.missing_values()\n other_dominoes = [d for p, h in enumerate(self.hands) for d in h if p != self.turn]\n while True:\n shuffled_dominoes = (d for d in random.sample(other_dominoes, len(other_dominoes)))\n hands = []\n for player, hand in enumerate(self.hands):\n if player != self.turn:\n hand = [next(shuffled_dominoes) for _ in hand]\n hands.append(dominoes.Hand(hand))\n if _validate_hands(hands, missing):\n return hands", "docstring": "Returns random possible hands for all players, given the information\n known by the player whose turn it is. This information includes the\n current player's hand, the sizes of the other players' hands, and the\n moves played by every player, including the passes.\n\n :return: a list of possible Hand objects, corresponding to each player" }, { "code": "def number_of_interactions(self, u=None, v=None, t=None):\n if t is None:\n if u is None:\n return int(self.size())\n elif u is not None and v is not None:\n if v in self._succ[u]:\n return 1\n else:\n return 0\n else:\n if u is None:\n return int(self.size(t))\n elif u is not None and v is not None:\n if v in self._succ[u]:\n if self.__presence_test(u, v, t):\n return 1\n else:\n return 0", "docstring": "Return the number of interaction between two nodes at time t.\n\n Parameters\n ----------\n u, v : nodes, optional (default=all interaction)\n If u and v are specified, return the number of interaction between\n u and v. Otherwise return the total number of all interaction.\n t : snapshot id (default=None)\n If None will be returned the number of edges on the flattened graph.\n\n Returns\n -------\n nedges : int\n The number of interaction in the graph. If nodes u and v are specified\n return the number of interaction between those nodes. If a single node is specified return None.\n\n See Also\n --------\n size\n\n Examples\n --------\n >>> G = dn.DynDiGraph()\n >>> G.add_path([0,1,2,3], t=0)\n >>> G.number_of_interactions()\n 3\n >>> G.number_of_interactions(0,1, t=0)\n 1\n >>> G.add_edge(3, 4, t=1)\n >>> G.number_of_interactions()\n 4" }, { "code": "def prepend_status(func):\n @ft.wraps(func)\n def wrapper(self, *args, **kwargs):\n res = func(self, *args, **kwargs)\n if self.status is not StepResult.UNSET:\n res = \"[{status}]\".format(status=self.status.name) + res\n return res\n return wrapper", "docstring": "Prepends the output of `func` with the status." }, { "code": "def get_nodes():\n cfg_file = \"/etc/nago/nago.ini\"\n config = ConfigParser.ConfigParser()\n config.read(cfg_file)\n result = {}\n for section in config.sections():\n if section in ['main']:\n continue\n token = section\n node = Node(token)\n for key, value in config.items(token):\n node[key] = value\n result[token] = node\n return result", "docstring": "Returns all nodes in a list of dicts format" }, { "code": "def get_time_remaining_estimate(self):\n if IOPSGetTimeRemainingEstimate is not None:\n estimate = float(IOPSGetTimeRemainingEstimate())\n if estimate == -1.0:\n return common.TIME_REMAINING_UNKNOWN\n elif estimate == -2.0:\n return common.TIME_REMAINING_UNLIMITED\n else:\n return estimate / 60.0\n else:\n warnings.warn(\"IOPSGetTimeRemainingEstimate is not preset\", RuntimeWarning)\n blob = IOPSCopyPowerSourcesInfo()\n type = IOPSGetProvidingPowerSourceType(blob)\n if type == common.POWER_TYPE_AC:\n return common.TIME_REMAINING_UNLIMITED\n else:\n estimate = 0.0\n for source in IOPSCopyPowerSourcesList(blob):\n description = IOPSGetPowerSourceDescription(blob, source)\n if kIOPSIsPresentKey in description and description[kIOPSIsPresentKey] and kIOPSTimeToEmptyKey in description and description[kIOPSTimeToEmptyKey] > 0.0:\n estimate += float(description[kIOPSTimeToEmptyKey])\n if estimate > 0.0:\n return float(estimate)\n else:\n return common.TIME_REMAINING_UNKNOWN", "docstring": "In Mac OS X 10.7+\n Uses IOPSGetTimeRemainingEstimate to get time remaining estimate.\n\n In Mac OS X 10.6\n IOPSGetTimeRemainingEstimate is not available.\n If providing power source type is AC, returns TIME_REMAINING_UNLIMITED.\n Otherwise looks through all power sources returned by IOPSGetProvidingPowerSourceType\n and returns total estimate." }, { "code": "def get_buffer( self ):\n last_byte = self.current_bits if (self.bits_remaining < 8) else None\n result = self.output\n if last_byte is not None:\n result = bytearray( result )\n result.append( last_byte )\n if self.bytes_reverse:\n return bytes( reversed( result ) )\n else:\n return bytes( result )", "docstring": "Return a byte string containing the target as currently written." }, { "code": "def _init_count_terms(self, annots):\n gonotindag = set()\n gocnts = self.gocnts\n go2obj = self.go2obj\n for terms in annots.values():\n allterms = set()\n for go_id in terms:\n goobj = go2obj.get(go_id, None)\n if goobj is not None:\n allterms.add(go_id)\n allterms |= goobj.get_all_parents()\n else:\n gonotindag.add(go_id)\n for parent in allterms:\n gocnts[parent] += 1\n if gonotindag:\n print(\"{N} Assc. GO IDs not found in the GODag\\n\".format(N=len(gonotindag)))", "docstring": "Fills in the counts and overall aspect counts." }, { "code": "def set(self, name, value=True):\n \"set a feature value\"\n setattr(self, name.lower(), value)", "docstring": "set a feature value" }, { "code": "def posargs_limiter(func, *args):\n posargs = inspect.getargspec(func)[0]\n length = len(posargs)\n if inspect.ismethod(func):\n length -= 1\n if length == 0:\n return func()\n return func(*args[0:length])", "docstring": "takes a function a positional arguments and sends only the number of\n positional arguments the function is expecting" }, { "code": "def ssh_known_hosts_lines(application_name, user=None):\n known_hosts_list = []\n with open(known_hosts(application_name, user)) as hosts:\n for hosts_line in hosts:\n if hosts_line.rstrip():\n known_hosts_list.append(hosts_line.rstrip())\n return(known_hosts_list)", "docstring": "Return contents of known_hosts file for given application.\n\n :param application_name: Name of application eg nova-compute-something\n :type application_name: str\n :param user: The user that the ssh asserts are for.\n :type user: str" }, { "code": "def multi_split(text, regexes):\n def make_regex(s):\n return re.compile(s) if isinstance(s, basestring) else s\n regexes = [make_regex(r) for r in regexes]\n piece_list = [text]\n finished_pieces = set()\n def apply_re(regex, piece_list):\n for piece in piece_list:\n if piece in finished_pieces:\n yield piece\n continue\n for s in full_split(piece, regex):\n if regex.match(s):\n finished_pieces.add(s)\n if s:\n yield s\n for regex in regexes:\n piece_list = list(apply_re(regex, piece_list))\n assert ''.join(piece_list) == text\n return piece_list", "docstring": "Split the text by the given regexes, in priority order.\n\n Make sure that the regex is parenthesized so that matches are returned in\n re.split().\n\n Splitting on a single regex works like normal split.\n >>> '|'.join(multi_split('one two three', [r'\\w+']))\n 'one| |two| |three'\n\n Splitting on digits first separates the digits from their word\n >>> '|'.join(multi_split('one234five 678', [r'\\d+', r'\\w+']))\n 'one|234|five| |678'\n\n Splitting on words first keeps the word with digits intact.\n >>> '|'.join(multi_split('one234five 678', [r'\\w+', r'\\d+']))\n 'one234five| |678'" }, { "code": "def normalize(path_name, override=None):\n identity = identify(path_name, override=override)\n new_path_name = os.path.normpath(os.path.expanduser(path_name))\n return new_path_name, identity", "docstring": "Prepares a path name to be worked with. Path name must not be empty. This\n function will return the 'normpath'ed path and the identity of the path.\n This function takes an optional overriding argument for the identity.\n\n ONLY PROVIDE OVERRIDE IF:\n 1) YOU AREWORKING WITH A FOLDER THAT HAS AN EXTENSION IN THE NAME\n 2) YOU ARE MAKING A FILE WITH NO EXTENSION" }, { "code": "def insert(self, resourcetype, source, insert_date=None):\n caller = inspect.stack()[1][3]\n if caller == 'transaction':\n hhclass = 'Layer'\n source = resourcetype\n resourcetype = resourcetype.csw_schema\n else:\n hhclass = 'Service'\n if resourcetype not in HYPERMAP_SERVICE_TYPES.keys():\n raise RuntimeError('Unsupported Service Type')\n return self._insert_or_update(resourcetype, source, mode='insert', hhclass=hhclass)", "docstring": "Insert a record into the repository" }, { "code": "def fetch(self):\n if self.data.type == self._manager.FOLDER_TYPE:\n raise YagocdException(\"Can't fetch folder <{}>, only file!\".format(self._path))\n response = self._session.get(self.data.url)\n return response.content", "docstring": "Method for getting artifact's content.\n Could only be applicable for file type.\n\n :return: content of the artifact." }, { "code": "def get_table(ports):\n table = PrettyTable([\"Name\", \"Port\", \"Protocol\", \"Description\"])\n table.align[\"Name\"] = \"l\"\n table.align[\"Description\"] = \"l\"\n table.padding_width = 1\n for port in ports:\n table.add_row(port)\n return table", "docstring": "This function returns a pretty table used to display the port results.\n\n :param ports: list of found ports\n :return: the table to display" }, { "code": "def login():\n cas_token_session_key = current_app.config['CAS_TOKEN_SESSION_KEY']\n redirect_url = create_cas_login_url(\n current_app.config['CAS_SERVER'],\n current_app.config['CAS_LOGIN_ROUTE'],\n flask.url_for('.login', origin=flask.session.get('CAS_AFTER_LOGIN_SESSION_URL'), _external=True))\n if 'ticket' in flask.request.args:\n flask.session[cas_token_session_key] = flask.request.args['ticket']\n if cas_token_session_key in flask.session:\n if validate(flask.session[cas_token_session_key]):\n if 'CAS_AFTER_LOGIN_SESSION_URL' in flask.session:\n redirect_url = flask.session.pop('CAS_AFTER_LOGIN_SESSION_URL')\n elif flask.request.args.get('origin'):\n redirect_url = flask.request.args['origin']\n else:\n redirect_url = flask.url_for(\n current_app.config['CAS_AFTER_LOGIN'])\n else:\n del flask.session[cas_token_session_key]\n current_app.logger.debug('Redirecting to: {0}'.format(redirect_url))\n return flask.redirect(redirect_url)", "docstring": "This route has two purposes. First, it is used by the user\n to login. Second, it is used by the CAS to respond with the\n `ticket` after the user logs in successfully.\n\n When the user accesses this url, they are redirected to the CAS\n to login. If the login was successful, the CAS will respond to this\n route with the ticket in the url. The ticket is then validated.\n If validation was successful the logged in username is saved in\n the user's session under the key `CAS_USERNAME_SESSION_KEY` and\n the user's attributes are saved under the key\n 'CAS_USERNAME_ATTRIBUTE_KEY'" }, { "code": "def change_default_radii(def_map):\n s = current_system()\n rep = current_representation()\n rep.radii_state.default = [def_map[t] for t in s.type_array]\n rep.radii_state.reset()", "docstring": "Change the default radii" }, { "code": "def create_sqs_policy(self, topic_name, topic_arn, topic_subs):\n t = self.template\n arn_endpoints = []\n url_endpoints = []\n for sub in topic_subs:\n arn_endpoints.append(sub[\"Endpoint\"])\n split_endpoint = sub[\"Endpoint\"].split(\":\")\n queue_url = \"https://%s.%s.amazonaws.com/%s/%s\" % (\n split_endpoint[2],\n split_endpoint[3],\n split_endpoint[4],\n split_endpoint[5],\n )\n url_endpoints.append(queue_url)\n policy_doc = queue_policy(topic_arn, arn_endpoints)\n t.add_resource(\n sqs.QueuePolicy(\n topic_name + \"SubPolicy\",\n PolicyDocument=policy_doc,\n Queues=url_endpoints,\n )\n )", "docstring": "This method creates the SQS policy needed for an SNS subscription. It\n also takes the ARN of the SQS queue and converts it to the URL needed\n for the subscription, as that takes a URL rather than the ARN." }, { "code": "def get_object(self, request):\n pattern = request.GET.get('pattern', '')\n if len(pattern) < 3:\n raise ObjectDoesNotExist\n return pattern", "docstring": "The GET parameter 'pattern' is the object." }, { "code": "def body(self):\n self.connection = pika.BlockingConnection(self.connection_param)\n self.channel = self.connection.channel()\n print \"Monitoring file '%s'.\" % self.ftp_extended_log\n file_iter = process_log(\n sh.tail(\"-f\", self.ftp_extended_log, _iter=True)\n )\n for import_request in file_iter:\n self.sendMessage(\n exchange=self.output_exchange,\n routing_key=self.output_key,\n message=serializers.serialize(import_request),\n UUID=str(uuid.uuid1())\n )", "docstring": "This method handles AMQP connection details and reacts to FTP events by\n sending messages to output queue." }, { "code": "def get_function_name(s):\n s = s.strip()\n if s.startswith(\"__attribute__\"):\n if \"))\" not in s:\n raise ValueError(\"__attribute__ is present, but I cannot find double-right parenthesis in the function \"\n \"declaration string.\")\n s = s[s.index(\"))\") + 2 : ].strip()\n if '(' not in s:\n raise ValueError(\"Cannot find any left parenthesis in the function declaration string.\")\n func_name = s[:s.index('(')].strip()\n for i, ch in enumerate(reversed(func_name)):\n if ch == ' ':\n pos = len(func_name) - 1 - i\n break\n else:\n raise ValueError('Cannot find any space in the function declaration string.')\n func_name = func_name[pos + 1 : ]\n return func_name", "docstring": "Get the function name from a C-style function declaration string.\n\n :param str s: A C-style function declaration string.\n :return: The function name.\n :rtype: str" }, { "code": "def get_settings(config_uri, section=None, defaults=None):\n loader = get_loader(config_uri)\n return loader.get_settings(section, defaults)", "docstring": "Load the settings from a named section.\n\n .. code-block:: python\n\n settings = plaster.get_settings(...)\n print(settings['foo'])\n\n :param config_uri: Anything that can be parsed by\n :func:`plaster.parse_uri`.\n\n :param section: The name of the section in the config file. If this is\n ``None`` then it is up to the loader to determine a sensible default\n usually derived from the fragment in the ``path#name`` syntax of the\n ``config_uri``.\n\n :param defaults: A ``dict`` of default values used to populate the\n settings and support variable interpolation. Any values in ``defaults``\n may be overridden by the loader prior to returning the final\n configuration dictionary.\n\n :returns: A ``dict`` of settings. This should return a dictionary object\n even if no data is available." }, { "code": "def _ensure_ifaces_tuple(ifaces):\n try:\n ifaces = tuple(ifaces)\n except TypeError:\n ifaces = (ifaces,)\n for iface in ifaces:\n if not _issubclass(iface, ibc.Iface):\n raise TypeError('Can only compare against interfaces.')\n return ifaces", "docstring": "Convert to a tuple of interfaces and raise if not interfaces." }, { "code": "def return_dict(self):\n output_dict = {}\n output_dict['general'] = self._iterate_through_class(self.general.__dict__)\n output_dict['figure'] = self._iterate_through_class(self.figure.__dict__)\n if self.total_plots > 1:\n trans_dict = ({\n str(i): self._iterate_through_class(axis.__dict__) for i, axis\n in enumerate(self.ax)})\n output_dict['plot_info'] = trans_dict\n else:\n output_dict['plot_info'] = {'0': self._iterate_through_class(self.ax.__dict__)}\n if self.print_input:\n print(output_dict)\n return output_dict", "docstring": "Output dictionary for ``make_plot.py`` input.\n\n Iterates through the entire MainContainer class turning its contents\n into dictionary form. This dictionary becomes the input for ``make_plot.py``.\n\n If `print_input` attribute is True, the entire dictionary will be printed\n prior to returning the dicitonary.\n\n Returns:\n - **output_dict** (*dict*): Dicitonary for input into ``make_plot.py``." }, { "code": "def write(self):\n string = ''.join(self.content)\n lines = string.splitlines(True)\n if len(lines) == 0:\n return\n texts = [self.first_prefix + lines[0]]\n for line in lines[1:]:\n if line.strip() == '':\n texts.append('\\n')\n else:\n texts.append(self.prefix + line)\n self.base.append(''.join(texts))", "docstring": "Add ``self.contents`` with current ``prefix`` and ``first_prefix``\n\n Add processed ``self.contents`` to ``self.base``. The first line has\n ``first_prefix`` prepended, further lines have ``prefix`` prepended.\n\n Empty (all whitespace) lines get written as bare carriage returns, to\n avoid ugly extra whitespace." }, { "code": "def emptyTag(self, namespace, name, attrs, hasChildren=False):\n yield {\"type\": \"EmptyTag\", \"name\": name,\n \"namespace\": namespace,\n \"data\": attrs}\n if hasChildren:\n yield self.error(\"Void element has children\")", "docstring": "Generates an EmptyTag token\n\n :arg namespace: the namespace of the token--can be ``None``\n\n :arg name: the name of the element\n\n :arg attrs: the attributes of the element as a dict\n\n :arg hasChildren: whether or not to yield a SerializationError because\n this tag shouldn't have children\n\n :returns: EmptyTag token" }, { "code": "def save_profile(self, **params):\n image = self.get_image()\n if (image is None):\n return\n profile = image.get('profile', None)\n if profile is None:\n profile = Settings.SettingGroup()\n image.set(profile=profile)\n self.logger.debug(\"saving to image profile: params=%s\" % (\n str(params)))\n profile.set(**params)\n return profile", "docstring": "Save the given parameters into profile settings.\n\n Parameters\n ----------\n params : dict\n Keywords and values to be saved." }, { "code": "def create_standalone_context(require=None, **settings) -> 'Context':\n backend = os.environ.get('MODERNGL_BACKEND')\n if backend is not None:\n settings['backend'] = backend\n ctx = Context.__new__(Context)\n ctx.mglo, ctx.version_code = mgl.create_standalone_context(settings)\n ctx._screen = None\n ctx.fbo = None\n ctx._info = None\n ctx.extra = None\n if require is not None and ctx.version_code < require:\n raise ValueError('Requested OpenGL version {}, got version {}'.format(\n require, ctx.version_code))\n return ctx", "docstring": "Create a standalone ModernGL context.\n\n Example::\n\n # Create a context with highest possible supported version\n ctx = moderngl.create_context()\n\n # Require at least OpenGL 4.3\n ctx = moderngl.create_context(require=430)\n\n Keyword Arguments:\n require (int): OpenGL version code.\n\n Returns:\n :py:class:`Context` object" }, { "code": "def allow_relation(self, obj1, obj2, **hints):\n if obj1._meta.app_label != 'oldimporter' and obj2._meta.app_label != 'oldimporter':\n return True\n return None", "docstring": "Relations between objects are allowed between nodeshot2 objects only" }, { "code": "def delete(self):\n if 'delete' in self._URL:\n extra = {'resource': self.__class__.__name__, 'query': {\n 'id': self.id}}\n logger.info(\"Deleting {} resource.\".format(self), extra=extra)\n self._api.delete(url=self._URL['delete'].format(id=self.id))\n else:\n raise SbgError('Resource can not be deleted!')", "docstring": "Deletes the resource on the server." }, { "code": "def to_str(self):\n dflt = super(DataportenAccount, self).to_str()\n return '%s (%s)' % (\n self.account.extra_data.get('name', ''),\n dflt,\n )", "docstring": "Returns string representation of a social account. Includes the name\n of the user." }, { "code": "def update(backend=None):\n fileserver = salt.fileserver.Fileserver(__opts__)\n fileserver.update(back=backend)\n return True", "docstring": "Update the fileserver cache. If no backend is provided, then the cache for\n all configured backends will be updated.\n\n backend\n Narrow fileserver backends to a subset of the enabled ones.\n\n .. versionchanged:: 2015.5.0\n If all passed backends start with a minus sign (``-``), then these\n backends will be excluded from the enabled backends. However, if\n there is a mix of backends with and without a minus sign (ex:\n ``backend=-roots,git``) then the ones starting with a minus\n sign will be disregarded.\n\n Additionally, fileserver backends can now be passed as a\n comma-separated list. In earlier versions, they needed to be passed\n as a python list (ex: ``backend=\"['roots', 'git']\"``)\n\n CLI Example:\n\n .. code-block:: bash\n\n salt-run fileserver.update\n salt-run fileserver.update backend=roots,git" }, { "code": "def GE(classical_reg1, classical_reg2, classical_reg3):\n classical_reg1, classical_reg2, classical_reg3 = prepare_ternary_operands(classical_reg1,\n classical_reg2,\n classical_reg3)\n return ClassicalGreaterEqual(classical_reg1, classical_reg2, classical_reg3)", "docstring": "Produce an GE instruction.\n\n :param classical_reg1: Memory address to which to store the comparison result.\n :param classical_reg2: Left comparison operand.\n :param classical_reg3: Right comparison operand.\n :return: A ClassicalGreaterEqual instance." }, { "code": "def get(path_or_file, default=SENTINAL, mime=None, name=None, backend=None,\n encoding=None, encoding_errors=None, kwargs=None,\n _wtitle=False):\n try:\n text, title = _get(\n path_or_file, default=default, mime=mime, name=name,\n backend=backend, kwargs=kwargs, encoding=encoding,\n encoding_errors=encoding_errors, _wtitle=_wtitle)\n if _wtitle:\n return (text, title)\n else:\n return text\n except Exception as e:\n if default is not SENTINAL:\n LOGGER.exception(e)\n return default\n raise", "docstring": "Get document full text.\n\n Accepts a path or file-like object.\n * If given, `default` is returned instead of an error.\n * `backend` is either a module object or a string specifying which\n default backend to use (e.g. \"doc\"); take a look at backends\n directory to see a list of default backends.\n * `mime` and `name` should be passed if the information\n is available to caller, otherwise a best guess is made.\n If both are specified `mime` takes precedence.\n * `encoding` and `encoding_errors` are used to handle text encoding.\n They are taken into consideration mostly only by pure-python\n backends which do not rely on CLI tools.\n Default to \"utf8\" and \"strict\" respectively.\n * `kwargs` are passed to the underlying backend." }, { "code": "def profile_url(obj, profile_app_name, profile_model_name):\n try:\n content_type = ContentType.objects.get(\n app_label=profile_app_name,\n model=profile_model_name.lower()\n )\n profile = content_type.get_object_for_this_type(user=obj.user)\n return profile.get_absolute_url()\n except ContentType.DoesNotExist:\n return \"\"\n except AttributeError:\n return \"\"", "docstring": "returns profile url of user" }, { "code": "def update_bindings(self):\n with self._lock:\n all_valid = True\n for handler in self.get_handlers(handlers_const.KIND_DEPENDENCY):\n self.__safe_handler_callback(handler, \"try_binding\")\n all_valid &= self.__safe_handler_callback(\n handler, \"is_valid\", only_boolean=True, none_as_true=True\n )\n return all_valid", "docstring": "Updates the bindings of the given component\n\n :return: True if the component can be validated" }, { "code": "def split_classes(X, y):\n lstsclass = np.unique(y)\n return [X[y == i, :].astype(np.float32) for i in lstsclass]", "docstring": "split samples in X by classes in y" }, { "code": "def trace(function, *args, **k) :\n\tif doTrace : print (\"> \"+function.__name__, args, k)\n\tresult = function(*args, **k)\n\tif doTrace : print (\"< \"+function.__name__, args, k, \"->\", result)\n\treturn result", "docstring": "Decorates a function by tracing the begining and\n\tend of the function execution, if doTrace global is True" }, { "code": "def import_authors(self, tree):\n self.write_out(self.style.STEP('- Importing authors\\n'))\n post_authors = set()\n for item in tree.findall('channel/item'):\n post_type = item.find('{%s}post_type' % WP_NS).text\n if post_type == 'post':\n post_authors.add(item.find(\n '{http://purl.org/dc/elements/1.1/}creator').text)\n self.write_out('> %i authors found.\\n' % len(post_authors))\n authors = {}\n for post_author in post_authors:\n if self.default_author:\n authors[post_author] = self.default_author\n else:\n authors[post_author] = self.migrate_author(\n post_author.replace(' ', '-'))\n return authors", "docstring": "Retrieve all the authors used in posts\n and convert it to new or existing author and\n return the conversion." }, { "code": "def is_BF_hypergraph(self):\n for hyperedge_id in self._hyperedge_attributes:\n tail = self.get_hyperedge_tail(hyperedge_id)\n head = self.get_hyperedge_head(hyperedge_id)\n if len(tail) > 1 and len(head) > 1:\n return False\n return True", "docstring": "Indicates whether the hypergraph is a BF-hypergraph.\n A BF-hypergraph consists of only B-hyperedges and F-hyperedges.\n See \"is_B_hypergraph\" or \"is_F_hypergraph\" for more details.\n\n :returns: bool -- True iff the hypergraph is an F-hypergraph." }, { "code": "def _run_post_configure_callbacks(self, configure_args):\n resulting_configuration = ImmutableDict(self.config)\n multiple_callbacks = copy.copy(\n self._post_configure_callbacks['multiple']\n )\n single_callbacks = copy.copy(self._post_configure_callbacks['single'])\n self._post_configure_callbacks['single'] = []\n for callback in multiple_callbacks:\n callback(resulting_configuration, configure_args)\n for callback in single_callbacks:\n callback(resulting_configuration, configure_args)", "docstring": "Run all post configure callbacks we have stored.\n\n Functions are passed the configuration that resulted from the call to\n :meth:`configure` as the first argument, in an immutable form; and are\n given the arguments passed to :meth:`configure` for the second\n argument.\n\n Returns from callbacks are ignored in all fashion.\n\n Args:\n configure_args (list[object]):\n The full list of arguments passed to :meth:`configure`.\n\n Returns:\n None:\n Does not return anything." }, { "code": "def returns_annualized(returns, geometric=True, scale=None, expanding=False):\n scale = _resolve_periods_in_year(scale, returns)\n if expanding:\n if geometric:\n n = pd.expanding_count(returns)\n return ((1. + returns).cumprod() ** (scale / n)) - 1.\n else:\n return pd.expanding_mean(returns) * scale\n else:\n if geometric:\n n = returns.count()\n return ((1. + returns).prod() ** (scale / n)) - 1.\n else:\n return returns.mean() * scale", "docstring": "return the annualized cumulative returns\n\n Parameters\n ----------\n returns : DataFrame or Series\n geometric : link the returns geometrically\n scale: None or scalar or string (ie 12 for months in year),\n If None, attempt to resolve from returns\n If scalar, then use this as the annualization factor\n If string, then pass this to periodicity function to resolve annualization factor\n expanding: bool, default is False\n If True, return expanding series/frames.\n If False, return final result." }, { "code": "def update_hash(a_hash, mv):\n if mv.labels:\n signing.add_dict_to_hash(a_hash, encoding.MessageToPyValue(mv.labels))\n money_value = mv.get_assigned_value(u'moneyValue')\n if money_value is not None:\n a_hash.update(b'\\x00')\n a_hash.update(money_value.currencyCode.encode('utf-8'))", "docstring": "Adds ``mv`` to ``a_hash``\n\n Args:\n a_hash (`Hash`): the secure hash, e.g created by hashlib.md5\n mv (:class:`MetricValue`): the instance to add to the hash" }, { "code": "def access(self, path, mode, dir_fd=None, follow_symlinks=None):\n if follow_symlinks is not None and sys.version_info < (3, 3):\n raise TypeError(\"access() got an unexpected \"\n \"keyword argument 'follow_symlinks'\")\n path = self._path_with_dir_fd(path, self.access, dir_fd)\n try:\n stat_result = self.stat(path, follow_symlinks=follow_symlinks)\n except OSError as os_error:\n if os_error.errno == errno.ENOENT:\n return False\n raise\n if is_root():\n mode &= ~os.W_OK\n return (mode & ((stat_result.st_mode >> 6) & 7)) == mode", "docstring": "Check if a file exists and has the specified permissions.\n\n Args:\n path: (str) Path to the file.\n mode: (int) Permissions represented as a bitwise-OR combination of\n os.F_OK, os.R_OK, os.W_OK, and os.X_OK.\n dir_fd: If not `None`, the file descriptor of a directory, with\n `path` being relative to this directory.\n New in Python 3.3.\n follow_symlinks: (bool) If `False` and `path` points to a symlink,\n the link itself is queried instead of the linked object.\n New in Python 3.3.\n\n Returns:\n bool, `True` if file is accessible, `False` otherwise." }, { "code": "def get_response(self):\r\n request = getattr(requests, self.request_method, None)\r\n if request is None and self._request_method is None:\r\n raise ValueError(\"A effective http request method must be set\")\r\n if self.request_url is None:\r\n raise ValueError(\r\n \"Fatal error occurred, the class property \\\"request_url\\\" is\"\r\n \"set to None, reset it with an effective url of dingtalk api.\"\r\n )\r\n response = request(self.request_url, **self.kwargs)\r\n self.response = response\r\n return response", "docstring": "Get the original response of requests" }, { "code": "def find_whole_word(w):\n return re.compile(r'\\b({0})\\b'.format(w), flags=re.IGNORECASE).search", "docstring": "Scan through string looking for a location where this word produces a match,\n and return a corresponding MatchObject instance.\n Return None if no position in the string matches the pattern;\n note that this is different from finding a zero-length match at some point in the string." }, { "code": "def _update_plotting_params(self, **kwargs):\n scalars = kwargs.get('scalars', None)\n if scalars is not None:\n old = self.display_params['scalars']\n self.display_params['scalars'] = scalars\n if old != scalars:\n self.plotter.subplot(*self.loc)\n self.plotter.remove_actor(self._data_to_update, reset_camera=False)\n self._need_to_update = True\n self.valid_range = self.input_dataset.get_data_range(scalars)\n cmap = kwargs.get('cmap', None)\n if cmap is not None:\n self.display_params['cmap'] = cmap", "docstring": "Some plotting parameters can be changed through the tool; this\n updataes those plotting parameters." }, { "code": "def get_extra_context(site, ctx):\n\t'Returns extra data useful to the templates.'\n\tctx['site'] = site\n\tctx['feeds'] = feeds = site.active_feeds.order_by('name')\n\tdef get_mod_chk(k):\n\t\tmod, chk = (\n\t\t\t(max(vals) if vals else None) for vals in (\n\t\t\t\tfilter(None, it.imap(op.attrgetter(k), feeds))\n\t\t\t\tfor k in ['last_modified', 'last_checked'] ) )\n\t\tchk = chk or datetime(1970, 1, 1, 0, 0, 0, 0, timezone.utc)\n\t\tctx['last_modified'], ctx['last_checked'] = mod or chk, chk\n\t\treturn ctx[k]\n\tfor k in 'last_modified', 'last_checked':\n\t\tctx[k] = lambda: get_mod_chk(k)\n\tctx['media_url'] = ctx['static_url'] =\\\n\t\t'{}feedjack/{}'.format(settings.STATIC_URL, site.template)", "docstring": "Returns extra data useful to the templates." }, { "code": "def format(self, obj, **kwargs):\n sio = StringIO()\n self.fprint(obj, stream=sio, **kwargs)\n return sio.getvalue()", "docstring": "Return the formatted representation of the object as a string." }, { "code": "def link(self, title, path):\n if not isinstance(path, file):\n path = salt.utils.files.fopen(path)\n self.__current_section.append({title: path})", "docstring": "Add a static file on the file system.\n\n :param title:\n :param path:\n :return:" }, { "code": "def pWMWrite(fileHandle, pWM, alphabetSize=4):\n for i in xrange(0, alphabetSize):\n fileHandle.write(\"%s\\n\" % ' '.join([ str(pWM[j][i]) for j in xrange(0, len(pWM)) ]))", "docstring": "Writes file in standard PWM format, is reverse of pWMParser" }, { "code": "def dict_to_numpy_array(d):\n return fromarrays(d.values(), np.dtype([(str(k), v.dtype) for k, v in d.items()]))", "docstring": "Convert a dict of 1d array to a numpy recarray" }, { "code": "def get_user(self, user_name=None):\n params = {}\n if user_name:\n params['UserName'] = user_name\n return self.get_response('GetUser', params)", "docstring": "Retrieve information about the specified user.\n\n If the user_name is not specified, the user_name is determined\n implicitly based on the AWS Access Key ID used to sign the request.\n\n :type user_name: string\n :param user_name: The name of the user to delete.\n If not specified, defaults to user making\n request." }, { "code": "def _uri_to_etext(cls, uri_ref):\n try:\n return validate_etextno(int(os.path.basename(uri_ref.toPython())))\n except InvalidEtextIdException:\n return None", "docstring": "Converts the representation used to identify a text in the\n meta-data RDF graph to a human-friendly integer text identifier." }, { "code": "def _cancelScheduledUpgrade(self, justification=None) -> None:\n if self.scheduledAction:\n why_prefix = \": \"\n why = justification\n if justification is None:\n why_prefix = \", \"\n why = \"cancellation reason not specified\"\n ev_data = self.scheduledAction\n logger.info(\"Cancelling upgrade {}\"\n \" of node {}\"\n \" of package {}\"\n \" to version {}\"\n \" scheduled on {}\"\n \"{}{}\"\n .format(ev_data.upgrade_id,\n self.nodeName,\n ev_data.pkg_name,\n ev_data.version,\n ev_data.when,\n why_prefix,\n why))\n self._unscheduleAction()\n self._actionLog.append_cancelled(ev_data)\n self._notifier.sendMessageUponPoolUpgradeCancel(\n \"Upgrade of package {} on node '{}' to version {} \"\n \"has been cancelled due to {}\"\n .format(ev_data.pkg_name, self.nodeName,\n ev_data.version, why))", "docstring": "Cancels scheduled upgrade\n\n :param when: time upgrade was scheduled to\n :param version: version upgrade scheduled for" }, { "code": "def read_chunk(stream):\n chunk = stream.read(1)\n while chunk in SKIP:\n chunk = stream.read(1)\n if chunk == \"\\\"\":\n chunk += stream.read(1)\n while not chunk.endswith(\"\\\"\"):\n if chunk[-1] == ESCAPE:\n chunk += stream.read(2)\n else:\n chunk += stream.read(1)\n return chunk", "docstring": "Ignore whitespace outside of strings. If we hit a string, read it in\n its entirety." }, { "code": "def choose(self, choose_from):\n for choice in self.elements:\n if choice in choose_from:\n return ImplementationChoice(choice, choose_from[choice])\n raise LookupError(self.elements, choose_from.keys())", "docstring": "given a mapping of implementations\n choose one based on the current settings\n returns a key value pair" }, { "code": "def get_info(self):\n reconstructed = self.is_reconstructed()\n site, site_type = self.get_site()\n return reconstructed, site, site_type", "docstring": "Return surface reconstruction as well as primary and\n secondary adsorption site labels" }, { "code": "def vb_destroy_machine(name=None, timeout=10000):\n vbox = vb_get_box()\n log.info('Destroying machine %s', name)\n machine = vbox.findMachine(name)\n files = machine.unregister(2)\n progress = machine.deleteConfig(files)\n progress.waitForCompletion(timeout)\n log.info('Finished destroying machine %s', name)", "docstring": "Attempts to get rid of a machine and all its files from the hypervisor\n @param name:\n @type name: str\n @param timeout int timeout in milliseconds" }, { "code": "def _update_font_style(self, font_style):\n toggle_state = font_style & wx.FONTSTYLE_ITALIC == wx.FONTSTYLE_ITALIC\n self.ToggleTool(wx.FONTFLAG_ITALIC, toggle_state)", "docstring": "Updates font style widget\n\n Parameters\n ----------\n\n font_style: Integer\n \\tButton down iif font_style == wx.FONTSTYLE_ITALIC" }, { "code": "def _dump_to_pages(dump):\n pos = 0\n ret = []\n start_tag = u\"\\n\"\n end_tag = u\"\\n\"\n while True:\n start_pos = dump.find(start_tag, pos)\n if start_pos == -1:\n break\n start_pos += len(start_tag)\n end_pos = dump.find(end_tag, start_pos)\n if end_pos == -1:\n break\n ret.append(dump[start_pos:end_pos])\n pos = end_pos + len(end_tag)\n return ret", "docstring": "Extract pages from an xml dump.\n\n Args:\n dump: a unicode string\n Returns:\n a list of unicode strings" }, { "code": "def _load_from_cache_if_available(self, key):\n if key in self._cache:\n entity = self._cache[key]\n if entity is None or entity._key == key:\n raise tasklets.Return(entity)", "docstring": "Returns a cached Model instance given the entity key if available.\n\n Args:\n key: Key instance.\n\n Returns:\n A Model instance if the key exists in the cache." }, { "code": "def _handle_command(self, command, env, args):\n plugin_obj = registration.get_command_hook(command, env.task.active)\n if plugin_obj and not env.task.active:\n if plugin_obj.task_only or plugin_obj.options:\n plugin_obj = None\n if plugin_obj:\n if plugin_obj.needs_root:\n registration.setup_sudo_access(plugin_obj)\n parser = self._get_plugin_parser(plugin_obj)\n parsed_args = parser.parse_args(args)\n plugin_obj.execute(env, parsed_args)\n return True\n return False", "docstring": "Handles calling appropriate command plugin based on the arguments\n provided.\n\n `command`\n Command string.\n `env`\n Runtime ``Environment`` instance.\n `args`\n List of argument strings passed.\n\n Returns ``False`` if nothing handled.\n\n * Raises ``HelpBanner`` exception if mismatched command arguments." }, { "code": "def compile_pillar(self):\n load = {'id': self.minion_id,\n 'grains': self.grains,\n 'saltenv': self.opts['saltenv'],\n 'pillarenv': self.opts['pillarenv'],\n 'pillar_override': self.pillar_override,\n 'extra_minion_data': self.extra_minion_data,\n 'ver': '2',\n 'cmd': '_pillar'}\n if self.ext:\n load['ext'] = self.ext\n try:\n ret_pillar = yield self.channel.crypted_transfer_decode_dictentry(\n load,\n dictkey='pillar',\n )\n except Exception:\n log.exception('Exception getting pillar:')\n raise SaltClientError('Exception getting pillar.')\n if not isinstance(ret_pillar, dict):\n msg = ('Got a bad pillar from master, type {0}, expecting dict: '\n '{1}').format(type(ret_pillar).__name__, ret_pillar)\n log.error(msg)\n raise SaltClientError(msg)\n raise tornado.gen.Return(ret_pillar)", "docstring": "Return a future which will contain the pillar data from the master" }, { "code": "def show_image(kwargs, call=None):\n if call != 'function':\n raise SaltCloudSystemExit(\n 'The show_image action must be called with -f or --function.'\n )\n name = kwargs['image']\n log.info(\"Showing image %s\", name)\n machine = vb_get_machine(name)\n ret = {\n machine[\"name\"]: treat_machine_dict(machine)\n }\n del machine[\"name\"]\n return ret", "docstring": "Show the details of an image" }, { "code": "def _get_bundles_by_type(self, type):\n bundles = {}\n bundle_definitions = self.config.get(type)\n if bundle_definitions is None:\n return bundles\n for bundle_name, paths in bundle_definitions.items():\n bundle_files = []\n for path in paths:\n pattern = abspath = os.path.join(self.basedir, path)\n assetdir = os.path.dirname(abspath)\n fnames = [os.path.join(assetdir, fname)\n for fname in os.listdir(assetdir)]\n expanded_fnames = fnmatch.filter(fnames, pattern)\n bundle_files.extend(sorted(expanded_fnames))\n bundles[bundle_name] = bundle_files\n return bundles", "docstring": "Get a dictionary of bundles for requested type.\n\n Args:\n type: 'javascript' or 'css'" }, { "code": "def DOM_node_to_XML(tree, xml_declaration=True):\n result = ET.tostring(tree, encoding='utf8', method='xml').decode('utf-8')\n if not xml_declaration:\n result = result.split(\"\\n\")[1]\n return result", "docstring": "Prints a DOM tree to its Unicode representation.\n\n :param tree: the input DOM tree\n :type tree: an ``xml.etree.ElementTree.Element`` object\n :param xml_declaration: if ``True`` (default) prints a leading XML\n declaration line\n :type xml_declaration: bool\n :returns: Unicode object" }, { "code": "def get(self, key):\n if key in self and len(self[key]) > 0:\n return min(self[key])\n else:\n return 0", "docstring": "Return timings for `key`. Returns 0 if not present." }, { "code": "def apply_numpy_specials(self, copy=True):\n if copy:\n data = self.data.astype(numpy.float64)\n elif self.data.dtype != numpy.float64:\n data = self.data = self.data.astype(numpy.float64)\n else:\n data = self.data\n data[data == self.specials['Null']] = numpy.nan\n data[data < self.specials['Min']] = numpy.NINF\n data[data > self.specials['Max']] = numpy.inf\n return data", "docstring": "Convert isis special pixel values to numpy special pixel values.\n\n ======= =======\n Isis Numpy\n ======= =======\n Null nan\n Lrs -inf\n Lis -inf\n His inf\n Hrs inf\n ======= =======\n\n Parameters\n ----------\n copy : bool [True]\n Whether to apply the new special values to a copy of the\n pixel data and leave the original unaffected\n\n Returns\n -------\n Numpy Array\n A numpy array with special values converted to numpy's nan, inf,\n and -inf" }, { "code": "def with_log(func):\n @functools.wraps(func)\n def wrapper(*args, **kwargs):\n decorator_logger = logging.getLogger('@with_log')\n decorator_logger.debug('Entering %s() function call.', func.__name__)\n log = kwargs.get('log', logging.getLogger(func.__name__))\n try:\n ret = func(log=log, *args, **kwargs)\n finally:\n decorator_logger.debug('Leaving %s() function call.', func.__name__)\n return ret\n return wrapper", "docstring": "Automatically adds a named logger to a function upon function call.\n\n :param func: Function to decorate.\n\n :return: Decorated function.\n :rtype: function" }, { "code": "def guess_xml_encoding(self, content):\n r\n matchobj = self.__regex['xml_encoding'].match(content)\n return matchobj and matchobj.group(1).lower()", "docstring": "r\"\"\"Guess encoding from xml header declaration.\n\n :param content: xml content\n :rtype: str or None" }, { "code": "def parse_s2bins(s2bins):\n s2b = {}\n b2s = {}\n for line in s2bins:\n line = line.strip().split()\n s, b = line[0], line[1]\n if 'UNK' in b:\n continue\n if len(line) > 2:\n g = ' '.join(line[2:])\n else:\n g = 'n/a'\n b = '%s\\t%s' % (b, g)\n s2b[s] = b \n if b not in b2s:\n b2s[b] = []\n b2s[b].append(s)\n return s2b, b2s", "docstring": "parse ggKbase scaffold-to-bin mapping\n - scaffolds-to-bins and bins-to-scaffolds" }, { "code": "def __FinalUrlValue(self, value, field):\n if isinstance(field, messages.BytesField) and value is not None:\n return base64.urlsafe_b64encode(value)\n elif isinstance(value, six.text_type):\n return value.encode('utf8')\n elif isinstance(value, six.binary_type):\n return value.decode('utf8')\n elif isinstance(value, datetime.datetime):\n return value.isoformat()\n return value", "docstring": "Encode value for the URL, using field to skip encoding for bytes." }, { "code": "def open(self):\r\n filename = self.dialogs.getOpenFileName(filter=\"*.%s\" % self.FTYPE)\r\n if filename:\r\n self.new(filename)", "docstring": "open a session to define in a dialog in an extra window" }, { "code": "def facilityNetToMs():\n a = TpPd(pd=0x3)\n b = MessageType(mesType=0x3a)\n c = Facility()\n packet = a / b / c\n return packet", "docstring": "FACILITY Section 9.3.9.1" }, { "code": "def growth_volatility(eqdata, **kwargs):\n _window = kwargs.get('window', 20)\n _selection = kwargs.get('selection', 'Adj Close')\n _outputcol = kwargs.get('outputcol', 'Growth Risk')\n _growthdata = simple.growth(eqdata, selection=_selection)\n return volatility(_growthdata, outputcol=_outputcol, window=_window)", "docstring": "Return the volatility of growth.\n\n Note that, like :func:`pynance.tech.simple.growth` but in contrast to \n :func:`volatility`, :func:`growth_volatility`\n applies directly to a dataframe like that returned by \n :func:`pynance.data.retrieve.get`, not necessarily to a single-column dataframe.\n\n Parameters\n ----------\n eqdata : DataFrame\n Data from which to extract growth volatility. An exception\n will be raised if `eqdata` does not contain a column 'Adj Close'\n or an optional name specified by the `selection` parameter.\n window : int, optional\n Window on which to calculate volatility. Defaults to 20.\n selection : str, optional\n Column of eqdata on which to calculate volatility of growth. Defaults\n to 'Adj Close'\n outputcol : str, optional\n Column to use for output. Defaults to 'Growth Risk'.\n\n Returns\n ---------\n out : DataFrame\n Dataframe showing the volatility of growth over the specified `window`." }, { "code": "def config_oauth(app):\n \" Configure oauth support. \"\n for name in PROVIDERS:\n config = app.config.get('OAUTH_%s' % name.upper())\n if not config:\n continue\n if not name in oauth.remote_apps:\n remote_app = oauth.remote_app(name, **config)\n else:\n remote_app = oauth.remote_apps[name]\n client_class = CLIENTS.get(name)\n client_class(app, remote_app)", "docstring": "Configure oauth support." }, { "code": "def flatten_path(path, flatten_slashes=False):\n if not path or path == '/':\n return '/'\n if path[0] == '/':\n path = path[1:]\n parts = path.split('/')\n new_parts = collections.deque()\n for part in parts:\n if part == '.' or (flatten_slashes and not part):\n continue\n elif part != '..':\n new_parts.append(part)\n elif new_parts:\n new_parts.pop()\n if flatten_slashes and path.endswith('/') or not len(new_parts):\n new_parts.append('')\n new_parts.appendleft('')\n return '/'.join(new_parts)", "docstring": "Flatten an absolute URL path by removing the dot segments.\n\n :func:`urllib.parse.urljoin` has some support for removing dot segments,\n but it is conservative and only removes them as needed.\n\n Arguments:\n path (str): The URL path.\n flatten_slashes (bool): If True, consecutive slashes are removed.\n\n The path returned will always have a leading slash." }, { "code": "def field_to_long(value):\n if isinstance(value, (int, long)):\n return long(value)\n elif isinstance(value, basestring):\n return bytes_to_long(from_hex(value))\n else:\n return None", "docstring": "Converts given value to long if possible, otherwise None is returned.\n\n :param value:\n :return:" }, { "code": "def verify_signature(self, addr):\n return verify(virtualchain.address_reencode(addr), self.get_plaintext_to_sign(), self.sig)", "docstring": "Given an address, verify whether or not it was signed by it" }, { "code": "def fail(self, message, status=500, **kw):\n self.request.response.setStatus(status)\n result = {\"success\": False, \"errors\": message, \"status\": status}\n result.update(kw)\n return result", "docstring": "Set a JSON error object and a status to the response" }, { "code": "def look_up(self, **keys: Dict[InstanceName, ScalarValue]) -> \"ArrayEntry\":\n if not isinstance(self.schema_node, ListNode):\n raise InstanceValueError(self.json_pointer(), \"lookup on non-list\")\n try:\n for i in range(len(self.value)):\n en = self.value[i]\n flag = True\n for k in keys:\n if en[k] != keys[k]:\n flag = False\n break\n if flag:\n return self._entry(i)\n raise NonexistentInstance(self.json_pointer(), \"entry lookup failed\")\n except KeyError:\n raise NonexistentInstance(self.json_pointer(), \"entry lookup failed\") from None\n except TypeError:\n raise InstanceValueError(self.json_pointer(), \"lookup on non-list\") from None", "docstring": "Return the entry with matching keys.\n\n Args:\n keys: Keys and values specified as keyword arguments.\n\n Raises:\n InstanceValueError: If the receiver's value is not a YANG list.\n NonexistentInstance: If no entry with matching keys exists." }, { "code": "def setSignalHeaders(self, signalHeaders):\n for edfsignal in np.arange(self.n_channels):\n self.channels[edfsignal] = signalHeaders[edfsignal]\n self.update_header()", "docstring": "Sets the parameter for all signals\n\n Parameters\n ----------\n signalHeaders : array_like\n containing dict with\n 'label' : str\n channel label (string, <= 16 characters, must be unique)\n 'dimension' : str\n physical dimension (e.g., mV) (string, <= 8 characters)\n 'sample_rate' : int\n sample frequency in hertz\n 'physical_max' : float\n maximum physical value\n 'physical_min' : float\n minimum physical value\n 'digital_max' : int\n maximum digital value (-2**15 <= x < 2**15)\n 'digital_min' : int\n minimum digital value (-2**15 <= x < 2**15)" }, { "code": "def socket_close(self):\n if self.sock != NC.INVALID_SOCKET:\n self.sock.close()\n self.sock = NC.INVALID_SOCKET", "docstring": "Close our socket." }, { "code": "def _cosmoid_request(self, resource, cosmoid, **kwargs):\n params = {\n 'cosmoid': cosmoid,\n }\n params.update(kwargs)\n return self.make_request(resource, params)", "docstring": "Maps to the Generic API method for requests who's only parameter is ``cosmoid``" }, { "code": "def iter_entries(self):\n for idx in range(self._entry_count):\n dir_entry_offset = self._offset + 2 + (idx*12)\n ifd_entry = _IfdEntryFactory(self._stream_rdr, dir_entry_offset)\n yield ifd_entry", "docstring": "Generate an |_IfdEntry| instance corresponding to each entry in the\n directory." }, { "code": "def _response_value(self, response, json=True):\n if json:\n contentType = response.headers.get(\"Content-Type\", \"\")\n if not contentType.startswith((\"application/json\",\n \"text/javascript\")):\n if response.status_code == 200:\n raise CloudStackException(\n \"JSON (application/json) was expected, got {!r}\"\n .format(contentType),\n response=response)\n raise CloudStackException(\n \"HTTP {0.status_code} {0.reason}\"\n .format(response),\n \"Make sure endpoint URL {!r} is correct.\"\n .format(self.endpoint),\n response=response)\n try:\n data = response.json()\n except ValueError as e:\n raise CloudStackException(\n \"HTTP {0.status_code} {0.reason}\"\n .format(response),\n \"{0!s}. Malformed JSON document\".format(e),\n response=response)\n [key] = data.keys()\n data = data[key]\n else:\n data = response.text\n if response.status_code != 200:\n raise CloudStackException(\n \"HTTP {0} response from CloudStack\".format(\n response.status_code),\n data,\n response=response)\n return data", "docstring": "Parses the HTTP response as a the cloudstack value.\n\n It throws an exception if the server didn't answer with a 200." }, { "code": "def level_names(self):\n index = self.to_index()\n if isinstance(index, pd.MultiIndex):\n return index.names\n else:\n return None", "docstring": "Return MultiIndex level names or None if this IndexVariable has no\n MultiIndex." }, { "code": "def _get_enum(self, source, bitarray):\n raw_value = self._get_raw(source, bitarray)\n value_desc = source.find('item', {'value': str(raw_value)}) or self._get_rangeitem(source, raw_value)\n return {\n source['shortcut']: {\n 'description': source.get('description'),\n 'unit': source.get('unit', ''),\n 'value': value_desc['description'].format(value=raw_value),\n 'raw_value': raw_value,\n }\n }", "docstring": "Get enum value, based on the data in XML" }, { "code": "def get_statements(self):\n for k, v in self.reader_output.items():\n for interaction in v['interactions']:\n self._process_interaction(k, interaction, v['text'], self.pmid,\n self.extra_annotations)", "docstring": "Process reader output to produce INDRA Statements." }, { "code": "def _known_populations(row, pops):\n cutoff = 0.01\n out = set([])\n for pop, base in [(\"esp\", \"af_esp_all\"), (\"1000g\", \"af_1kg_all\"),\n (\"exac\", \"af_exac_all\"), (\"anypop\", \"max_aaf_all\")]:\n for key in [x for x in pops if x.startswith(base)]:\n val = row[key]\n if val and val > cutoff:\n out.add(pop)\n return sorted(list(out))", "docstring": "Find variants present in substantial frequency in population databases." }, { "code": "def new(cls, ns_path, script, campaign_dir, runner_type='Auto',\n overwrite=False, optimized=True, check_repo=True):\n ns_path = os.path.abspath(ns_path)\n campaign_dir = os.path.abspath(campaign_dir)\n if Path(campaign_dir).exists() and not overwrite:\n manager = CampaignManager.load(campaign_dir, ns_path,\n runner_type=runner_type,\n optimized=optimized,\n check_repo=check_repo)\n if manager.db.get_script() == script:\n return manager\n else:\n del manager\n runner = CampaignManager.create_runner(ns_path, script,\n runner_type=runner_type,\n optimized=optimized)\n params = runner.get_available_parameters()\n commit = \"\"\n if check_repo:\n from git import Repo, exc\n commit = Repo(ns_path).head.commit.hexsha\n db = DatabaseManager.new(script=script,\n params=params,\n commit=commit,\n campaign_dir=campaign_dir,\n overwrite=overwrite)\n return cls(db, runner, check_repo)", "docstring": "Create a new campaign from an ns-3 installation and a campaign\n directory.\n\n This method will create a DatabaseManager, which will install a\n database in the specified campaign_dir. If a database is already\n available at the ns_path described in the specified campaign_dir and\n its configuration matches config, this instance is used instead. If the\n overwrite argument is set to True instead, the specified directory is\n wiped and a new campaign is created in its place.\n\n Furthermore, this method will initialize a SimulationRunner, of type\n specified by the runner_type parameter, which will be locked on the\n ns-3 installation at ns_path and set up to run the desired script.\n\n Finally, note that creation of a campaign requires a git repository to\n be initialized at the specified ns_path. This will allow SEM to save\n the commit at which the simulations are run, enforce reproducibility\n and avoid mixing results coming from different versions of ns-3 and its\n libraries.\n\n Args:\n ns_path (str): path to the ns-3 installation to employ in this\n campaign.\n script (str): ns-3 script that will be executed to run simulations.\n campaign_dir (str): path to the directory in which to save the\n simulation campaign database.\n runner_type (str): implementation of the SimulationRunner to use.\n Value can be: SimulationRunner (for running sequential\n simulations locally), ParallelRunner (for running parallel\n simulations locally), GridRunner (for running simulations using\n a DRMAA-compatible parallel task scheduler). Use Auto to\n automatically pick the best runner.\n overwrite (bool): whether to overwrite already existing\n campaign_dir folders. This deletes the directory if and only if\n it only contains files that were detected to be created by sem.\n optimized (bool): whether to configure the runner to employ an\n optimized ns-3 build." }, { "code": "def nodeToXML(nodeObject):\n xmlRoot = etree.Element(NODE + \"node\", nsmap=NODE_NSMAP)\n nameNode = etree.SubElement(xmlRoot, NODE + \"name\")\n nameNode.text = nodeObject.node_name\n urlNode = etree.SubElement(xmlRoot, NODE + \"url\")\n urlNode.text = nodeObject.node_url\n pathNode = etree.SubElement(xmlRoot, NODE + \"path\")\n pathNode.text = nodeObject.node_path\n capNode = etree.SubElement(xmlRoot, NODE + \"capacity\")\n capNode.text = str(nodeObject.node_capacity)\n sizeNode = etree.SubElement(xmlRoot, NODE + \"size\")\n sizeNode.text = str(nodeObject.node_size)\n if nodeObject.last_checked:\n checkedNode = etree.SubElement(xmlRoot, NODE + \"lastChecked\")\n checkedNode.text = nodeObject.last_checked.strftime(TIME_FORMAT_STRING)\n return xmlRoot", "docstring": "Take a Django node object from our CODA store and make an XML\n representation" }, { "code": "def visit(self, node):\n for pattern, replace in know_pattern:\n check = Check(node, dict())\n if check.visit(pattern):\n node = PlaceholderReplace(check.placeholders).visit(replace())\n self.update = True\n return super(PatternTransform, self).visit(node)", "docstring": "Try to replace if node match the given pattern or keep going." }, { "code": "def write_badge(self, file_path, overwrite=False):\n if file_path.endswith('/'):\n raise Exception('File location may not be a directory.')\n path = os.path.abspath(file_path)\n if not path.lower().endswith('.svg'):\n path += '.svg'\n if not overwrite and os.path.exists(path):\n raise Exception('File \"{}\" already exists.'.format(path))\n with open(path, mode='w') as file_handle:\n file_handle.write(self.badge_svg_text)", "docstring": "Write badge to file." }, { "code": "def load(self, profile_args):\n for key, value in profile_args.items():\n self.add(key, value)", "docstring": "Load provided CLI Args.\n\n Args:\n args (dict): Dictionary of args in key/value format." }, { "code": "def GetFeedItemIdsForCampaign(campaign_feed):\n feed_item_ids = set()\n try:\n lhs_operand = campaign_feed['matchingFunction']['lhsOperand']\n except KeyError:\n lhs_operand = None\n if (lhs_operand and lhs_operand[0]['FunctionArgumentOperand.Type'] ==\n 'RequestContextOperand'):\n request_context_operand = lhs_operand[0]\n if (request_context_operand['contextType'] == 'FEED_ITEM_ID' and\n campaign_feed['matchingFunction']['operator'] == 'IN'):\n for argument in campaign_feed['matchingFunction']['rhsOperand']:\n if argument['xsi_type'] == 'ConstantOperand':\n feed_item_ids.add(argument['longValue'])\n return feed_item_ids", "docstring": "Gets the Feed Item Ids used by a campaign through a given Campaign Feed.\n\n Args:\n campaign_feed: the Campaign Feed we are retrieving Feed Item Ids from.\n\n Returns:\n A list of Feed Item IDs." }, { "code": "def get_default_gwf_api():\n for lib in APIS:\n try:\n import_gwf_library(lib)\n except ImportError:\n continue\n else:\n return lib\n raise ImportError(\"no GWF API available, please install a third-party GWF \"\n \"library ({}) and try again\".format(', '.join(APIS)))", "docstring": "Return the preferred GWF library\n\n Examples\n --------\n If you have |LDAStools.frameCPP|_ installed:\n\n >>> from gwpy.timeseries.io.gwf import get_default_gwf_api\n >>> get_default_gwf_api()\n 'framecpp'\n\n Or, if you don't have |lalframe|_:\n\n >>> get_default_gwf_api()\n 'lalframe'\n\n Otherwise:\n\n >>> get_default_gwf_api()\n ImportError: no GWF API available, please install a third-party GWF\n library (framecpp, lalframe) and try again" }, { "code": "def concat_padded(base, *args):\n ret = base\n for n in args:\n if is_string(n):\n ret = \"%s_%s\" % (ret, n)\n else:\n ret = \"%s_%04i\" % (ret, n + 1)\n return ret", "docstring": "Concatenate string and zero-padded 4 digit number" }, { "code": "def _pool_event_refresh_cb(conn, pool, opaque):\n _salt_send_event(opaque, conn, {\n 'pool': {\n 'name': pool.name(),\n 'uuid': pool.UUIDString()\n },\n 'event': opaque['event']\n })", "docstring": "Storage pool refresh events handler" }, { "code": "def getanymentions(idf, anidfobject):\n name = anidfobject.obj[1]\n foundobjs = []\n keys = idfobjectkeys(idf)\n idfkeyobjects = [idf.idfobjects[key.upper()] for key in keys]\n for idfobjects in idfkeyobjects:\n for idfobject in idfobjects:\n if name.upper() in [item.upper() \n for item in idfobject.obj \n if isinstance(item, basestring)]:\n foundobjs.append(idfobject)\n return foundobjs", "docstring": "Find out if idjobject is mentioned an any object anywhere" }, { "code": "def remove_external_data_field(tensor, field_key):\n for (i, field) in enumerate(tensor.external_data):\n if field.key == field_key:\n del tensor.external_data[i]", "docstring": "Remove a field from a Tensor's external_data key-value store.\n\n Modifies tensor object in place.\n\n @params\n tensor: Tensor object from which value will be removed\n field_key: The key of the field to be removed" }, { "code": "def encode_command(*args, buf=None):\n if buf is None:\n buf = bytearray()\n buf.extend(b'*%d\\r\\n' % len(args))\n try:\n for arg in args:\n barg = _converters[type(arg)](arg)\n buf.extend(b'$%d\\r\\n%s\\r\\n' % (len(barg), barg))\n except KeyError:\n raise TypeError(\"Argument {!r} expected to be of bytearray, bytes,\"\n \" float, int, or str type\".format(arg))\n return buf", "docstring": "Encodes arguments into redis bulk-strings array.\n\n Raises TypeError if any of args not of bytearray, bytes, float, int, or str\n type." }, { "code": "def capabilities(self):\n response = self.get(PATH_CAPABILITIES)\n return _load_atom(response, MATCH_ENTRY_CONTENT).capabilities", "docstring": "Returns the list of system capabilities.\n\n :return: A ``list`` of capabilities." }, { "code": "async def start_authentication(self):\n _, code = await self.http.post_data(\n 'pair-pin-start', headers=_AIRPLAY_HEADERS)\n if code != 200:\n raise DeviceAuthenticationError('pair start failed')", "docstring": "Start the authentication process.\n\n This method will show the expected PIN on screen." }, { "code": "async def get_person(self, id_):\n data = await self._get_person_json(\n id_,\n OrderedDict(append_to_response='movie_credits')\n )\n return Person.from_json(data, self.config['data'].get('images'))", "docstring": "Retrieve person data by ID.\n\n Arguments:\n id_ (:py:class:`int`): The person's TMDb ID.\n\n Returns:\n :py:class:`~.Person`: The requested person." }, { "code": "def __get_payload(self, uuid, failed):\n try:\n return self.publish_uuid_store[uuid]\n except Exception as exc:\n msg = \"Failed to load payload from publish store for UUID %s, %s: %s\"\n if uuid in failed:\n log.error(msg, uuid, \"discarding\", str(exc))\n self.__discard_publish_uuid(uuid, failed)\n else:\n log.error(msg, uuid, \"will try agan\", str(exc))\n failed.add(uuid)\n return None", "docstring": "Retry reading a message from the publish_uuid_store once, delete on the second failure." }, { "code": "def remove_port_profile_to_delete(self, profile_name, device_id):\n with self.session.begin(subtransactions=True):\n self.session.query(ucsm_model.PortProfileDelete).filter_by(\n profile_id=profile_name, device_id=device_id).delete()", "docstring": "Removes port profile to be deleted from table." }, { "code": "def work_experience(self, working_start_age: int = 22) -> int:\n age = self._store['age']\n if age == 0:\n age = self.age()\n return max(age - working_start_age, 0)", "docstring": "Get a work experience.\n\n :param working_start_age: Age then person start to work.\n :return: Depend on previous generated age." }, { "code": "def start_pinging(self) -> None:\n assert self.ping_interval is not None\n if self.ping_interval > 0:\n self.last_ping = self.last_pong = IOLoop.current().time()\n self.ping_callback = PeriodicCallback(\n self.periodic_ping, self.ping_interval * 1000\n )\n self.ping_callback.start()", "docstring": "Start sending periodic pings to keep the connection alive" }, { "code": "def update_user_type(self):\n if self.rb_tutor.isChecked():\n self.user_type = 'tutor'\n elif self.rb_student.isChecked():\n self.user_type = 'student'\n self.accept()", "docstring": "Return either 'tutor' or 'student' based on which radio\n button is selected." }, { "code": "def cli(ctx):\n wandb.try_to_set_up_global_logging()\n if ctx.invoked_subcommand is None:\n click.echo(ctx.get_help())", "docstring": "Weights & Biases.\n\n Run \"wandb docs\" for full documentation." }, { "code": "def write_supercells_with_displacements(supercell, cells_with_disps, filename=\"geo.gen\"):\n write_dftbp(filename + \"S\", supercell)\n for ii in range(len(cells_with_disps)):\n write_dftbp(filename + \"S-{:03d}\".format(ii+1), cells_with_disps[ii])", "docstring": "Writes perfect supercell and supercells with displacements\n\n Args:\n supercell: perfect supercell\n cells_with_disps: supercells with displaced atoms\n filename: root-filename" }, { "code": "def addrs_for_hash(self, h):\n if h not in self._hash_mapping:\n return\n self._mark_updated_mapping(self._hash_mapping, h)\n to_discard = set()\n for e in self._hash_mapping[h]:\n try:\n if h == hash(self[e].object): yield e\n else: to_discard.add(e)\n except KeyError:\n to_discard.add(e)\n self._hash_mapping[h] -= to_discard", "docstring": "Returns addresses that contain expressions that contain a variable with the hash of `h`." }, { "code": "def Attach(self, pid):\n if self.inferior.is_running:\n answer = raw_input('Already attached to process ' +\n str(self.inferior.pid) +\n '. Detach? [y]/n ')\n if answer and answer != 'y' and answer != 'yes':\n return None\n self.Detach()\n for plugin in self.plugins:\n plugin.position = None\n self.inferior.Reinit(pid)", "docstring": "Attach to the process with the given pid." }, { "code": "def handle_logout_response(self, response, sign_alg=None, digest_alg=None):\n logger.info(\"state: %s\", self.state)\n status = self.state[response.in_response_to]\n logger.info(\"status: %s\", status)\n issuer = response.issuer()\n logger.info(\"issuer: %s\", issuer)\n del self.state[response.in_response_to]\n if status[\"entity_ids\"] == [issuer]:\n self.local_logout(decode(status[\"name_id\"]))\n return 0, \"200 Ok\", [(\"Content-type\", \"text/html\")], []\n else:\n status[\"entity_ids\"].remove(issuer)\n if \"sign_alg\" in status:\n sign_alg = status[\"sign_alg\"]\n return self.do_logout(decode(status[\"name_id\"]),\n status[\"entity_ids\"],\n status[\"reason\"], status[\"not_on_or_after\"],\n status[\"sign\"], sign_alg=sign_alg,\n digest_alg=digest_alg)", "docstring": "handles a Logout response\n\n :param response: A response.Response instance\n :return: 4-tuple of (session_id of the last sent logout request,\n response message, response headers and message)" }, { "code": "def get_publish_path(self, obj):\n return os.path.join(\n obj.chat_type.publish_path, obj.publish_path.lstrip(\"/\")\n )", "docstring": "publish_path joins the publish_paths for the chat type and the channel." }, { "code": "def _generate_examples(self, archive, directory):\n reg = re.compile(os.path.join(\"^%s\" % directory, \"(?P`` and named\n ``0.npy, 1.npy, ... .npy``.\n\n Returns:\n list: A list of loaded data, such that ``list[i]`` contains the the\n contents of ``i.npy``." }, { "code": "def compute_update_ratio(weight_tensors, before_weights, after_weights):\n deltas = [after - before for after,\n before in zip(after_weights, before_weights)]\n delta_norms = [np.linalg.norm(d.ravel()) for d in deltas]\n weight_norms = [np.linalg.norm(w.ravel()) for w in before_weights]\n ratios = [d / w for d, w in zip(delta_norms, weight_norms)]\n all_summaries = [\n tf.Summary.Value(tag='update_ratios/' +\n tensor.name, simple_value=ratio)\n for tensor, ratio in zip(weight_tensors, ratios)]\n return tf.Summary(value=all_summaries)", "docstring": "Compute the ratio of gradient norm to weight norm." }, { "code": "def collection_list(self, resource_id, resource_type=\"collection\"):\n def fetch_children(children):\n results = []\n for child in children:\n results.append(child[\"slug\"])\n if \"children\" in child:\n results.extend(fetch_children(child[\"children\"]))\n return results\n response = self._get(\n urljoin(self.base_url, \"informationobjects/tree/{}\".format(resource_id))\n )\n tree = response.json()\n return fetch_children(tree[\"children\"])", "docstring": "Fetches a list of slug representing descriptions within the specified parent description.\n\n :param resource_id str: The slug of the description to fetch children from.\n :param resource_type str: no-op; not required or used in this implementation.\n\n :return: A list of strings representing the slugs for all children of the requested description.\n :rtype list:" }, { "code": "def same_page(c):\n return all(\n [\n _to_span(c[i]).sentence.is_visual()\n and bbox_from_span(_to_span(c[i])).page\n == bbox_from_span(_to_span(c[0])).page\n for i in range(len(c))\n ]\n )", "docstring": "Return true if all the components of c are on the same page of the document.\n\n Page numbers are based on the PDF rendering of the document. If a PDF file is\n provided, it is used. Otherwise, if only a HTML/XML document is provided, a\n PDF is created and then used to determine the page number of a Mention.\n\n :param c: The candidate to evaluate\n :rtype: boolean" }, { "code": "def expose_event(self, widget, event):\n x, y, width, height = event.area\n self.logger.debug(\"surface is %s\" % self.surface)\n if self.surface is not None:\n win = widget.get_window()\n cr = win.cairo_create()\n cr.rectangle(x, y, width, height)\n cr.clip()\n cr.set_source_surface(self.surface, 0, 0)\n cr.set_operator(cairo.OPERATOR_SOURCE)\n cr.paint()\n return False", "docstring": "When an area of the window is exposed, we just copy out of the\n server-side, off-screen surface to that area." }, { "code": "def _urls_for_js(urls=None):\n if urls is None:\n from .urls import urlpatterns\n urls = [url.name for url in urlpatterns if getattr(url, 'name', None)]\n urls = dict(zip(urls, [get_uri_template(url) for url in urls]))\n urls.update(getattr(settings, 'LEAFLET_STORAGE_EXTRA_URLS', {}))\n return urls", "docstring": "Return templated URLs prepared for javascript." }, { "code": "def _parse_hunk_line(self, line):\n components = line.split('@@')\n if len(components) >= 2:\n hunk_info = components[1]\n groups = self.HUNK_LINE_RE.findall(hunk_info)\n if len(groups) == 1:\n try:\n return int(groups[0])\n except ValueError:\n msg = \"Could not parse '{}' as a line number\".format(groups[0])\n raise GitDiffError(msg)\n else:\n msg = \"Could not find start of hunk in line '{}'\".format(line)\n raise GitDiffError(msg)\n else:\n msg = \"Could not parse hunk in line '{}'\".format(line)\n raise GitDiffError(msg)", "docstring": "Given a hunk line in `git diff` output, return the line number\n at the start of the hunk. A hunk is a segment of code that\n contains changes.\n\n The format of the hunk line is:\n\n @@ -k,l +n,m @@ TEXT\n\n where `k,l` represent the start line and length before the changes\n and `n,m` represent the start line and length after the changes.\n\n `git diff` will sometimes put a code excerpt from within the hunk\n in the `TEXT` section of the line." }, { "code": "def query_array(ncfile, name) -> numpy.ndarray:\n variable = query_variable(ncfile, name)\n maskedarray = variable[:]\n fillvalue_ = getattr(variable, '_FillValue', numpy.nan)\n if not numpy.isnan(fillvalue_):\n maskedarray[maskedarray.mask] = numpy.nan\n return maskedarray.data", "docstring": "Return the data of the variable with the given name from the given\n NetCDF file.\n\n The following example shows that |query_array| returns |nan| entries\n to represent missing values even when the respective NetCDF variable\n defines a different fill value:\n\n >>> from hydpy import TestIO\n >>> from hydpy.core.netcdftools import netcdf4\n >>> from hydpy.core import netcdftools\n >>> netcdftools.fillvalue = -999.0\n >>> with TestIO():\n ... with netcdf4.Dataset('test.nc', 'w') as ncfile:\n ... netcdftools.create_dimension(ncfile, 'dim1', 5)\n ... netcdftools.create_variable(ncfile, 'var1', 'f8', ('dim1',))\n ... ncfile = netcdf4.Dataset('test.nc', 'r')\n >>> netcdftools.query_variable(ncfile, 'var1')[:].data\n array([-999., -999., -999., -999., -999.])\n >>> netcdftools.query_array(ncfile, 'var1')\n array([ nan, nan, nan, nan, nan])\n >>> import numpy\n >>> netcdftools.fillvalue = numpy.nan" }, { "code": "def nodes(self, t=None, data=False):\n return list(self.nodes_iter(t=t, data=data))", "docstring": "Return a list of the nodes in the graph at a given snapshot.\n\n Parameters\n ----------\n t : snapshot id (default=None)\n If None the the method returns all the nodes of the flattened graph.\n data : boolean, optional (default=False)\n If False return a list of nodes. If True return a\n two-tuple of node and node data dictionary\n\n Returns\n -------\n nlist : list\n A list of nodes. If data=True a list of two-tuples containing\n (node, node data dictionary).\n\n Examples\n --------\n >>> G = dn.DynGraph() # or DiGraph, MultiGraph, MultiDiGraph, etc\n >>> G.add_path([0,1,2], 0)\n >>> G.nodes(t=0)\n [0, 1, 2]\n >>> G.add_edge(1, 4, t=1)\n >>> G.nodes(t=0)\n [0, 1, 2]" }, { "code": "def get_root_gradebook_ids(self):\n if self._catalog_session is not None:\n return self._catalog_session.get_root_catalog_ids()\n return self._hierarchy_session.get_roots()", "docstring": "Gets the root gradebook ``Ids`` in this hierarchy.\n\n return: (osid.id.IdList) - the root gradebook ``Ids``\n raise: OperationFailed - unable to complete request\n raise: PermissionDenied - authorization failure\n *compliance: mandatory -- This method must be implemented.*" }, { "code": "def get_elements(self, filter_cls, elem_id=None):\n result = []\n if elem_id is not None:\n try:\n result = [self._class_collection_map[filter_cls][elem_id]]\n except KeyError:\n result = []\n else:\n for e in self._class_collection_map[filter_cls].values():\n result.append(e)\n return result", "docstring": "Get a list of elements from the result and filter the element type by a class.\n\n :param filter_cls:\n :param elem_id: ID of the object\n :type elem_id: Integer\n :return: List of available elements\n :rtype: List" }, { "code": "def _setup_converter_graph(self, converter_list, prune_converters):\n for converter in converter_list:\n if prune_converters:\n try:\n converter.configure()\n except ConverterUnavailable as e:\n log.warning('%s unavailable: %s' %\n (converter.__class__.__name__, str(e)))\n continue\n for in_ in converter.inputs:\n for out in converter.outputs:\n self.dgraph.add_edge(in_, out, converter.cost)\n self.converters[(in_, out)] = converter\n if hasattr(converter, 'direct_outputs'):\n self._setup_direct_converter(converter)", "docstring": "Set up directed conversion graph, pruning unavailable converters as\n necessary" }, { "code": "def get_value(self):\n with self._lock:\n if self._future_value is not None:\n return {\n key: value[:] for key, value in self._future_value.items()\n }\n return None", "docstring": "Retrieves the value to inject in the component\n\n :return: The value to inject" }, { "code": "def get_news(self):\n headers = {\"Content-type\": \"application/x-www-form-urlencoded\",\"Accept\": \"text/plain\",'Referer': 'http://'+self.domain+'/login.phtml',\"User-Agent\": user_agent}\n req = self.session.get('http://'+self.domain+'/team_news.phtml',headers=headers).content\n soup = BeautifulSoup(req)\n news = []\n for i in soup.find_all('div',{'class','article_content_text'}):\n news.append(i.text)\n return news", "docstring": "Get all the news from first page" }, { "code": "def get_instance(self, payload):\n return AssistantFallbackActionsInstance(\n self._version,\n payload,\n assistant_sid=self._solution['assistant_sid'],\n )", "docstring": "Build an instance of AssistantFallbackActionsInstance\n\n :param dict payload: Payload response from the API\n\n :returns: twilio.rest.preview.understand.assistant.assistant_fallback_actions.AssistantFallbackActionsInstance\n :rtype: twilio.rest.preview.understand.assistant.assistant_fallback_actions.AssistantFallbackActionsInstance" }, { "code": "def total_vat(self):\n q = Vat.objects.filter(receipt=self).aggregate(total=Sum('amount'))\n return q['total'] or 0", "docstring": "Returns the sum of all Vat objects." }, { "code": "def astensor(array: TensorLike) -> BKTensor:\n tensor = tf.convert_to_tensor(array, dtype=CTYPE)\n if DEVICE == 'gpu':\n tensor = tensor.gpu()\n N = int(math.log2(size(tensor)))\n tensor = tf.reshape(tensor, ([2]*N))\n return tensor", "docstring": "Convert to product tensor" }, { "code": "def ListFiles(self, ext_attrs=False):\n if not self.IsDirectory():\n raise IOError(\"%s is not a directory.\" % self.path)\n for path in self.files:\n try:\n filepath = utils.JoinPath(self.path, path)\n response = self._Stat(filepath, ext_attrs=ext_attrs)\n pathspec = self.pathspec.Copy()\n pathspec.last.path = utils.JoinPath(pathspec.last.path, path)\n response.pathspec = pathspec\n yield response\n except OSError:\n pass", "docstring": "List all files in the dir." }, { "code": "def _valid_directory(self, path):\n abspath = os.path.abspath(path)\n if not os.path.isdir(abspath):\n raise argparse.ArgumentTypeError('Not a valid directory: {}'.format(abspath))\n return abspath", "docstring": "Ensure that the given path is valid.\n\n :param str path: A valid directory path.\n :raises: :py:class:`argparse.ArgumentTypeError`\n :returns: An absolute directory path." }, { "code": "def schema_remove(dbname, name,\n user=None,\n db_user=None, db_password=None,\n db_host=None, db_port=None):\n if not schema_exists(dbname, name, user=None,\n db_user=db_user, db_password=db_password,\n db_host=db_host, db_port=db_port):\n log.info('Schema \\'%s\\' does not exist in \\'%s\\'', name, dbname)\n return False\n sub_cmd = 'DROP SCHEMA \"{0}\"'.format(name)\n _psql_prepare_and_run(\n ['-c', sub_cmd],\n runas=user,\n maintenance_db=dbname,\n host=db_host, user=db_user, port=db_port, password=db_password)\n if not schema_exists(dbname, name, user,\n db_user=db_user, db_password=db_password,\n db_host=db_host, db_port=db_port):\n return True\n else:\n log.info('Failed to delete schema \\'%s\\'.', name)\n return False", "docstring": "Removes a schema from the Postgres server.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' postgres.schema_remove dbname schemaname\n\n dbname\n Database name we work on\n\n schemaname\n The schema's name we'll remove\n\n user\n System user all operations should be performed on behalf of\n\n db_user\n database username if different from config or default\n\n db_password\n user password if any password for a specified user\n\n db_host\n Database host if different from config or default\n\n db_port\n Database port if different from config or default" }, { "code": "def _include_environment_variables(self, program, executor_vars):\n env_vars = {\n 'RESOLWE_HOST_URL': self.settings_actual.get('RESOLWE_HOST_URL', 'localhost'),\n }\n set_env = self.settings_actual.get('FLOW_EXECUTOR', {}).get('SET_ENV', {})\n env_vars.update(executor_vars)\n env_vars.update(set_env)\n export_commands = ['export {}={}'.format(key, shlex.quote(value)) for key, value in env_vars.items()]\n return os.linesep.join(export_commands) + os.linesep + program", "docstring": "Define environment variables." }, { "code": "def user_list(database=None, user=None, password=None, host=None, port=None):\n client = _client(user=user, password=password, host=host, port=port)\n if not database:\n return client.get_list_cluster_admins()\n client.switch_database(database)\n return client.get_list_users()", "docstring": "List cluster admins or database users.\n\n If a database is specified: it will return database users list.\n If a database is not specified: it will return cluster admins list.\n\n database\n The database to list the users from\n\n user\n The user to connect as\n\n password\n The password of the user\n\n host\n The host to connect to\n\n port\n The port to connect to\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' influxdb08.user_list\n salt '*' influxdb08.user_list \n salt '*' influxdb08.user_list " }, { "code": "def _exchange_refresh_tokens(self):\n 'Exchanges a refresh token for an access token'\n if self.token_cache is not None and 'refresh' in self.token_cache:\n refresh_form = {\n 'grant_type': 'refresh_token',\n 'refresh_token': self.token_cache['refresh'],\n 'client_id': self.client_id,\n 'client_secret': self.client_secret,\n }\n try:\n tokens = self._request_tokens_from_token_endpoint(refresh_form)\n tokens['refresh'] = self.token_cache['refresh']\n return tokens\n except OAuth2Exception:\n logging.exception(\n 'Encountered an exception during refresh token flow.')\n return None", "docstring": "Exchanges a refresh token for an access token" }, { "code": "def _parse_domain_id(self, config):\n match = re.search(r'domain-id (.+)$', config)\n value = match.group(1) if match else None\n return dict(domain_id=value)", "docstring": "Scans the config block and parses the domain-id value\n\n Args:\n config (str): The config block to scan\n\n Returns:\n dict: A dict object that is intended to be merged into the\n resource dict" }, { "code": "def clean_new(self, value):\n value = self.schema_class(value).full_clean()\n return self.object_class(**value)", "docstring": "Return a new object instantiated with cleaned data." }, { "code": "def create_user_deliveryserver(self, domainid, data):\n return self.api_call(\n ENDPOINTS['userdeliveryservers']['new'],\n dict(domainid=domainid),\n body=data)", "docstring": "Create a user delivery server" }, { "code": "def rewind(self):\n self.__data = deque()\n self.__id = None\n self.__address = None\n self.__retrieved = 0\n self.__killed = False\n return self", "docstring": "Rewind this cursor to its unevaluated state.\n\n Reset this cursor if it has been partially or completely evaluated.\n Any options that are present on the cursor will remain in effect.\n Future iterating performed on this cursor will cause new queries to\n be sent to the server, even if the resultant data has already been\n retrieved by this cursor." }, { "code": "def swap(self, a, b):\n self.mem[a], self.mem[b] = self.mem[b], self.mem[a]\n self.asm[a], self.asm[b] = self.asm[b], self.asm[a]", "docstring": "Swaps mem positions a and b" }, { "code": "def pformat(tree):\n if tree.empty():\n return ''\n buf = six.StringIO()\n for line in _pformat(tree.root, 0):\n buf.write(line + \"\\n\")\n return buf.getvalue().strip()", "docstring": "Recursively formats a tree into a nice string representation.\n\n Example Input:\n yahoo = tt.Tree(tt.Node(\"CEO\"))\n yahoo.root.add(tt.Node(\"Infra\"))\n yahoo.root[0].add(tt.Node(\"Boss\"))\n yahoo.root[0][0].add(tt.Node(\"Me\"))\n yahoo.root.add(tt.Node(\"Mobile\"))\n yahoo.root.add(tt.Node(\"Mail\"))\n\n Example Output:\n CEO\n |__Infra\n | |__Boss\n | |__Me\n |__Mobile\n |__Mail" }, { "code": "def create_server(cloud, **kwargs):\n if cloud == 'ec2':\n _create_server_ec2(**kwargs)\n elif cloud == 'rackspace':\n _create_server_rackspace(**kwargs)\n elif cloud == 'gce':\n _create_server_gce(**kwargs)\n else:\n raise ValueError(\"Unknown cloud type: {}\".format(cloud))", "docstring": "Create a new instance" }, { "code": "def wait_for_jobs(self, job_ids, timeout, delay):\n if self.skip:\n return\n logger.debug(\"Waiting up to %d sec for completion of the job IDs %s\", timeout, job_ids)\n remaining_job_ids = set(job_ids)\n found_jobs = []\n countdown = timeout\n while countdown > 0:\n matched_jobs = self.find_jobs(remaining_job_ids)\n if matched_jobs:\n remaining_job_ids.difference_update({job[\"id\"] for job in matched_jobs})\n found_jobs.extend(matched_jobs)\n if not remaining_job_ids:\n return found_jobs\n time.sleep(delay)\n countdown -= delay\n logger.error(\n \"Timed out while waiting for completion of the job IDs %s. Results not updated.\",\n list(remaining_job_ids),\n )", "docstring": "Waits until the jobs appears in the completed job queue." }, { "code": "def S_star(u, dfs_data):\n s_u = S(u, dfs_data)\n if u not in s_u:\n s_u.append(u)\n return s_u", "docstring": "The set of all descendants of u, with u added." }, { "code": "def _gen_full_path(self, filename, file_system=None):\n if file_system is None:\n return '{}/{}'.format(self.dest_file_system, filename)\n else:\n if \":\" not in file_system:\n raise ValueError(\"Invalid file_system specified: {}\".format(file_system))\n return '{}/{}'.format(file_system, filename)", "docstring": "Generate full file path on remote device." }, { "code": "def setUser(self, *args, **kwargs):\n try:\n user = self.mambuuserclass(entid=self['assignedUserKey'], *args, **kwargs)\n except KeyError as kerr:\n err = MambuError(\"La cuenta %s no tiene asignado un usuario\" % self['id'])\n err.noUser = True\n raise err\n except AttributeError as ae:\n from .mambuuser import MambuUser\n self.mambuuserclass = MambuUser\n try:\n user = self.mambuuserclass(entid=self['assignedUserKey'], *args, **kwargs)\n except KeyError as kerr:\n err = MambuError(\"La cuenta %s no tiene asignado un usuario\" % self['id'])\n err.noUser = True\n raise err\n self['user'] = user\n return 1", "docstring": "Adds the user for this loan to a 'user' field.\n\n User is a MambuUser object.\n\n Returns the number of requests done to Mambu." }, { "code": "def get_xpath(stmt, qualified=False, prefix_to_module=False):\n return mk_path_str(stmt, with_prefixes=qualified,\n prefix_onchange=True, prefix_to_module=prefix_to_module)", "docstring": "Gets the XPath of the statement.\n Unless qualified=True, does not include prefixes unless the prefix\n changes mid-XPath.\n\n qualified will add a prefix to each node.\n\n prefix_to_module will resolve prefixes to module names instead.\n\n For RFC 8040, set prefix_to_module=True:\n /prefix:root/node/prefix:node/...\n\n qualified=True:\n /prefix:root/prefix:node/prefix:node/...\n\n qualified=True, prefix_to_module=True:\n /module:root/module:node/module:node/...\n prefix_to_module=True: /module:root/node/module:node/..." }, { "code": "def clean_markup(self, markup, parser=None):\n result_type = type(markup)\n if isinstance(markup, six.string_types):\n doc = fromstring(markup, parser=parser)\n else:\n doc = copy.deepcopy(markup)\n self(doc)\n if issubclass(result_type, six.binary_type):\n return tostring(doc, encoding='utf-8')\n elif issubclass(result_type, six.text_type):\n return tostring(doc, encoding='unicode')\n else:\n return doc", "docstring": "Apply ``Cleaner`` to markup string or document and return a cleaned string or document." }, { "code": "def _read_provenance_from_xml(self, root):\n path = self._special_properties['provenance']\n provenance = root.find(path, XML_NS)\n for step in provenance.iter('provenance_step'):\n title = step.find('title').text\n description = step.find('description').text\n timestamp = step.get('timestamp')\n if 'IF Provenance' in title:\n data = {}\n from safe.metadata35.provenance import IFProvenanceStep\n keys = IFProvenanceStep.impact_functions_fields\n for key in keys:\n value = step.find(key)\n if value is not None:\n data[key] = value.text\n else:\n data[key] = ''\n self.append_if_provenance_step(\n title, description, timestamp, data)\n else:\n self.append_provenance_step(title, description, timestamp)", "docstring": "read metadata provenance from xml.\n\n :param root: container in which we search\n :type root: ElementTree.Element" }, { "code": "def empty_tree(input_list):\n for item in input_list:\n if not isinstance(item, list) or not empty_tree(item):\n return False\n return True", "docstring": "Recursively iterate through values in nested lists." }, { "code": "def stp(br=None, state='disable', iface=None):\n kernel = __grains__['kernel']\n if kernel == 'Linux':\n states = {'enable': 'on', 'disable': 'off'}\n return _os_dispatch('stp', br, states[state])\n elif kernel in SUPPORTED_BSD_LIKE:\n states = {'enable': 'stp', 'disable': '-stp'}\n return _os_dispatch('stp', br, states[state], iface)\n else:\n return False", "docstring": "Sets Spanning Tree Protocol state for a bridge\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' bridge.stp br0 enable\n salt '*' bridge.stp br0 disable\n\n For BSD-like operating systems, it is required to add the interface on\n which to enable the STP.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' bridge.stp bridge0 enable fxp0\n salt '*' bridge.stp bridge0 disable fxp0" }, { "code": "def getCanonicalID(iname, xrd_tree):\n xrd_list = xrd_tree.findall(xrd_tag)\n xrd_list.reverse()\n try:\n canonicalID = xri.XRI(xrd_list[0].findall(canonicalID_tag)[0].text)\n except IndexError:\n return None\n childID = canonicalID.lower()\n for xrd in xrd_list[1:]:\n parent_sought = childID[:childID.rindex('!')]\n parent = xri.XRI(xrd.findtext(canonicalID_tag))\n if parent_sought != parent.lower():\n raise XRDSFraud(\"%r can not come from %s\" % (childID, parent))\n childID = parent_sought\n root = xri.rootAuthority(iname)\n if not xri.providerIsAuthoritative(root, childID):\n raise XRDSFraud(\"%r can not come from root %r\" % (childID, root))\n return canonicalID", "docstring": "Return the CanonicalID from this XRDS document.\n\n @param iname: the XRI being resolved.\n @type iname: unicode\n\n @param xrd_tree: The XRDS output from the resolver.\n @type xrd_tree: ElementTree\n\n @returns: The XRI CanonicalID or None.\n @returntype: unicode or None" }, { "code": "def _build_ds_from_instruction(instruction, ds_from_file_fn):\n examples_ds = ds_from_file_fn(instruction[\"filepath\"])\n mask_ds = _build_mask_ds(\n mask_offset=instruction[\"mask_offset\"],\n mask=instruction[\"mask\"],\n )\n ds = tf.data.Dataset.zip((examples_ds, mask_ds))\n ds = ds.filter(lambda example, mask: mask)\n ds = ds.map(lambda example, mask: example)\n return ds", "docstring": "Map an instruction to a real datasets for one particular shard.\n\n Args:\n instruction: A `dict` of `tf.Tensor` containing the instruction to load\n the particular shard (filename, mask,...)\n ds_from_file_fn: `fct`, function which returns the dataset associated to\n the filename\n\n Returns:\n dataset: `tf.data.Dataset`, The shard loaded from the instruction" }, { "code": "def main():\n args = parse_arguments()\n pid = args.pid\n title = get_programme_title(pid)\n broadcast_date = get_broadcast_date(pid)\n listing = extract_listing(pid)\n filename = get_output_filename(args)\n tracklisting = generate_output(listing, title, broadcast_date)\n output_to_file(filename, tracklisting, args.action)\n print(\"Done!\")", "docstring": "Get a tracklisting, write to audio file or text." }, { "code": "def copy_file_links(self, src):\n if not self._initialized:\n raise pycdlibexception.PyCdlibInternalError('Rock Ridge extension not yet initialized')\n if src.dr_entries.px_record is None:\n if src.ce_entries.px_record is None:\n raise pycdlibexception.PyCdlibInvalidInput('No Rock Ridge file links')\n num_links = src.ce_entries.px_record.posix_file_links\n else:\n num_links = src.dr_entries.px_record.posix_file_links\n if self.dr_entries.px_record is None:\n if self.ce_entries.px_record is None:\n raise pycdlibexception.PyCdlibInvalidInput('No Rock Ridge file links')\n self.ce_entries.px_record.posix_file_links = num_links\n else:\n self.dr_entries.px_record.posix_file_links = num_links", "docstring": "Copy the number of file links from the source Rock Ridge entry into\n this Rock Ridge entry.\n\n Parameters:\n src - The source Rock Ridge entry to copy from.\n Returns:\n Nothing." }, { "code": "def __fill_buffer(self, size=0):\n read_size = min(max(size, self.__buffer_size), MAX_BLOB_FETCH_SIZE)\n self.__buffer = fetch_data(self.__blob_key, self.__position,\n self.__position + read_size - 1)\n self.__buffer_position = 0\n self.__eof = len(self.__buffer) < read_size", "docstring": "Fills the internal buffer.\n\n Args:\n size: Number of bytes to read. Will be clamped to\n [self.__buffer_size, MAX_BLOB_FETCH_SIZE]." }, { "code": "def _cast_to_type(self, value):\n if value in (True, False):\n return bool(value)\n if value in ('t', 'True', '1'):\n return True\n if value in ('f', 'False', '0'):\n return False\n self.fail('invalid', value=value)", "docstring": "Convert the value to a boolean and raise error on failures" }, { "code": "def _parse_config(self, requires_cfg=True):\n if len(self.config_paths) > 0:\n try:\n self._find_config()\n except BisonError:\n if not requires_cfg:\n return\n raise\n try:\n with open(self.config_file, 'r') as f:\n parsed = self._fmt_to_parser[self.config_format](f)\n except Exception as e:\n raise BisonError(\n 'Failed to parse config file: {}'.format(self.config_file)\n ) from e\n self._full_config = None\n self._config = parsed", "docstring": "Parse the configuration file, if one is configured, and add it to\n the `Bison` state.\n\n Args:\n requires_cfg (bool): Specify whether or not parsing should fail\n if a config file is not found. (default: True)" }, { "code": "def op_paths(self, path_prefix=None):\n url_path = self.path\n if path_prefix:\n url_path = path_prefix + url_path\n yield url_path, self", "docstring": "Yield operations paths stored in containers." }, { "code": "def BoolEncoder(field_number, is_repeated, is_packed):\n false_byte = b'\\x00'\n true_byte = b'\\x01'\n if is_packed:\n tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_LENGTH_DELIMITED)\n local_EncodeVarint = _EncodeVarint\n def EncodePackedField(write, value):\n write(tag_bytes)\n local_EncodeVarint(write, len(value))\n for element in value:\n if element:\n write(true_byte)\n else:\n write(false_byte)\n return EncodePackedField\n elif is_repeated:\n tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_VARINT)\n def EncodeRepeatedField(write, value):\n for element in value:\n write(tag_bytes)\n if element:\n write(true_byte)\n else:\n write(false_byte)\n return EncodeRepeatedField\n else:\n tag_bytes = TagBytes(field_number, wire_format.WIRETYPE_VARINT)\n def EncodeField(write, value):\n write(tag_bytes)\n if value:\n return write(true_byte)\n return write(false_byte)\n return EncodeField", "docstring": "Returns an encoder for a boolean field." }, { "code": "def get_python(self):\n if self.multiselect:\n return super(MultiSelectField, self).get_python()\n return self._get()", "docstring": "Only return cursor instance if configured for multiselect" }, { "code": "def update(self, sequence=None, **mapping):\n if sequence is not None:\n if isinstance(sequence, dict):\n for slot in sequence:\n self[slot] = sequence[slot]\n else:\n for slot, value in sequence:\n self[slot] = value\n if mapping:\n for slot in sequence:\n self[slot] = sequence[slot]", "docstring": "Add multiple elements to the fact." }, { "code": "def OnUpdateFigurePanel(self, event):\n if self.updating:\n return\n self.updating = True\n self.figure_panel.update(self.get_figure(self.code))\n self.updating = False", "docstring": "Redraw event handler for the figure panel" }, { "code": "def triplify(binding):\n triples = []\n if binding.data is None:\n return None, triples\n if binding.is_object:\n return triplify_object(binding)\n elif binding.is_array:\n for item in binding.items:\n _, item_triples = triplify(item)\n triples.extend(item_triples)\n return None, triples\n else:\n subject = binding.parent.subject\n triples.append((subject, binding.predicate, binding.object))\n if binding.reverse is not None:\n triples.append((binding.object, binding.reverse, subject))\n return subject, triples", "docstring": "Recursively generate RDF statement triples from the data and\n schema supplied to the application." }, { "code": "def plug(self):\n if self.__plugged:\n return\n for _, method in inspect.getmembers(self, predicate=inspect.ismethod):\n if hasattr(method, '_callback_messages'):\n for message in method._callback_messages:\n global_callbacks[message].add(method)\n self.__plugged = True", "docstring": "Add the actor's methods to the callback registry." }, { "code": "def validate_create_package(package_format, owner, repo, **kwargs):\n client = get_packages_api()\n with catch_raise_api_exception():\n check = getattr(\n client, \"packages_validate_upload_%s_with_http_info\" % package_format\n )\n _, _, headers = check(\n owner=owner, repo=repo, data=make_create_payload(**kwargs)\n )\n ratelimits.maybe_rate_limit(client, headers)\n return True", "docstring": "Validate parameters for creating a package." }, { "code": "def main(args):\n ui = getUI(args)\n if ui.optionIsSet(\"test\"):\n unittest.main(argv=[sys.argv[0]])\n elif ui.optionIsSet(\"help\"):\n ui.usage()\n else:\n verbose = ui.optionIsSet(\"verbose\")\n stranded = ui.optionIsSet(\"stranded\")\n if stranded:\n sys.stderr.write(\"Sorry, stranded mode hasn't been implemented yet.\")\n sys.exit()\n regions_1 = [e for e in BEDIterator(ui.getArgument(0), verbose=verbose)]\n regions_2 = [e for e in BEDIterator(ui.getArgument(1), verbose=verbose)]\n print jaccardIndex(regions_1, regions_2)", "docstring": "main entry point for the GenomicIntJaccard script.\n\n :param args: the arguments for this script, as a list of string. Should\n already have had things like the script name stripped. That\n is, if there are no args provided, this should be an empty\n list." }, { "code": "def get_assignable_objective_bank_ids(self, objective_bank_id):\n mgr = self._get_provider_manager('LEARNING', local=True)\n lookup_session = mgr.get_objective_bank_lookup_session(proxy=self._proxy)\n objective_banks = lookup_session.get_objective_banks()\n id_list = []\n for objective_bank in objective_banks:\n id_list.append(objective_bank.get_id())\n return IdList(id_list)", "docstring": "Gets a list of objective banks including and under the given objective bank node in which any objective can be assigned.\n\n arg: objective_bank_id (osid.id.Id): the ``Id`` of the\n ``ObjectiveBank``\n return: (osid.id.IdList) - list of assignable objective bank\n ``Ids``\n raise: NullArgument - ``objective_bank_id`` is ``null``\n raise: OperationFailed - unable to complete request\n *compliance: mandatory -- This method must be implemented.*" }, { "code": "def do_types_conflict(type1: GraphQLOutputType, type2: GraphQLOutputType) -> bool:\n if is_list_type(type1):\n return (\n do_types_conflict(\n cast(GraphQLList, type1).of_type, cast(GraphQLList, type2).of_type\n )\n if is_list_type(type2)\n else True\n )\n if is_list_type(type2):\n return True\n if is_non_null_type(type1):\n return (\n do_types_conflict(\n cast(GraphQLNonNull, type1).of_type, cast(GraphQLNonNull, type2).of_type\n )\n if is_non_null_type(type2)\n else True\n )\n if is_non_null_type(type2):\n return True\n if is_leaf_type(type1) or is_leaf_type(type2):\n return type1 is not type2\n return False", "docstring": "Check whether two types conflict\n\n Two types conflict if both types could not apply to a value simultaneously.\n Composite types are ignored as their individual field types will be compared later\n recursively. However List and Non-Null types must match." }, { "code": "def plan(self):\n\t\tfor invoiceitem in self.invoiceitems.all():\n\t\t\tif invoiceitem.plan:\n\t\t\t\treturn invoiceitem.plan\n\t\tif self.subscription:\n\t\t\treturn self.subscription.plan", "docstring": "Gets the associated plan for this invoice.\n\n\t\tIn order to provide a consistent view of invoices, the plan object\n\t\tshould be taken from the first invoice item that has one, rather than\n\t\tusing the plan associated with the subscription.\n\n\t\tSubscriptions (and their associated plan) are updated by the customer\n\t\tand represent what is current, but invoice items are immutable within\n\t\tthe invoice and stay static/unchanged.\n\n\t\tIn other words, a plan retrieved from an invoice item will represent\n\t\tthe plan as it was at the time an invoice was issued. The plan\n\t\tretrieved from the subscription will be the currently active plan.\n\n\t\t:returns: The associated plan for the invoice.\n\t\t:rtype: ``djstripe.Plan``" }, { "code": "def rotate_concurrent(self, *locations, **kw):\n timer = Timer()\n pool = CommandPool(concurrency=10)\n logger.info(\"Scanning %s ..\", pluralize(len(locations), \"backup location\"))\n for location in locations:\n for cmd in self.rotate_backups(location, prepare=True, **kw):\n pool.add(cmd)\n if pool.num_commands > 0:\n backups = pluralize(pool.num_commands, \"backup\")\n logger.info(\"Preparing to rotate %s (in parallel) ..\", backups)\n pool.run()\n logger.info(\"Successfully rotated %s in %s.\", backups, timer)", "docstring": "Rotate the backups in the given locations concurrently.\n\n :param locations: One or more values accepted by :func:`coerce_location()`.\n :param kw: Any keyword arguments are passed on to :func:`rotate_backups()`.\n\n This function uses :func:`rotate_backups()` to prepare rotation\n commands for the given locations and then it removes backups in\n parallel, one backup per mount point at a time.\n\n The idea behind this approach is that parallel rotation is most useful\n when the files to be removed are on different disks and so multiple\n devices can be utilized at the same time.\n\n Because mount points are per system :func:`rotate_concurrent()` will\n also parallelize over backups located on multiple remote systems." }, { "code": "def join(self):\n for thread in self.worker_threads:\n thread.join()\n WorkerThread.join(self)", "docstring": "Joins the coordinator thread and all worker threads." }, { "code": "def track(cls, obj, ptr):\n cls._objects.add(cls(obj, ptr))", "docstring": "Track an object which needs destruction when it is garbage collected." }, { "code": "def properties_for(self, index):\n return vectorize(lambda i: [prop for prop in self.properties() if i in self[prop]], otypes=[list])(index)", "docstring": "Returns a list of properties, such that each entry in the list corresponds\n to the element of the index given.\n\n Example:\n let properties: 'one':[1,2,3,4], 'two':[3,5,6]\n\n >>> properties_for([2,3,5])\n [['one'], ['one', 'two'], ['two']]" }, { "code": "def schedule(\n time: Union[datetime.time, datetime.datetime],\n callback: Callable, *args):\n dt = _fillDate(time)\n now = datetime.datetime.now(dt.tzinfo)\n delay = (dt - now).total_seconds()\n loop = asyncio.get_event_loop()\n loop.call_later(delay, callback, *args)", "docstring": "Schedule the callback to be run at the given time with\n the given arguments.\n\n Args:\n time: Time to run callback. If given as :py:class:`datetime.time`\n then use today as date.\n callback: Callable scheduled to run.\n args: Arguments for to call callback with." }, { "code": "def url_read(url, verbose=True):\n r\n if url.find('://') == -1:\n url = 'http://' + url\n if verbose:\n print('Reading data from url=%r' % (url,))\n try:\n file_ = _urllib.request.urlopen(url)\n except IOError:\n raise\n data = file_.read()\n file_.close()\n return data", "docstring": "r\"\"\"\n Directly reads data from url" }, { "code": "def remove_stale_sockets(self):\n if self.opts.max_idle_time_seconds is not None:\n with self.lock:\n while (self.sockets and\n self.sockets[-1].idle_time_seconds() > self.opts.max_idle_time_seconds):\n sock_info = self.sockets.pop()\n sock_info.close()\n while True:\n with self.lock:\n if (len(self.sockets) + self.active_sockets >=\n self.opts.min_pool_size):\n break\n if not self._socket_semaphore.acquire(False):\n break\n try:\n sock_info = self.connect()\n with self.lock:\n self.sockets.appendleft(sock_info)\n finally:\n self._socket_semaphore.release()", "docstring": "Removes stale sockets then adds new ones if pool is too small." }, { "code": "def reset(self):\r\n self._elapsed = datetime.timedelta()\r\n self._delta = datetime.timedelta()\r\n self._starttime = datetime.datetime.now()\r\n self.refresh()", "docstring": "Stops the timer and resets its values to 0." }, { "code": "def seek(self, offset, whence=os.SEEK_SET):\n pos = None\n if whence == os.SEEK_SET:\n pos = self.offset + offset\n elif whence == os.SEEK_CUR:\n pos = self.tell() + offset\n elif whence == os.SEEK_END:\n pos = self.offset + self.len + offset\n else:\n raise ValueError(\"invalid whence {}\".format(whence))\n if pos > self.offset + self.len or pos < self.offset:\n raise ValueError(\"seek position beyond chunk area\")\n self.parent_fd.seek(pos, os.SEEK_SET)", "docstring": "Seek to position in stream, see file.seek" }, { "code": "def javadoc_role(name, rawtext, text, lineno, inliner, options={}, content=[]):\n has_explicit_title, title, target = split_explicit_title(text)\n title = utils.unescape(title)\n target = utils.unescape(target)\n if not has_explicit_title:\n target = target.lstrip('~')\n if title[0] == '~':\n title = title[1:].rpartition('.')[2]\n app = inliner.document.settings.env.app\n ref = get_javadoc_ref(app, rawtext, target)\n if not ref:\n raise ValueError(\"no Javadoc source found for %s in javadoc_url_map\" % (target,))\n ref.append(nodes.Text(title, title))\n return [ref], []", "docstring": "Role for linking to external Javadoc" }, { "code": "def _get_graph(graph, filename):\n try:\n rendered = graph.rendered_file\n except AttributeError:\n try:\n graph.render(os.path.join(server.tmpdir, filename), format='png')\n rendered = filename\n except OSError:\n rendered = None\n graph.rendered_file = rendered\n return rendered", "docstring": "Retrieve or render a graph." }, { "code": "def read(self, size=None):\n if size is None or size < 0:\n raise exceptions.NotYetImplementedError(\n 'Illegal read of size %s requested on BufferedStream. '\n 'Wrapped stream %s is at position %s-%s, '\n '%s bytes remaining.' %\n (size, self.__stream, self.__start_pos, self.__end_pos,\n self._bytes_remaining))\n data = ''\n if self._bytes_remaining:\n size = min(size, self._bytes_remaining)\n data = self.__buffered_data[\n self.__buffer_pos:self.__buffer_pos + size]\n self.__buffer_pos += size\n return data", "docstring": "Reads from the buffer." }, { "code": "def get_file(self, filename):\n log.debug('[%s]: reading: //%s/%s', self.name, self.name, filename)\n try:\n blob = self.repo.head.commit.tree/filename\n return blob.data_stream\n except KeyError as err:\n raise GitError(err)", "docstring": "Get a file from the repo.\n\n Returns a file-like stream with the data." }, { "code": "def is_port_default(self):\n if self.scheme in RELATIVE_SCHEME_DEFAULT_PORTS:\n return RELATIVE_SCHEME_DEFAULT_PORTS[self.scheme] == self.port", "docstring": "Return whether the URL is using the default port." }, { "code": "def jsonload(model, fp):\n dumped_list = json.load(fp)\n for link in dumped_list:\n if len(link) == 2:\n sid, (s, p, o, a) = link\n elif len(link) == 4:\n (s, p, o, a) = link\n tt = a.get('@target-type')\n if tt == '@iri-ref':\n o = I(o)\n a.pop('@target-type', None)\n else:\n continue\n model.add(s, p, o, a)\n return", "docstring": "Load Versa model dumped into JSON form, either raw or canonical" }, { "code": "def policy_and_value_net(rng_key,\n batch_observations_shape,\n num_actions,\n bottom_layers=None):\n cur_layers = []\n if bottom_layers is not None:\n cur_layers.extend(bottom_layers)\n cur_layers.extend([layers.Branch(), layers.Parallel(\n layers.Serial(layers.Dense(num_actions), layers.LogSoftmax()),\n layers.Dense(1)\n )])\n net = layers.Serial(*cur_layers)\n return net.initialize(batch_observations_shape, rng_key), net", "docstring": "A policy and value net function." }, { "code": "def zlist(self, name_start, name_end, limit=10):\n limit = get_positive_integer('limit', limit)\n return self.execute_command('zlist', name_start, name_end, limit)", "docstring": "Return a list of the top ``limit`` zset's name between ``name_start`` and\n ``name_end`` in ascending order\n\n .. note:: The range is (``name_start``, ``name_end``]. The ``name_start``\n isn't in the range, but ``name_end`` is.\n\n :param string name_start: The lower bound(not included) of zset names to\n be returned, empty string ``''`` means -inf\n :param string name_end: The upper bound(included) of zset names to be\n returned, empty string ``''`` means +inf\n :param int limit: number of elements will be returned.\n :return: a list of zset's name\n :rtype: list\n \n >>> ssdb.zlist('zset_ ', 'zset_z', 10)\n ['zset_1', 'zset_2']\n >>> ssdb.zlist('zset_ ', '', 3)\n ['zset_1', 'zset_2']\n >>> ssdb.zlist('', 'aaa_not_exist', 10)\n []" }, { "code": "def GetLoggingLocation():\n frame = inspect.currentframe()\n this_file = frame.f_code.co_filename\n frame = frame.f_back\n while frame:\n if this_file == frame.f_code.co_filename:\n if 'cdbg_logging_location' in frame.f_locals:\n ret = frame.f_locals['cdbg_logging_location']\n if len(ret) != 3:\n return (None, None, None)\n return ret\n frame = frame.f_back\n return (None, None, None)", "docstring": "Search for and return the file and line number from the log collector.\n\n Returns:\n (pathname, lineno, func_name) The full path, line number, and function name\n for the logpoint location." }, { "code": "def subscribe_and_validate(self, topic, qos, payload, timeout=1):\n seconds = convert_time(timeout)\n self._verified = False\n logger.info('Subscribing to topic: %s' % topic)\n self._mqttc.subscribe(str(topic), int(qos))\n self._payload = str(payload)\n self._mqttc.on_message = self._on_message\n timer_start = time.time()\n while time.time() < timer_start + seconds:\n if self._verified:\n break\n self._mqttc.loop()\n if not self._verified:\n raise AssertionError(\"The expected payload didn't arrive in the topic\")", "docstring": "Subscribe to a topic and validate that the specified payload is\n received within timeout. It is required that a connection has been\n established using `Connect` keyword. The payload can be specified as\n a python regular expression. If the specified payload is not received\n within timeout, an AssertionError is thrown.\n\n `topic` topic to subscribe to\n\n `qos` quality of service for the subscription\n\n `payload` payload (message) that is expected to arrive\n\n `timeout` time to wait for the payload to arrive\n\n Examples:\n\n | Subscribe And Validate | test/test | 1 | test message |" }, { "code": "def validate_cmap(val):\n from matplotlib.colors import Colormap\n try:\n return validate_str(val)\n except ValueError:\n if not isinstance(val, Colormap):\n raise ValueError(\n \"Could not find a valid colormap!\")\n return val", "docstring": "Validate a colormap\n\n Parameters\n ----------\n val: str or :class:`mpl.colors.Colormap`\n\n Returns\n -------\n str or :class:`mpl.colors.Colormap`\n\n Raises\n ------\n ValueError" }, { "code": "def export_module_spec_with_checkpoint(module_spec,\n checkpoint_path,\n export_path,\n scope_prefix=\"\"):\n with tf.Graph().as_default():\n m = hub.Module(module_spec)\n assign_map = {\n scope_prefix + name: value for name, value in m.variable_map.items()\n }\n tf.train.init_from_checkpoint(checkpoint_path, assign_map)\n init_op = tf.initializers.global_variables()\n with tf.Session() as session:\n session.run(init_op)\n m.export(export_path, session)", "docstring": "Exports given checkpoint as tfhub module with given spec." }, { "code": "def integer(prompt=None, empty=False):\n s = _prompt_input(prompt)\n if empty and not s:\n return None\n else:\n try:\n return int(s)\n except ValueError:\n return integer(prompt=prompt, empty=empty)", "docstring": "Prompt an integer.\n\n Parameters\n ----------\n prompt : str, optional\n Use an alternative prompt.\n empty : bool, optional\n Allow an empty response.\n\n Returns\n -------\n int or None\n An int if the user entered a valid integer.\n None if the user pressed only Enter and ``empty`` was True." }, { "code": "def add_edge_fun(graph):\n succ, pred, node = graph._succ, graph._pred, graph._node\n def add_edge(u, v, **attr):\n if v not in succ:\n succ[v], pred[v], node[v] = {}, {}, {}\n succ[u][v] = pred[v][u] = attr\n return add_edge", "docstring": "Returns a function that adds an edge to the `graph` checking only the out\n node.\n\n :param graph:\n A directed graph.\n :type graph: networkx.classes.digraph.DiGraph\n\n :return:\n A function that adds an edge to the `graph`.\n :rtype: callable" }, { "code": "def wait_for(func):\n @wraps(func)\n def wrapped(*args, **kwargs):\n timeout = kwargs.pop('timeout', TIMEOUT)\n start = None\n while True:\n try:\n return func(*args, **kwargs)\n except AssertionError:\n if not start:\n start = time()\n if time() - start < timeout:\n sleep(CHECK_EVERY)\n continue\n else:\n raise\n return wrapped", "docstring": "A decorator to invoke a function, retrying on assertion errors for a\n specified time interval.\n\n Adds a kwarg `timeout` to `func` which is a number of seconds to try\n for (default 15)." }, { "code": "def _gcd_array(X):\n greatest_common_divisor = 0.0\n for x in X:\n greatest_common_divisor = _gcd(greatest_common_divisor, x)\n return greatest_common_divisor", "docstring": "Return the largest real value h such that all elements in x are integer\n multiples of h." }, { "code": "def print_update(self):\n print(\"\\r\\n\")\n now = datetime.datetime.now()\n print(\"Update info: (from: %s)\" % now.strftime(\"%c\"))\n current_total_size = self.total_stined_bytes + self.total_new_bytes\n if self.total_errored_items:\n print(\" * WARNING: %i omitted files!\" % self.total_errored_items)\n print(\" * fast backup: %i files\" % self.total_fast_backup)\n print(\n \" * new content saved: %i files (%s %.1f%%)\"\n % (\n self.total_new_file_count,\n human_filesize(self.total_new_bytes),\n to_percent(self.total_new_bytes, current_total_size),\n )\n )\n print(\n \" * stint space via hardlinks: %i files (%s %.1f%%)\"\n % (\n self.total_file_link_count,\n human_filesize(self.total_stined_bytes),\n to_percent(self.total_stined_bytes, current_total_size),\n )\n )\n duration = default_timer() - self.start_time\n performance = current_total_size / duration / 1024.0 / 1024.0\n print(\" * present performance: %.1fMB/s\\n\" % performance)", "docstring": "print some status information in between." }, { "code": "def filter_parts(cls, part_info):\n filtered = OrderedDict()\n for part_name, info_list in part_info.items():\n if info_list is None or isinstance(info_list, Exception):\n continue\n info_list = [i for i in info_list if isinstance(i, cls)]\n if info_list:\n filtered[part_name] = info_list\n return filtered", "docstring": "Filter the part_info dict looking for instances of our class\n\n Args:\n part_info (dict): {part_name: [Info] or None} as returned from\n Controller.run_hook()\n\n Returns:\n dict: {part_name: [info]} where info is a subclass of cls" }, { "code": "def inspect_hash(path):\n \" Calculate the hash of a database, efficiently. \"\n m = hashlib.sha256()\n with path.open(\"rb\") as fp:\n while True:\n data = fp.read(HASH_BLOCK_SIZE)\n if not data:\n break\n m.update(data)\n return m.hexdigest()", "docstring": "Calculate the hash of a database, efficiently." }, { "code": "def get_parent_element(self):\n return {AUDIT_REF_STATE: self.context.audit_record,\n SIGNATURE_REF_STATE: self.context.signature}[self.ref_state]", "docstring": "Signatures and Audit elements share sub-elements, we need to know which to set attributes on" }, { "code": "def chosen_view_factory(chooser_cls):\n class ChosenView(chooser_cls):\n def get(self, request, *args, **kwargs):\n self.object = self.get_object()\n return render_modal_workflow(\n self.request,\n None,\n '{0}/chosen.js'.format(self.template_dir),\n {'obj': self.get_json(self.object)}\n )\n def get_object(self, queryset=None):\n if queryset is None:\n queryset = self.get_queryset()\n pk = self.kwargs.get('pk', None)\n try:\n return queryset.get(pk=pk)\n except self.models.DoesNotExist:\n raise Http404()\n def post(self, request, *args, **kwargs):\n return self.get(request, *args, **kwargs)\n return ChosenView", "docstring": "Returns a ChosenView class that extends specified chooser class.\n\n :param chooser_cls: the class to extend.\n :rtype: class." }, { "code": "def get_l(self):\n cell_left = CellBorders(self.cell_attributes,\n *self.cell.get_left_key_rect())\n return cell_left.get_r()", "docstring": "Returns the left border of the cell" }, { "code": "def duplicates_removed(it, already_seen=()):\n lst = []\n seen = set()\n for i in it:\n if i in seen or i in already_seen:\n continue\n lst.append(i)\n seen.add(i)\n return lst", "docstring": "Returns a list with duplicates removed from the iterable `it`.\n\n Order is preserved." }, { "code": "def dtypes(self):\n return Series(np.array(list(self._gather_dtypes().values()), dtype=np.bytes_),\n self.keys())", "docstring": "Series of NumPy dtypes present in the DataFrame with index of column names.\n\n Returns\n -------\n Series" }, { "code": "def getDocPath(fn, root=None):\n cwd = pathlib.Path(os.getcwd())\n if root:\n cwd = pathlib.Path(root)\n while True:\n dpath = cwd.joinpath('docdata')\n if dpath.is_dir():\n break\n parent = cwd.parent\n if parent == cwd:\n raise ValueError(f'Unable to find data directory from {os.getcwd()}.')\n cwd = parent\n fpath = os.path.abspath(os.path.join(dpath.as_posix(), fn))\n if not fpath.startswith(dpath.as_posix()):\n raise ValueError(f'Path escaping detected: {fn}')\n if not os.path.isfile(fpath):\n raise ValueError(f'File does not exist: {fn}')\n return fpath", "docstring": "Helper for getting a documentation data file paths.\n\n Args:\n fn (str): Name of the file to retrieve the full path for.\n root (str): Optional root path to look for a docdata in.\n\n Notes:\n Defaults to looking for the ``docdata`` directory in the current\n working directory. This behavior works fine for notebooks nested\n in the docs directory of synapse; but this root directory that\n is looked for may be overridden by providing an alternative root.\n\n Returns:\n str: A file path.\n\n Raises:\n ValueError if the file does not exist or directory traversal attempted.." }, { "code": "async def download_file(self, Bucket, Key, Filename, ExtraArgs=None, Callback=None, Config=None):\n with open(Filename, 'wb') as open_file:\n await download_fileobj(self, Bucket, Key, open_file, ExtraArgs=ExtraArgs, Callback=Callback, Config=Config)", "docstring": "Download an S3 object to a file.\n\n Usage::\n\n import boto3\n s3 = boto3.resource('s3')\n s3.meta.client.download_file('mybucket', 'hello.txt', '/tmp/hello.txt')\n\n Similar behavior as S3Transfer's download_file() method,\n except that parameters are capitalized." }, { "code": "def load(stream, overrides=None, **kwargs):\n global is_initialized\n if not is_initialized:\n initialize()\n if isinstance(stream, basestring):\n string = stream\n else:\n string = '\\n'.join(stream.readlines())\n proxy_graph = yaml.load(string, **kwargs)\n from . import init\n init_dict = proxy_graph.get('init', {})\n init(**init_dict)\n if overrides is not None:\n handle_overrides(proxy_graph, overrides)\n return instantiate_all(proxy_graph)", "docstring": "Loads a YAML configuration from a string or file-like object.\n\n Parameters\n ----------\n stream : str or object\n Either a string containing valid YAML or a file-like object\n supporting the .read() interface.\n overrides : dict, optional\n A dictionary containing overrides to apply. The location of\n the override is specified in the key as a dot-delimited path\n to the desired parameter, e.g. \"model.corruptor.corruption_level\".\n\n Returns\n -------\n graph : dict or object\n The dictionary or object (if the top-level element specified an\n Python object to instantiate).\n\n Notes\n -----\n Other keyword arguments are passed on to `yaml.load`." }, { "code": "def update(self, title=None, body=None, state=None):\n data = {'title': title, 'body': body, 'state': state}\n json = None\n self._remove_none(data)\n if data:\n json = self._json(self._patch(self._api, data=dumps(data)), 200)\n if json:\n self._update_(json)\n return True\n return False", "docstring": "Update this pull request.\n\n :param str title: (optional), title of the pull\n :param str body: (optional), body of the pull request\n :param str state: (optional), ('open', 'closed')\n :returns: bool" }, { "code": "def _attachToObject(self, anchorObj, relationName) :\n\t\t\"Attaches the rabalist to a raba object. Only attached rabalists can be saved\"\n\t\tif self.anchorObj == None :\n\t\t\tself.relationName = relationName\n\t\t\tself.anchorObj = anchorObj\n\t\t\tself._setNamespaceConAndConf(anchorObj._rabaClass._raba_namespace)\n\t\t\tself.tableName = self.connection.makeRabaListTableName(self.anchorObj._rabaClass.__name__, self.relationName)\n\t\t\tfaultyElmt = self._checkSelf()\n\t\t\tif faultyElmt != None :\n\t\t\t\traise ValueError(\"Element %s violates specified list or relation constraints\" % faultyElmt)\n\t\telif self.anchorObj is not anchorObj :\n\t\t\traise ValueError(\"Ouch: attempt to steal rabalist, use RabaLict.copy() instead.\\nthief: %s\\nvictim: %s\\nlist: %s\" % (anchorObj, self.anchorObj, self))", "docstring": "Attaches the rabalist to a raba object. Only attached rabalists can be saved" }, { "code": "def generate_template(self, channeldir, filename, header):\n file_path = get_metadata_file_path(channeldir, filename)\n if not os.path.exists(file_path):\n with open(file_path, 'w') as csv_file:\n csvwriter = csv.DictWriter(csv_file, header)\n csvwriter.writeheader()", "docstring": "Create empty template .csv file called `filename` as siblings of the\n directory `channeldir` with header fields specified in `header`." }, { "code": "def doArc8(arcs, domains, assignments):\n check = dict.fromkeys(domains, True)\n while check:\n variable, _ = check.popitem()\n if variable not in arcs or variable in assignments:\n continue\n domain = domains[variable]\n arcsvariable = arcs[variable]\n for othervariable in arcsvariable:\n arcconstraints = arcsvariable[othervariable]\n if othervariable in assignments:\n otherdomain = [assignments[othervariable]]\n else:\n otherdomain = domains[othervariable]\n if domain:\n for value in domain[:]:\n assignments[variable] = value\n if otherdomain:\n for othervalue in otherdomain:\n assignments[othervariable] = othervalue\n for constraint, variables in arcconstraints:\n if not constraint(\n variables, domains, assignments, True\n ):\n break\n else:\n break\n else:\n domain.hideValue(value)\n del assignments[othervariable]\n del assignments[variable]\n if not domain:\n return False\n return True", "docstring": "Perform the ARC-8 arc checking algorithm and prune domains\n\n @attention: Currently unused." }, { "code": "def help_text(self, name, text, text_kind='plain', trim_pfx=0):\n if trim_pfx > 0:\n text = toolbox.trim_prefix(text, trim_pfx)\n if text_kind == 'rst':\n try:\n overrides = {'input_encoding': 'ascii',\n 'output_encoding': 'utf-8'}\n text_html = publish_string(text, writer_name='html',\n settings_overrides=overrides)\n text = text_html.decode('utf-8')\n text_kind = 'html'\n except Exception as e:\n self.logger.error(\"Error converting help text to HTML: %s\" % (\n str(e)))\n else:\n raise ValueError(\n \"I don't know how to display text of kind '%s'\" % (text_kind))\n if text_kind == 'html':\n self.help(text=text, text_kind='html')\n else:\n self.show_help_text(name, text)", "docstring": "Provide help text for the user.\n\n This method will convert the text as necessary with docutils and\n display it in the WBrowser plugin, if available. If the plugin is\n not available and the text is type 'rst' then the text will be\n displayed in a plain text widget.\n\n Parameters\n ----------\n name : str\n Category of help to show.\n\n text : str\n The text to show. Should be plain, HTML or RST text\n\n text_kind : str (optional)\n One of 'plain', 'html', 'rst'. Default is 'plain'.\n\n trim_pfx : int (optional)\n Number of spaces to trim off the beginning of each line of text." }, { "code": "def _process_image_file(fobj, session, filename):\n image = _decode_image(fobj, session, filename=filename)\n return _encode_jpeg(image)", "docstring": "Process image files from the dataset." }, { "code": "def copy(self, to_name):\n return self.reddit_session.copy_multireddit(self._author, self.name,\n to_name)", "docstring": "Copy this multireddit.\n\n Convenience function that utilizes\n :meth:`.MultiredditMixin.copy_multireddit` populating both\n the `from_redditor` and `from_name` parameters." }, { "code": "def intermediate_cpfs(self) -> List[CPF]:\n _, cpfs = self.cpfs\n interm_cpfs = [cpf for cpf in cpfs if cpf.name in self.intermediate_fluents]\n interm_cpfs = sorted(interm_cpfs, key=lambda cpf: (self.intermediate_fluents[cpf.name].level, cpf.name))\n return interm_cpfs", "docstring": "Returns list of intermediate-fluent CPFs in level order." }, { "code": "def create_from_tuple(cls, tube, the_tuple):\n if the_tuple is None:\n return\n if not the_tuple.rowcount:\n raise Queue.ZeroTupleException(\"Error creating task\")\n row = the_tuple[0]\n return cls(\n tube,\n task_id=row[0],\n state=row[1],\n data=row[2]\n )", "docstring": "Create task from tuple.\n\n Returns `Task` instance." }, { "code": "def augmentation_transform(self, data, label):\n for aug in self.auglist:\n data, label = aug(data, label)\n return (data, label)", "docstring": "Override Transforms input data with specified augmentations." }, { "code": "def run_command(self, command_name, config_updates=None,\n named_configs=(), args=(), meta_info=None):\n import warnings\n warnings.warn(\"run_command is deprecated. Use run instead\",\n DeprecationWarning)\n return self.run(command_name, config_updates, named_configs, meta_info,\n args)", "docstring": "Run the command with the given name.\n\n .. note:: Deprecated in Sacred 0.7\n run_command() will be removed in Sacred 1.0.\n It is replaced by run() which can now also handle command_names." }, { "code": "def system_update_column_family(self, cf_def):\n self._seqid += 1\n d = self._reqs[self._seqid] = defer.Deferred()\n self.send_system_update_column_family(cf_def)\n return d", "docstring": "updates properties of a column family. returns the new schema id.\n\n Parameters:\n - cf_def" }, { "code": "def add_ok_action(self, action_arn=None):\n if not action_arn:\n return\n self.actions_enabled = 'true'\n self.ok_actions.append(action_arn)", "docstring": "Adds an ok action, represented as an SNS topic, to this alarm. What\n to do when the ok state is reached.\n\n :type action_arn: str\n :param action_arn: SNS topics to which notification should be \n sent if the alarm goes to state INSUFFICIENT_DATA." }, { "code": "def create(cls, obj):\n self = cls.__new__(cls)\n self.__proto__ = obj\n return self", "docstring": "Create a new prototype object with the argument as the source\n prototype.\n\n .. Note:\n\n This does not `initialize` the newly created object any\n more than setting its prototype.\n Calling the __init__ method is usually unnecessary as all\n initialization data should be in the original prototype\n object already.\n\n If required, call __init__ explicitly:\n\n >>> proto_obj = MyProtoObj(1, 2, 3)\n >>> obj = MyProtoObj.create(proto_obj)\n >>> obj.__init__(1, 2, 3)" }, { "code": "def check_all_local(self):\n all_local_chk = self.event['global']['all_local'].isChecked()\n for buttons in self.event['local'].values():\n buttons[0].setChecked(all_local_chk)\n buttons[1].setEnabled(buttons[0].isChecked())", "docstring": "Check or uncheck all local event parameters." }, { "code": "def checkversion(doc,\n metadata,\n enable_dev\n):\n cdoc = None\n if isinstance(doc, CommentedSeq):\n if not isinstance(metadata, CommentedMap):\n raise Exception(\"Expected metadata to be CommentedMap\")\n lc = metadata.lc\n metadata = copy.deepcopy(metadata)\n metadata.lc.data = copy.copy(lc.data)\n metadata.lc.filename = lc.filename\n metadata[u\"$graph\"] = doc\n cdoc = metadata\n elif isinstance(doc, CommentedMap):\n cdoc = doc\n else:\n raise Exception(\"Expected CommentedMap or CommentedSeq\")\n version = metadata[u\"cwlVersion\"]\n cdoc[\"cwlVersion\"] = version\n if version not in UPDATES:\n if version in DEVUPDATES:\n if enable_dev:\n pass\n else:\n raise validate.ValidationException(\n u\"Version '%s' is a development or deprecated version.\\n \"\n \"Update your document to a stable version (%s) or use \"\n \"--enable-dev to enable support for development and \"\n \"deprecated versions.\" % (version, \", \".join(\n list(UPDATES.keys()))))\n else:\n raise validate.ValidationException(\n u\"Unrecognized version %s\" % version)\n return (cdoc, version)", "docstring": "Checks the validity of the version of the give CWL document.\n\n Returns the document and the validated version string." }, { "code": "def ensure_clean_git(operation='operation'):\n if os.system('git diff-index --quiet HEAD --'):\n print(\"Unstaged or uncommitted changes detected. {} aborted.\".format(\n operation.capitalize()))\n sys.exit()", "docstring": "Verify that git has no uncommitted changes" }, { "code": "def restore(self, request, *args, **kwargs):\n paths = request.path_info.split('/')\n object_id_index = paths.index(\"restore\") - 2\n object_id = paths[object_id_index]\n obj = super(VersionedAdmin, self).get_object(request, object_id)\n obj.restore()\n admin_wordIndex = object_id_index - 3\n path = \"/%s\" % (\"/\".join(paths[admin_wordIndex:object_id_index]))\n opts = self.model._meta\n msg_dict = {\n 'name': force_text(opts.verbose_name),\n 'obj': format_html('{}',\n urlquote(request.path), obj),\n }\n msg = format_html(_('The {name} \"{obj}\" was restored successfully.'),\n **msg_dict)\n self.message_user(request, msg, messages.SUCCESS)\n return HttpResponseRedirect(path)", "docstring": "View for restoring object from change view" }, { "code": "def clean(self):\n for f in self.catalog_names:\n if 'match' in f:\n if os.path.exists(self.catalog_names[f]):\n log.info('Deleting intermediate match file: %s'%\n self.catalog_names[f])\n os.remove(self.catalog_names[f])\n else:\n for extn in f:\n if os.path.exists(extn):\n log.info('Deleting intermediate catalog: %d'%extn)\n os.remove(extn)", "docstring": "Remove intermediate files created." }, { "code": "def write_generator_data(self, file):\n writer = self._get_writer(file)\n writer.writerow([\"bus\"] + GENERATOR_ATTRS)\n for g in self.case.generators:\n i = g.bus._i\n writer.writerow([i] + [getattr(g,a) for a in GENERATOR_ATTRS])", "docstring": "Write generator data as CSV." }, { "code": "def suspend(rq, ctx, duration):\n \"Suspends all workers.\"\n ctx.invoke(\n rq_cli.suspend,\n duration=duration,\n **shared_options(rq)\n )", "docstring": "Suspends all workers." }, { "code": "def fromstring(text, schema=None):\n if schema:\n parser = objectify.makeparser(schema = schema.schema)\n return objectify.fromstring(text, parser=parser)\n else:\n return objectify.fromstring(text)", "docstring": "Parses a KML text string\n \n This function parses a KML text string and optionally validates it against \n a provided schema object" }, { "code": "def flatten(nested):\n flat_return = list()\n def __inner_flat(nested,flat):\n for i in nested:\n __inner_flat(i, flat) if isinstance(i, list) else flat.append(i)\n return flat\n __inner_flat(nested,flat_return)\n return flat_return", "docstring": "Return a flatten version of the nested argument" }, { "code": "def _run_sync(self, method: Callable, *args, **kwargs) -> Any:\n if self.loop.is_running():\n raise RuntimeError(\"Event loop is already running.\")\n if not self.is_connected:\n self.loop.run_until_complete(self.connect())\n task = asyncio.Task(method(*args, **kwargs), loop=self.loop)\n result = self.loop.run_until_complete(task)\n self.loop.run_until_complete(self.quit())\n return result", "docstring": "Utility method to run commands synchronously for testing." }, { "code": "def deserialize(stream_or_string, **options):\n options.setdefault('Loader', Loader)\n try:\n return yaml.load(stream_or_string, **options)\n except ScannerError as error:\n log.exception('Error encountered while deserializing')\n err_type = ERROR_MAP.get(error.problem, 'Unknown yaml render error')\n line_num = error.problem_mark.line + 1\n raise DeserializationError(err_type,\n line_num,\n error.problem_mark.buffer)\n except ConstructorError as error:\n log.exception('Error encountered while deserializing')\n raise DeserializationError(error)\n except Exception as error:\n log.exception('Error encountered while deserializing')\n raise DeserializationError(error)", "docstring": "Deserialize any string of stream like object into a Python data structure.\n\n :param stream_or_string: stream or string to deserialize.\n :param options: options given to lower yaml module." }, { "code": "def get_desktop_for_window(self, window):\n desktop = ctypes.c_long(0)\n _libxdo.xdo_get_desktop_for_window(\n self._xdo, window, ctypes.byref(desktop))\n return desktop.value", "docstring": "Get the desktop a window is on.\n Uses _NET_WM_DESKTOP of the EWMH spec.\n\n If your desktop does not support ``_NET_WM_DESKTOP``, then '*desktop'\n remains unmodified.\n\n :param wid: the window to query" }, { "code": "def find_lib_directory(self):\n lib_directory = None\n if self.lib_micro_version in self.lib_directories:\n lib_directory = self.lib_micro_version\n elif self.lib_minor_version in self.lib_directories:\n lib_directory = self.lib_minor_version\n elif self.lib_major_version in self.lib_directories:\n lib_directory = self.lib_major_version\n else:\n for lv in [self.lib_micro_version, self.lib_minor_version, self.lib_major_version]:\n for d in self.lib_directories:\n if lv in d:\n lib_directory = d\n break\n else:\n continue\n break\n return lib_directory", "docstring": "Find the optimal lib directory." }, { "code": "def acquire(graftm_package_path):\n contents_hash = json.load(\n open(\n os.path.join(\n graftm_package_path,\n GraftMPackage._CONTENTS_FILE_NAME\n ),\n )\n )\n v=contents_hash[GraftMPackage.VERSION_KEY]\n logging.debug(\"Loading version %i GraftM package: %s\" % (v, graftm_package_path))\n if v == 2:\n pkg = GraftMPackageVersion2()\n elif v == 3:\n pkg = GraftMPackageVersion3()\n else:\n raise InsufficientGraftMPackageException(\"Bad version: %s\" % v)\n pkg._contents_hash = contents_hash\n pkg._base_directory = graftm_package_path\n pkg.check_universal_keys(v)\n pkg.check_required_keys(GraftMPackage._REQUIRED_KEYS[str(v)])\n return pkg", "docstring": "Acquire a new graftm Package\n\n Parameters\n ----------\n graftm_output_path: str\n path to base directory of graftm" }, { "code": "def GetCustomerIDs(client):\n managed_customer_service = client.GetService('ManagedCustomerService',\n version='v201809')\n offset = 0\n selector = {\n 'fields': ['CustomerId'],\n 'predicates': [{\n 'field': 'CanManageClients',\n 'operator': 'EQUALS',\n 'values': [False]\n }],\n 'paging': {\n 'startIndex': str(offset),\n 'numberResults': str(PAGE_SIZE)\n }\n }\n queue = multiprocessing.Queue()\n more_pages = True\n while more_pages:\n page = managed_customer_service.get(selector)\n if page and 'entries' in page and page['entries']:\n for entry in page['entries']:\n queue.put(entry['customerId'])\n else:\n raise Exception('Can\\'t retrieve any customer ID.')\n offset += PAGE_SIZE\n selector['paging']['startIndex'] = str(offset)\n more_pages = offset < int(page['totalNumEntries'])\n return queue", "docstring": "Retrieves all CustomerIds in the account hierarchy.\n\n Note that your configuration file must specify a client_customer_id belonging\n to an AdWords manager account.\n\n Args:\n client: an AdWordsClient instance.\n Raises:\n Exception: if no CustomerIds could be found.\n Returns:\n A Queue instance containing all CustomerIds in the account hierarchy." }, { "code": "def getargspec(func):\n if inspect.ismethod(func):\n func = func.__func__\n try:\n code = func.__code__\n except AttributeError:\n raise TypeError(\"{!r} is not a Python function\".format(func))\n if hasattr(code, \"co_kwonlyargcount\") and code.co_kwonlyargcount > 0:\n raise ValueError(\"keyword-only arguments are not supported by getargspec()\")\n args, varargs, varkw = inspect.getargs(code)\n return inspect.ArgSpec(args, varargs, varkw, func.__defaults__)", "docstring": "Variation of inspect.getargspec that works for more functions.\n\n This function works for Cythonized, non-cpdef functions, which expose argspec information but\n are not accepted by getargspec. It also works for Python 3 functions that use annotations, which\n are simply ignored. However, keyword-only arguments are not supported." }, { "code": "def add_user_to_group(iam_client, user, group, quiet = False):\n if not quiet:\n printInfo('Adding user to group %s...' % group)\n iam_client.add_user_to_group(GroupName = group, UserName = user)", "docstring": "Add an IAM user to an IAM group\n\n :param iam_client:\n :param group:\n :param user:\n :param user_info:\n :param dry_run:\n :return:" }, { "code": "def _run_mpi_cmd(self, cmd):\n log(\"Number of Processes: {0}\".format(self.num_processors))\n time_start = datetime.utcnow()\n cmd = [self.mpiexec_path, '-n', str(self.num_processors)] + cmd\n log(\"Command Line: {0}\".format(\" \".join(cmd)))\n process = Popen(cmd, stdout=PIPE, stderr=PIPE, shell=False)\n out, err = process.communicate()\n if out:\n log(\"OUTPUT:\")\n for line in out.split(b'\\n'):\n log(line)\n if err:\n log(err, severity=\"WARNING\")\n log(\"Time to complete: {0}\".format(datetime.utcnow()-time_start))", "docstring": "This runs the command you send in" }, { "code": "def namedb_get_num_names_in_namespace( cur, namespace_id, current_block ):\n unexpired_query, unexpired_args = namedb_select_where_unexpired_names( current_block )\n query = \"SELECT COUNT(name_records.name) FROM name_records JOIN namespaces ON name_records.namespace_id = namespaces.namespace_id WHERE name_records.namespace_id = ? AND \" + unexpired_query + \" ORDER BY name;\"\n args = (namespace_id,) + unexpired_args\n num_rows = namedb_select_count_rows( cur, query, args, count_column='COUNT(name_records.name)' )\n return num_rows", "docstring": "Get the number of names in a given namespace" }, { "code": "def search(self, query: 're.Pattern') -> 'Iterable[_WorkTitles]':\n titles: 'Titles'\n for titles in self._titles_list:\n title: 'AnimeTitle'\n for title in titles.titles:\n if query.search(title.title):\n yield WorkTitles(\n aid=titles.aid,\n main_title=_get_main_title(titles.titles),\n titles=[t.title for t in titles.titles],\n )\n continue", "docstring": "Search titles using a compiled RE query." }, { "code": "def match_conditions(self, filepath, sourcedir=None, nopartial=True,\n exclude_patterns=[], excluded_libdirs=[]):\n excluded_libdirs = [os.path.join(d, \"\") for d in excluded_libdirs]\n filename, ext = os.path.splitext(filepath)\n ext = ext[1:]\n if ext not in self.FINDER_STYLESHEET_EXTS:\n return False\n if nopartial and self.is_partial(filepath):\n return False\n if any(\n filepath.startswith(excluded_path)\n for excluded_path in paths_by_depth(excluded_libdirs)\n ):\n return False\n if sourcedir and exclude_patterns:\n candidates = [sourcedir]+excluded_libdirs\n relative_path = self.get_relative_from_paths(filepath, candidates)\n if not self.is_allowed(relative_path, excludes=exclude_patterns):\n return False\n return True", "docstring": "Find if a filepath match all required conditions.\n\n Available conditions are (in order):\n\n * Is allowed file extension;\n * Is a partial source;\n * Is from an excluded directory;\n * Is matching an exclude pattern;\n\n Args:\n filepath (str): Absolute filepath to match against conditions.\n\n Keyword Arguments:\n sourcedir (str or None): Absolute sources directory path. Can be\n ``None`` but then the exclude_patterns won't be matched against\n (because this method require to distinguish source dir from lib\n dirs).\n nopartial (bool): Accept partial sources if ``False``. Default is\n ``True`` (partial sources fail matchind condition). See\n ``Finder.is_partial()``.\n exclude_patterns (list): List of glob patterns, if filepath match\n one these pattern, it wont match conditions. See\n ``Finder.is_allowed()``.\n excluded_libdirs (list): A list of directory to match against\n filepath, if filepath starts with one them, it won't\n match condtions.\n\n Returns:\n bool: ``True`` if match all conditions, else ``False``." }, { "code": "def _tseitin(ex, auxvarname, auxvars=None):\n if isinstance(ex, Literal):\n return ex, list()\n else:\n if auxvars is None:\n auxvars = list()\n lits = list()\n constraints = list()\n for x in ex.xs:\n lit, subcons = _tseitin(x, auxvarname, auxvars)\n lits.append(lit)\n constraints.extend(subcons)\n auxvarindex = len(auxvars)\n auxvar = exprvar(auxvarname, auxvarindex)\n auxvars.append(auxvar)\n f = ASTOPS[ex.ASTOP](*lits)\n constraints.append((auxvar, f))\n return auxvar, constraints", "docstring": "Convert a factored expression to a literal, and a list of constraints." }, { "code": "def is_ancestor_of(self, other, include_self=False):\n return other.is_descendant_of(self, include_self=include_self)", "docstring": "Is this node an ancestor of `other`?" }, { "code": "def type_from_ast(schema, type_node):\n if isinstance(type_node, ListTypeNode):\n inner_type = type_from_ast(schema, type_node.type)\n return GraphQLList(inner_type) if inner_type else None\n if isinstance(type_node, NonNullTypeNode):\n inner_type = type_from_ast(schema, type_node.type)\n return GraphQLNonNull(inner_type) if inner_type else None\n if isinstance(type_node, NamedTypeNode):\n return schema.get_type(type_node.name.value)\n raise TypeError(\n f\"Unexpected type node: '{inspect(type_node)}'.\"\n )", "docstring": "Get the GraphQL type definition from an AST node.\n\n Given a Schema and an AST node describing a type, return a GraphQLType definition\n which applies to that type. For example, if provided the parsed AST node for\n `[User]`, a GraphQLList instance will be returned, containing the type called\n \"User\" found in the schema. If a type called \"User\" is not found in the schema,\n then None will be returned." }, { "code": "def get_available_positions(self):\n available_positions = [\"new\"]\n layout = self.context.getLayout()\n used_positions = [int(slot[\"position\"]) for slot in layout]\n if used_positions:\n used = [\n pos for pos in range(1, max(used_positions) + 1) if\n pos not in used_positions]\n available_positions.extend(used)\n return available_positions", "docstring": "Return a list of empty slot numbers" }, { "code": "def get_subdirectories(directory):\r\n return [name for name in os.listdir(directory)\r\n if name != '__pycache__'\r\n if os.path.isdir(os.path.join(directory, name))]", "docstring": "Get subdirectories without pycache" }, { "code": "def get_token(username, length=20, timeout=20):\n redis = get_redis_client()\n token = get_random_string(length)\n token_key = 'token:{}'.format(token)\n redis.set(token_key, username)\n redis.expire(token_key, timeout)\n return token", "docstring": "Obtain an access token that can be passed to a websocket client." }, { "code": "def generate_sibling_distance(self):\n sibling_distance = defaultdict(lambda: defaultdict(dict))\n topics = {p.topic for p in self.partitions}\n for source in self.brokers:\n for dest in self.brokers:\n if source != dest:\n for topic in topics:\n sibling_distance[dest][source][topic] = \\\n dest.count_partitions(topic) - \\\n source.count_partitions(topic)\n return sibling_distance", "docstring": "Generate a dict containing the distance computed as difference in\n in number of partitions of each topic from under_loaded_brokers\n to over_loaded_brokers.\n\n Negative distance means that the destination broker has got less\n partitions of a certain topic than the source broker.\n\n returns: dict {dest: {source: {topic: distance}}}" }, { "code": "def sync_user_email_addresses(user):\n from .models import EmailAddress\n email = user_email(user)\n if email and not EmailAddress.objects.filter(user=user,\n email__iexact=email).exists():\n if app_settings.UNIQUE_EMAIL \\\n and EmailAddress.objects.filter(email__iexact=email).exists():\n return\n EmailAddress.objects.create(user=user,\n email=email,\n primary=False,\n verified=False)", "docstring": "Keep user.email in sync with user.emailaddress_set.\n\n Under some circumstances the user.email may not have ended up as\n an EmailAddress record, e.g. in the case of manually created admin\n users." }, { "code": "def populate_host_templates(host_templates,\n hardware_ids=None,\n virtual_guest_ids=None,\n ip_address_ids=None,\n subnet_ids=None):\n if hardware_ids is not None:\n for hardware_id in hardware_ids:\n host_templates.append({\n 'objectType': 'SoftLayer_Hardware',\n 'id': hardware_id\n })\n if virtual_guest_ids is not None:\n for virtual_guest_id in virtual_guest_ids:\n host_templates.append({\n 'objectType': 'SoftLayer_Virtual_Guest',\n 'id': virtual_guest_id\n })\n if ip_address_ids is not None:\n for ip_address_id in ip_address_ids:\n host_templates.append({\n 'objectType': 'SoftLayer_Network_Subnet_IpAddress',\n 'id': ip_address_id\n })\n if subnet_ids is not None:\n for subnet_id in subnet_ids:\n host_templates.append({\n 'objectType': 'SoftLayer_Network_Subnet',\n 'id': subnet_id\n })", "docstring": "Populate the given host_templates array with the IDs provided\n\n :param host_templates: The array to which host templates will be added\n :param hardware_ids: A List of SoftLayer_Hardware ids\n :param virtual_guest_ids: A List of SoftLayer_Virtual_Guest ids\n :param ip_address_ids: A List of SoftLayer_Network_Subnet_IpAddress ids\n :param subnet_ids: A List of SoftLayer_Network_Subnet ids" }, { "code": "def send(tag, data=None):\n data = data or {}\n event = salt.utils.event.get_master_event(__opts__, __opts__['sock_dir'],\n listen=False)\n return event.fire_event(data, tag)", "docstring": "Send an event with the given tag and data.\n\n This is useful for sending events directly to the master from the shell\n with salt-run. It is also quite useful for sending events in orchestration\n states where the ``fire_event`` requisite isn't sufficient because it does\n not support sending custom data with the event.\n\n Note that event tags will *not* be namespaced like events sent with the\n ``fire_event`` requisite! Whereas events produced from ``fire_event`` are\n prefixed with ``salt/state_result///``, events sent\n using this runner module will have no such prefix. Make sure your reactors\n don't expect a prefix!\n\n :param tag: the tag to send with the event\n :param data: an optional dictionary of data to send with the event\n\n CLI Example:\n\n .. code-block:: bash\n\n salt-run event.send my/custom/event '{\"foo\": \"bar\"}'\n\n Orchestration Example:\n\n .. code-block:: yaml\n\n # orch/command.sls\n\n run_a_command:\n salt.function:\n - name: cmd.run\n - tgt: my_minion\n - arg:\n - exit {{ pillar['exit_code'] }}\n\n send_success_event:\n salt.runner:\n - name: event.send\n - tag: my_event/success\n - data:\n foo: bar\n - require:\n - salt: run_a_command\n\n send_failure_event:\n salt.runner:\n - name: event.send\n - tag: my_event/failure\n - data:\n baz: qux\n - onfail:\n - salt: run_a_command\n\n .. code-block:: bash\n\n salt-run state.orchestrate orch.command pillar='{\"exit_code\": 0}'\n salt-run state.orchestrate orch.command pillar='{\"exit_code\": 1}'" }, { "code": "def _handle_userCount(self, data):\n self.room.user_count = data\n self.conn.enqueue_data(\"user_count\", self.room.user_count)", "docstring": "Handle user count changes" }, { "code": "def empty( self, node ):\n overall = self.overall( node )\n if overall:\n return (overall - self.children_sum( self.children(node), node))/float(overall)\n return 0", "docstring": "Calculate empty space as a fraction of total space" }, { "code": "def QueueResponse(self, response, timestamp=None):\n if timestamp is None:\n timestamp = self.frozen_timestamp\n self.response_queue.append((response, timestamp))", "docstring": "Queues the message on the flow's state." }, { "code": "def clean():\n for queue in MyQueue.collection().instances():\n queue.delete()\n for job in MyJob.collection().instances():\n job.delete()\n for person in Person.collection().instances():\n person.delete()", "docstring": "Clean data created by this script" }, { "code": "def split(self, tValues):\n if self.segmentType == \"curve\":\n on1 = self.previousOnCurve\n off1 = self.points[0].coordinates\n off2 = self.points[1].coordinates\n on2 = self.points[2].coordinates\n return bezierTools.splitCubicAtT(on1, off1, off2, on2, *tValues)\n elif self.segmentType == \"line\":\n segments = []\n x1, y1 = self.previousOnCurve\n x2, y2 = self.points[0].coordinates\n dx = x2 - x1\n dy = y2 - y1\n pp = x1, y1\n for t in tValues:\n np = (x1+dx*t, y1+dy*t)\n segments.append([pp, np])\n pp = np\n segments.append([pp, (x2, y2)])\n return segments\n elif self.segmentType == \"qcurve\":\n raise NotImplementedError\n else:\n raise NotImplementedError", "docstring": "Split the segment according the t values" }, { "code": "def from_credentials(credentials, loop: asyncio.AbstractEventLoop=asyncio.get_event_loop()):\n return API(username=credentials.username, password=credentials.password,\n database=credentials.database, session_id=credentials.session_id,\n server=credentials.server, loop=loop)", "docstring": "Returns a new async API object from an existing Credentials object.\n\n :param credentials: The existing saved credentials.\n :param loop: The asyncio loop.\n :return: A new API object populated with MyGeotab credentials." }, { "code": "def is_absolute_path (path):\n if os.name == 'nt':\n if re.search(r\"^[a-zA-Z]:\", path):\n return True\n path = path.replace(\"\\\\\", \"/\")\n return path.startswith(\"/\")", "docstring": "Check if given path is absolute. On Windows absolute paths start\n with a drive letter. On all other systems absolute paths start with\n a slash." }, { "code": "def has_nvme_ssd(self):\n for member in self._drives_list():\n if (member.media_type == constants.MEDIA_TYPE_SSD and\n member.protocol == constants.PROTOCOL_NVMe):\n return True\n return False", "docstring": "Return True if the drive is SSD and protocol is NVMe" }, { "code": "def remove(self, class_name, name):\n if class_name not in self.components:\n logger.error(\"Component class {} not found\".format(class_name))\n return None\n cls_df = self.df(class_name)\n cls_df.drop(name, inplace=True)\n pnl = self.pnl(class_name)\n for df in itervalues(pnl):\n if name in df:\n df.drop(name, axis=1, inplace=True)", "docstring": "Removes a single component from the network.\n\n Removes it from component DataFrames.\n\n Parameters\n ----------\n class_name : string\n Component class name\n name : string\n Component name\n\n Examples\n --------\n >>> network.remove(\"Line\",\"my_line 12345\")" }, { "code": "def delete_jdbc_connection_pool(name, target='server', cascade=False, server=None):\n data = {'target': target, 'cascade': cascade}\n return _delete_element(name, 'resources/jdbc-connection-pool', data, server)", "docstring": "Delete a JDBC pool" }, { "code": "def replaceWith(self, el):\n self.childs = el.childs\n self.params = el.params\n self.endtag = el.endtag\n self.openertag = el.openertag\n self._tagname = el.getTagName()\n self._element = el.tagToString()\n self._istag = el.isTag()\n self._isendtag = el.isEndTag()\n self._iscomment = el.isComment()\n self._isnonpairtag = el.isNonPairTag()", "docstring": "Replace value in this element with values from `el`.\n\n This useful when you don't want change all references to object.\n\n Args:\n el (obj): :class:`HTMLElement` instance." }, { "code": "def find(self, path):\n path = path.split('.')\n node = self\n while node._parent:\n node = node._parent\n for name in path:\n node = node._tree.get(name, None)\n if node is None or type(node) is float:\n return None\n return node", "docstring": "Return the node for a path, or None." }, { "code": "def split_scoped_hparams(scopes, merged_hparams):\n split_values = {scope: {} for scope in scopes}\n merged_values = merged_hparams.values()\n for scoped_key, value in six.iteritems(merged_values):\n scope = scoped_key.split(\".\")[0]\n key = scoped_key[len(scope) + 1:]\n split_values[scope][key] = value\n return [\n hparam.HParams(**split_values[scope]) for scope in scopes\n ]", "docstring": "Split single HParams with scoped keys into multiple." }, { "code": "def copy(self):\n return Retry(max_tries=self.max_tries, delay=self.delay, backoff=self.backoff,\n max_jitter=self.max_jitter / 100.0, max_delay=self.max_delay, sleep_func=self.sleep_func,\n deadline=self.deadline, retry_exceptions=self.retry_exceptions)", "docstring": "Return a clone of this retry manager" }, { "code": "def get_function_source(ft, **kwargs)->str:\n \"Returns link to `ft` in source code.\"\n try: line = inspect.getsourcelines(ft)[1]\n except Exception: return ''\n mod_path = get_module_name(ft).replace('.', '/') + '.py'\n return get_source_link(mod_path, line, **kwargs)", "docstring": "Returns link to `ft` in source code." }, { "code": "def export_as_json(self):\n return {\n \"items\": {\n str(jid): item.export_as_json()\n for jid, item in self.items.items()\n },\n \"ver\": self.version\n }", "docstring": "Export the whole roster as currently stored on the client side into a\n JSON-compatible dictionary and return that dictionary." }, { "code": "def avail_images(call=None):\n if call == 'action':\n raise SaltCloudException(\n 'The avail_images function must be called with -f or --function.'\n )\n response = _query('avail', 'distributions')\n ret = {}\n for item in response['DATA']:\n name = item['LABEL']\n ret[name] = item\n return ret", "docstring": "Return available Linode images.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt-cloud --list-images my-linode-config\n salt-cloud -f avail_images my-linode-config" }, { "code": "def apply(self, styler):\n return styler.format(self.formatter, *self.args, **self.kwargs)", "docstring": "Apply Summary over Pandas Styler" }, { "code": "def main(argv=None):\n arguments = cli_common(__doc__, argv=argv)\n campaign_file = arguments['CAMPAIGN_FILE']\n if arguments['-g']:\n if osp.exists(campaign_file):\n raise Exception('Campaign file already exists')\n with open(campaign_file, 'w') as ostr:\n Generator().write(ostr)\n else:\n node = arguments.get('-n')\n output_dir = arguments.get('--output-dir')\n exclude_nodes = arguments.get('--exclude-nodes')\n srun_tag = arguments.get('--srun')\n driver = CampaignDriver(\n campaign_file,\n node=node,\n output_dir=output_dir,\n srun=srun_tag,\n exclude_nodes=exclude_nodes,\n )\n driver()\n if argv is not None:\n return driver\n campaign_fd = int(arguments.get('--campaign-path-fd') or 1)\n message = (osp.abspath(driver.campaign_path) + '\\n').encode()\n os.write(campaign_fd, message)", "docstring": "ben-sh entry point" }, { "code": "def main():\n parser = create_parser()\n options = vars(parser.parse_args())\n HASH_STORE.IGNORE_CACHE_FILE = options[constants.LABEL_FORCE]\n moban_file = options[constants.LABEL_MOBANFILE]\n load_engine_factory_and_engines()\n if moban_file is None:\n moban_file = mobanfile.find_default_moban_file()\n if moban_file:\n try:\n count = handle_moban_file(moban_file, options)\n moban_exit(options[constants.LABEL_EXIT_CODE], count)\n except (\n exceptions.DirectoryNotFound,\n exceptions.NoThirdPartyEngine,\n exceptions.MobanfileGrammarException,\n ) as e:\n reporter.report_error_message(str(e))\n moban_exit(options[constants.LABEL_EXIT_CODE], constants.ERROR)\n else:\n try:\n count = handle_command_line(options)\n moban_exit(options[constants.LABEL_EXIT_CODE], count)\n except exceptions.NoTemplate as e:\n reporter.report_error_message(str(e))\n moban_exit(options[constants.LABEL_EXIT_CODE], constants.ERROR)", "docstring": "program entry point" }, { "code": "def merge_noun_chunks(doc):\n if not doc.is_parsed:\n return doc\n with doc.retokenize() as retokenizer:\n for np in doc.noun_chunks:\n attrs = {\"tag\": np.root.tag, \"dep\": np.root.dep}\n retokenizer.merge(np, attrs=attrs)\n return doc", "docstring": "Merge noun chunks into a single token.\n\n doc (Doc): The Doc object.\n RETURNS (Doc): The Doc object with merged noun chunks.\n\n DOCS: https://spacy.io/api/pipeline-functions#merge_noun_chunks" }, { "code": "def _get_supercell_size(self, s1, s2):\n if self._supercell_size == 'num_sites':\n fu = s2.num_sites / s1.num_sites\n elif self._supercell_size == 'num_atoms':\n fu = s2.composition.num_atoms / s1.composition.num_atoms\n elif self._supercell_size == 'volume':\n fu = s2.volume / s1.volume\n else:\n try:\n el = get_el_sp(self._supercell_size)\n fu = s2.composition[el] / s1.composition[el]\n except:\n raise ValueError('Invalid argument for supercell_size.')\n if fu < 2/3:\n return int(round(1/fu)), False\n else:\n return int(round(fu)), True", "docstring": "Returns the supercell size, and whether the supercell should\n be applied to s1. If fu == 1, s1_supercell is returned as\n true, to avoid ambiguity." }, { "code": "def __need_ssl(self, host_and_port=None):\n if not host_and_port:\n host_and_port = self.current_host_and_port\n return host_and_port in self.__ssl_params", "docstring": "Whether current host needs SSL or not.\n\n :param (str,int) host_and_port: the host/port pair to check, default current_host_and_port" }, { "code": "def copy(self):\n new_client = self._client.copy()\n return self.__class__(\n self.instance_id,\n new_client,\n self.configuration_name,\n node_count=self.node_count,\n display_name=self.display_name,\n )", "docstring": "Make a copy of this instance.\n\n Copies the local data stored as simple types and copies the client\n attached to this instance.\n\n :rtype: :class:`~google.cloud.spanner_v1.instance.Instance`\n :returns: A copy of the current instance." }, { "code": "def logout(self):\n if not self.logged_in:\n raise RuntimeError(\"User is not logged in\")\n if self.conn.connected:\n params = {\"room\": self.conn.room.room_id}\n resp = self.conn.make_api_call(\"logout\", params)\n if not resp.get(\"success\", False):\n raise RuntimeError(\n f\"Logout unsuccessful: \"\n f\"{resp['error'].get('message') or resp['error']}\"\n )\n self.conn.make_call(\"logout\", params)\n self.conn.cookies.pop(\"session\")\n self.logged_in = False", "docstring": "Logs your user out" }, { "code": "def acquire_write(self):\n self.monitor.acquire()\n while self.rwlock != 0:\n self.writers_waiting += 1\n self.writers_ok.wait()\n self.writers_waiting -= 1\n self.rwlock = -1\n self.monitor.release()", "docstring": "Acquire a write lock. Only one thread can hold this lock, and\n only when no read locks are also held." }, { "code": "def AddAdGroup(self, client_customer_id, campaign_id, name, status):\n self.client.SetClientCustomerId(client_customer_id)\n ad_group_service = self.client.GetService('AdGroupService')\n operations = [{\n 'operator': 'ADD',\n 'operand': {\n 'campaignId': campaign_id,\n 'name': name,\n 'status': status\n }\n }]\n ad_group_service.mutate(operations)", "docstring": "Create a new ad group.\n\n Args:\n client_customer_id: str Client Customer Id used to create the AdGroup.\n campaign_id: str Id of the campaign to use.\n name: str Name to assign to the AdGroup.\n status: str Status to assign to the AdGroup when it is created." }, { "code": "def set_install_id(filename, install_id):\n if get_install_id(filename) is None:\n raise InstallNameError('{0} has no install id'.format(filename))\n back_tick(['install_name_tool', '-id', install_id, filename])", "docstring": "Set install id for library named in `filename`\n\n Parameters\n ----------\n filename : str\n filename of library\n install_id : str\n install id for library `filename`\n\n Raises\n ------\n RuntimeError if `filename` has not install id" }, { "code": "def show_service_profile(self, flavor_profile, **_params):\n return self.get(self.service_profile_path % (flavor_profile),\n params=_params)", "docstring": "Fetches information for a certain Neutron service flavor profile." }, { "code": "def make_logger(scraper):\n logger = logging.getLogger('')\n logger.setLevel(logging.DEBUG)\n requests_log = logging.getLogger(\"requests\")\n requests_log.setLevel(logging.WARNING)\n json_handler = logging.FileHandler(log_path(scraper))\n json_handler.setLevel(logging.DEBUG)\n json_formatter = jsonlogger.JsonFormatter(make_json_format())\n json_handler.setFormatter(json_formatter)\n logger.addHandler(json_handler)\n console_handler = logging.StreamHandler()\n console_handler.setLevel(logging.INFO)\n fmt = '%(name)s [%(levelname)-8s]: %(message)s'\n formatter = logging.Formatter(fmt)\n console_handler.setFormatter(formatter)\n logger.addHandler(console_handler)\n logger = logging.getLogger(scraper.name)\n logger = TaskAdapter(logger, scraper)\n return logger", "docstring": "Create two log handlers, one to output info-level ouput to the\n console, the other to store all logging in a JSON file which will\n later be used to generate reports." }, { "code": "def send_mail_worker(config, mail, event):\n log = \"\"\n try:\n if config.mail_ssl:\n server = SMTP_SSL(config.mail_server, port=config.mail_server_port, timeout=30)\n else:\n server = SMTP(config.mail_server, port=config.mail_server_port, timeout=30)\n if config.mail_tls:\n log += 'Starting TLS\\n'\n server.starttls()\n if config.mail_username != '':\n log += 'Logging in with ' + str(config.mail_username) + \"\\n\"\n server.login(config.mail_username, config.mail_password)\n else:\n log += 'No username, trying anonymous access\\n'\n log += 'Sending Mail\\n'\n response_send = server.send_message(mail)\n server.quit()\n except timeout as e:\n log += 'Could not send email to enrollee, mailserver timeout: ' + str(e) + \"\\n\"\n return False, log, event\n log += 'Server response:' + str(response_send)\n return True, log, event", "docstring": "Worker task to send out an email, which blocks the process unless it is threaded" }, { "code": "def set_visible_func(self, visible_func):\n self.model_filter.set_visible_func(\n self._internal_visible_func,\n visible_func,\n )\n self._visible_func = visible_func\n self.model_filter.refilter()", "docstring": "Set the function to decide visibility of an item\n\n :param visible_func: A callable that returns a boolean result to\n decide if an item should be visible, for\n example::\n\n def is_visible(item):\n return True" }, { "code": "def touch():\n from .models import Bucket\n bucket = Bucket.create()\n db.session.commit()\n click.secho(str(bucket), fg='green')", "docstring": "Create new bucket." }, { "code": "def on_sighup(self, signal_unused, frame_unused):\n for setting in self.http_config:\n if getattr(self.http_server, setting) != self.http_config[setting]:\n LOGGER.debug('Changing HTTPServer %s setting', setting)\n setattr(self.http_server, setting, self.http_config[setting])\n for setting in self.settings:\n if self.app.settings[setting] != self.settings[setting]:\n LOGGER.debug('Changing Application %s setting', setting)\n self.app.settings[setting] = self.settings[setting]\n self.app.handlers = []\n self.app.named_handlers = {}\n routes = self.namespace.config.get(config.ROUTES)\n self.app.add_handlers(\".*$\", self.app.prepare_routes(routes))\n LOGGER.info('Configuration reloaded')", "docstring": "Reload the configuration\n\n :param int signal_unused: Unused signal number\n :param frame frame_unused: Unused frame the signal was caught in" }, { "code": "def setValues(self, values):\n ncols = self.getNumCols()\n nindices = self.getNumIndices()\n for key, value in values.items():\n key = Utils.convToList(key)\n assert len(key) == nindices\n value = Utils.convToList(value)\n assert len(value) == ncols-nindices\n self.addRow(key + value)", "docstring": "Set the values of a DataFrame from a dictionary.\n\n Args:\n values: Dictionary with the values to set." }, { "code": "def compare_version(self, version_string, op):\n from pkg_resources import parse_version\n from monty.operator import operator_from_str\n op = operator_from_str(op)\n return op(parse_version(self.version), parse_version(version_string))", "docstring": "Compare Abinit version to `version_string` with operator `op`" }, { "code": "def get_view(self, view_name):\n return self.measure_to_view_map.get_view(view_name=view_name,\n timestamp=self.time)", "docstring": "gets the view given the view name" }, { "code": "def obj_update_or_create(model, defaults=None, update_fields=UNSET, **kwargs):\n obj, created = model.objects.get_or_create(defaults=defaults, **kwargs)\n if created:\n logger.debug('CREATED %s %s',\n model._meta.object_name,\n obj.pk,\n extra={'pk': obj.pk})\n else:\n obj_update(obj, defaults, update_fields=update_fields)\n return obj, created", "docstring": "Mimic queryset.update_or_create but using obj_update." }, { "code": "def get_rna(self) -> Rna:\n if self.variants:\n raise InferCentralDogmaException('can not get rna for variant')\n return Rna(\n namespace=self.namespace,\n name=self.name,\n identifier=self.identifier\n )", "docstring": "Get the corresponding RNA or raise an exception if it's not the reference node.\n\n :raises: InferCentralDogmaException" }, { "code": "def write(self, outfname=None):\n outfname = outfname or self.filename\n with codecs.open(outfname, 'wb', 'windows-1252') as outf:\n for survey in self.surveys:\n outf.write('\\r\\n'.join(survey._serialize()))\n outf.write('\\r\\n'+'\\f'+'\\r\\n')\n outf.write('\\x1A')", "docstring": "Write or overwrite a `Survey` to the specified .DAT file" }, { "code": "def _gather_field_values(\n\titem, *, fields=None, field_map=FIELD_MAP,\n\tnormalize_values=False, normalize_func=normalize_value):\n\tit = get_item_tags(item)\n\tif fields is None:\n\t\tfields = list(it.keys())\n\tnormalize = normalize_func if normalize_values else lambda x: str(x)\n\tfield_values = []\n\tfor field in fields:\n\t\tfield_values.append(\n\t\t\tnormalize(\n\t\t\t\tlist_to_single_value(\n\t\t\t\t\tget_field(it, field, field_map=field_map)\n\t\t\t\t)\n\t\t\t)\n\t\t)\n\treturn tuple(field_values)", "docstring": "Create a tuple of normalized metadata field values.\n\n\tParameter:\n\t\titem (~collections.abc.Mapping, str, os.PathLike): Item dict or filepath.\n\t\tfields (list): A list of fields used to compare item dicts.\n\t\tfield_map (~collections.abc.Mapping): A mapping field name aliases.\n\t\t\tDefault: :data:`~google_music_utils.constants.FIELD_MAP`\n\t\tnormalize_values (bool): Normalize metadata values to remove common differences between sources.\n\t\t\tDefault: ``False``\n\t\tnormalize_func (function): Function to apply to metadata values if\n\t\t\t``normalize_values`` is ``True``.\n\t\t\tDefault: :func:`~google_music_utils.utils.normalize_value`\n\n\tReturns:\n\t\ttuple: Values from the given metadata fields." }, { "code": "def attachment_state(self):\n state = None\n if self.attach_data:\n state = self.attach_data.status\n return state", "docstring": "Get the attachment state." }, { "code": "def load_files(self, path):\n if self.verbose == 2:\n print(\"Indexing {}\".format(path))\n for filename in os.listdir(path):\n file_path = path + \"/\" + filename\n if os.path.isdir(file_path):\n self.load_files(file_path)\n elif filename.endswith(\".yaml\") or filename.endswith(\".yml\"):\n self.unfold_yaml(file_path)", "docstring": "Loads files in a given path and all its subdirectories" }, { "code": "def read_version():\n regex = re.compile('^(?P\\d.*?) .*$')\n with open('../CHANGELOG.rst') as f:\n for line in f:\n match = regex.match(line)\n if match:\n return match.group('number')", "docstring": "Read version from the first line starting with digit" }, { "code": "def get_value(self, tag=None, field=None):\n assert not (tag is not None and field is not None), \\\n \"Cannot filter by tag and field simultaneously.\"\n selected_fields = self._select_by_field_or_tag(tag, field)\n missing_fields_idents = set(selected_fields) - set(self.field_values)\n if missing_fields_idents:\n raise ValueError(\n \"Cannot generate value with undefined fields {}.\".format(\n \", \".join(\"'{}'\".format(f)\n for f in missing_fields_idents)))\n value = 0\n for identifier, field in iteritems(selected_fields):\n if field.length is None or field.start_at is None:\n raise ValueError(\n \"Field '{}' does not have a fixed size/position.\".format(\n identifier))\n value |= (self.field_values[identifier] <<\n field.start_at)\n return value", "docstring": "Generate an integer whose bits are set according to the values of\n fields in this bit field. All other bits are set to zero.\n\n Parameters\n ----------\n tag : str\n Optionally specifies that the value should only include fields with\n the specified tag.\n field : str\n Optionally specifies that the value should only include the\n specified field.\n\n Raises\n ------\n ValueError\n If a field's value, length or position has not been defined. (e.g.\n :py:meth:`.assign_fields` has not been called).\n UnknownTagError\n If the tag specified using the `tag` argument does not exist.\n UnavailableFieldError\n If the field specified using the `field` argument does not exist or\n is not available." }, { "code": "def get_contents_to_filename(self, filename, headers=None,\n cb=None, num_cb=10,\n torrent=False,\n version_id=None,\n res_download_handler=None,\n response_headers=None, callback=None):\n fp = open(filename, 'wb')\n def got_contents_to_filename(response):\n fp.close()\n if self.last_modified != None:\n try:\n modified_tuple = rfc822.parsedate_tz(self.last_modified)\n modified_stamp = int(rfc822.mktime_tz(modified_tuple))\n os.utime(fp.name, (modified_stamp, modified_stamp))\n except Exception: pass\n if callable(callback):\n callback(response)\n self.get_contents_to_file(fp, headers, cb, num_cb, torrent=torrent,\n version_id=version_id,\n res_download_handler=res_download_handler,\n response_headers=response_headers, callback=got_contents_to_filename)", "docstring": "Retrieve an object from S3 using the name of the Key object as the\n key in S3. Store contents of the object to a file named by 'filename'.\n See get_contents_to_file method for details about the\n parameters.\n\n :type filename: string\n :param filename: The filename of where to put the file contents\n\n :type headers: dict\n :param headers: Any additional headers to send in the request\n\n :type cb: function\n :param cb: a callback function that will be called to report\n progress on the upload. The callback should accept\n two integer parameters, the first representing the\n number of bytes that have been successfully\n transmitted to S3 and the second representing the\n size of the to be transmitted object.\n\n :type cb: int\n :param num_cb: (optional) If a callback is specified with\n the cb parameter this parameter determines the\n granularity of the callback by defining\n the maximum number of times the callback will\n be called during the file transfer.\n\n :type torrent: bool\n :param torrent: If True, returns the contents of a torrent file\n as a string.\n\n :type res_upload_handler: ResumableDownloadHandler\n :param res_download_handler: If provided, this handler will\n perform the download.\n\n :type response_headers: dict\n :param response_headers: A dictionary containing HTTP headers/values\n that will override any headers associated with\n the stored object in the response.\n See http://goo.gl/EWOPb for details." }, { "code": "def datetime_to_timestamp(dt):\n epoch = datetime.utcfromtimestamp(0).replace(tzinfo=UTC)\n return (dt - epoch).total_seconds()", "docstring": "Convert timezone-aware `datetime` to POSIX timestamp and\n return seconds since UNIX epoch.\n\n Note: similar to `datetime.timestamp()` in Python 3.3+." }, { "code": "def check_calling_sequence(name, function_name, function, possible_variables):\n try:\n calling_sequence = inspect.getargspec(function.input_object).args\n except AttributeError:\n calling_sequence = inspect.getargspec(function).args\n assert calling_sequence[0] == 'self', \"Wrong syntax for 'evaluate' in %s. The first argument \" \\\n \"should be called 'self'.\" % name\n variables = filter(lambda var: var in possible_variables, calling_sequence)\n assert len(variables) > 0, \"The name of the variables for 'evaluate' in %s must be one or more \" \\\n \"among %s, instead of %s\" % (name, ','.join(possible_variables), \",\".join(variables))\n if variables != possible_variables[:len(variables)]:\n raise AssertionError(\"The variables %s are out of order in '%s' of %s. Should be %s.\"\n % (\",\".join(variables), function_name, name, possible_variables[:len(variables)]))\n other_parameters = filter(lambda var: var not in variables and var != 'self', calling_sequence)\n return variables, other_parameters", "docstring": "Check the calling sequence for the function looking for the variables specified.\n One or more of the variables can be in the calling sequence. Note that the\n order of the variables will be enforced.\n It will also enforce that the first parameter in the calling sequence is called 'self'.\n\n :param function: the function to check\n :param possible_variables: a list of variables to check, The order is important, and will be enforced\n :return: a tuple containing the list of found variables, and the name of the other parameters in the calling\n sequence" }, { "code": "def fill_zero(\n x=None,\n y=None,\n label=None,\n color=None,\n width=None,\n dash=None,\n opacity=None,\n mode='lines+markers',\n **kargs\n):\n return line(\n x=x,\n y=y,\n label=label,\n color=color,\n width=width,\n dash=dash,\n opacity=opacity,\n mode=mode,\n fill='tozeroy',\n **kargs\n )", "docstring": "Fill to zero.\n\n Parameters\n ----------\n x : array-like, optional\n y : TODO, optional\n label : TODO, optional\n\n Returns\n -------\n Chart" }, { "code": "def wrap(stream, unicode=False, window=1024, echo=False, close_stream=True):\n if hasattr(stream, 'read'):\n proxy = PollingStreamAdapter(stream)\n elif hasattr(stream, 'recv'):\n proxy = PollingSocketStreamAdapter(stream)\n else:\n raise TypeError('stream must have either read or recv method')\n if echo and unicode:\n callback = _echo_text\n elif echo and not unicode:\n callback = _echo_bytes\n else:\n callback = None\n if unicode:\n expecter = TextExpecter(proxy, input_callback=callback, window=window,\n close_adapter=close_stream)\n else:\n expecter = BytesExpecter(proxy, input_callback=callback, window=window,\n close_adapter=close_stream)\n return expecter", "docstring": "Wrap a stream to implement expect functionality.\n\n This function provides a convenient way to wrap any Python stream (a\n file-like object) or socket with an appropriate :class:`Expecter` class for\n the stream type. The returned object adds an :func:`Expect.expect` method\n to the stream, while passing normal stream functions like *read*/*recv*\n and *write*/*send* through to the underlying stream.\n\n Here's an example of opening and wrapping a pair of network sockets::\n\n import socket\n import streamexpect\n\n source, drain = socket.socketpair()\n expecter = streamexpect.wrap(drain)\n source.sendall(b'this is a test')\n match = expecter.expect_bytes(b'test', timeout=5)\n\n assert match is not None\n\n :param stream: The stream/socket to wrap.\n :param bool unicode: If ``True``, the wrapper will be configured for\n Unicode matching, otherwise matching will be done on binary.\n :param int window: Historical characters to buffer.\n :param bool echo: If ``True``, echoes received characters to stdout.\n :param bool close_stream: If ``True``, and the wrapper is used as a context\n manager, closes the stream at the end of the context manager." }, { "code": "def can_edit(self, user):\n return self.class_.can_edit(user) and self.status != u'locked'", "docstring": "Return whether or not `user` can make changes to the project." }, { "code": "def compress_monkey_patch():\n from compressor.templatetags import compress as compress_tags\n from compressor import base as compress_base\n compress_base.Compressor.filter_input = filter_input\n compress_base.Compressor.output = output\n compress_base.Compressor.hunks = hunks\n compress_base.Compressor.precompile = precompile\n compress_tags.CompressorMixin.render_compressed = render_compressed\n from django_pyscss import compressor as pyscss_compressor\n pyscss_compressor.DjangoScssFilter.input = input", "docstring": "patch all compress\n\n we need access to variables from widget scss\n\n for example we have::\n\n /themes/bootswatch/cyborg/_variables\n\n but only if is cyborg active for this reasone we need\n dynamically append import to every scss file" }, { "code": "def xraw_command(self, netfn, command, bridge_request=(), data=(),\n delay_xmit=None, retry=True, timeout=None):\n rsp = self.ipmi_session.raw_command(netfn=netfn, command=command,\n bridge_request=bridge_request,\n data=data, delay_xmit=delay_xmit,\n retry=retry, timeout=timeout)\n if 'error' in rsp:\n raise exc.IpmiException(rsp['error'], rsp['code'])\n rsp['data'] = buffer(rsp['data'])\n return rsp", "docstring": "Send raw ipmi command to BMC, raising exception on error\n\n This is identical to raw_command, except it raises exceptions\n on IPMI errors and returns data as a buffer. This is the recommend\n function to use. The response['data'] being a buffer allows\n traditional indexed access as well as works nicely with\n struct.unpack_from when certain data is coming back.\n\n :param netfn: Net function number\n :param command: Command value\n :param bridge_request: The target slave address and channel number for\n the bridge request.\n :param data: Command data as a tuple or list\n :param retry: Whether to retry this particular payload or not, defaults\n to true.\n :param timeout: A custom time to wait for initial reply, useful for\n a slow command. This may interfere with retry logic.\n :returns: dict -- The response from IPMI device" }, { "code": "def get_all_submissions(course_id, item_id, item_type, read_replica=True):\n submission_qs = Submission.objects\n if read_replica:\n submission_qs = _use_read_replica(submission_qs)\n query = submission_qs.select_related('student_item').filter(\n student_item__course_id=course_id,\n student_item__item_id=item_id,\n student_item__item_type=item_type,\n ).order_by('student_item__student_id', '-submitted_at', '-id').iterator()\n for unused_student_id, row_iter in itertools.groupby(query, operator.attrgetter('student_item.student_id')):\n submission = next(row_iter)\n data = SubmissionSerializer(submission).data\n data['student_id'] = submission.student_item.student_id\n yield data", "docstring": "For the given item, get the most recent submission for every student who has submitted.\n\n This may return a very large result set! It is implemented as a generator for efficiency.\n\n Args:\n course_id, item_id, item_type (string): The values of the respective student_item fields\n to filter the submissions by.\n read_replica (bool): If true, attempt to use the read replica database.\n If no read replica is available, use the default database.\n\n Yields:\n Dicts representing the submissions with the following fields:\n student_item\n student_id\n attempt_number\n submitted_at\n created_at\n answer\n\n Raises:\n Cannot fail unless there's a database error, but may return an empty iterable." }, { "code": "def _to_utc(self, dt):\n tz = self._get_tz()\n loc_dt = tz.localize(dt)\n return loc_dt.astimezone(pytz.utc)", "docstring": "Takes a naive timezone with an localized value and return it formatted\n as utc." }, { "code": "def check_key(self, key):\n if self.key_size and len(key) not in self.key_size:\n raise TypeError('invalid key size %s, must be one of %s' %\n (len(key), self.key_size))", "docstring": "Check that the key length is valid.\n\n @param key: a byte string" }, { "code": "def _annotation_handler(ion_type, length, ctx):\n _, self = yield\n self_handler = _create_delegate_handler(self)\n if ctx.annotations is not None:\n raise IonException('Annotation cannot be nested in annotations')\n ctx = ctx.derive_container_context(length, add_depth=0)\n (ann_length, _), _ = yield ctx.immediate_transition(\n _var_uint_field_handler(self_handler, ctx)\n )\n if ann_length < 1:\n raise IonException('Invalid annotation length subfield; annotation wrapper must have at least one annotation.')\n yield ctx.read_data_transition(ann_length, self)\n ann_data = ctx.queue.read(ann_length)\n annotations = tuple(_parse_sid_iter(ann_data))\n if ctx.limit - ctx.queue.position < 1:\n raise IonException('Incorrect annotation wrapper length.')\n yield ctx.immediate_transition(\n _start_type_handler(ctx.field_name, ctx.whence, ctx, annotations=annotations)\n )", "docstring": "Handles annotations. ``ion_type`` is ignored." }, { "code": "def listen():\n msg = MSG()\n ctypes.windll.user32.GetMessageA(ctypes.byref(msg), 0, 0, 0)", "docstring": "Listen for keyboard input." }, { "code": "def get_current_user(self):\n url = self.current_user_url\n result = self.get(url)\n return result", "docstring": "Get data from the current user endpoint" }, { "code": "def _from_dict(cls, _dict):\n args = {}\n if 'tokens' in _dict:\n args['tokens'] = [\n TokenResult._from_dict(x) for x in (_dict.get('tokens'))\n ]\n if 'sentences' in _dict:\n args['sentences'] = [\n SentenceResult._from_dict(x) for x in (_dict.get('sentences'))\n ]\n return cls(**args)", "docstring": "Initialize a SyntaxResult object from a json dictionary." }, { "code": "def get_list_from_file(file_name):\n with open(file_name, mode='r', encoding='utf-8') as f1:\n lst = f1.readlines()\n return lst", "docstring": "read the lines from a file into a list" }, { "code": "def template_sunmoon(self, **kwargs):\n kwargs_copy = self.base_dict.copy()\n kwargs_copy.update(**kwargs)\n kwargs_copy['dataset'] = kwargs.get('dataset', self.dataset(**kwargs))\n kwargs_copy['component'] = kwargs.get(\n 'component', self.component(**kwargs))\n self._replace_none(kwargs_copy) \n localpath = NameFactory.templatesunmoon_format.format(**kwargs_copy)\n if kwargs.get('fullpath', False):\n return self.fullpath(localpath=localpath)\n return localpath", "docstring": "return the file name for sun or moon template files" }, { "code": "def visit_break(self, node, parent):\n return nodes.Break(\n getattr(node, \"lineno\", None), getattr(node, \"col_offset\", None), parent\n )", "docstring": "visit a Break node by returning a fresh instance of it" }, { "code": "def from_path(cls, *path, namespace=None):\n parent = None\n for i in range(0, len(path), 2):\n parent = cls(*path[i:i + 2], parent=parent, namespace=namespace)\n return parent", "docstring": "Build up a Datastore key from a path.\n\n Parameters:\n \\*path(tuple[str or int]): The path segments.\n namespace(str): An optional namespace for the key. This is\n applied to each key in the tree.\n\n Returns:\n anom.Key: The Datastore represented by the given path." }, { "code": "def get_role(resource_root, service_name, name, cluster_name=\"default\"):\n return _get_role(resource_root, _get_role_path(cluster_name, service_name, name))", "docstring": "Lookup a role by name\n @param resource_root: The root Resource object.\n @param service_name: Service name\n @param name: Role name\n @param cluster_name: Cluster name\n @return: An ApiRole object" }, { "code": "def ppo_original_world_model_stochastic_discrete():\n hparams = ppo_original_params()\n hparams.policy_network = \"next_frame_basic_stochastic_discrete\"\n hparams_keys = hparams.values().keys()\n video_hparams = basic_stochastic.next_frame_basic_stochastic_discrete()\n for (name, value) in six.iteritems(video_hparams.values()):\n if name in hparams_keys:\n hparams.set_hparam(name, value)\n else:\n hparams.add_hparam(name, value)\n hparams.optimization_batch_size = 1\n hparams.weight_decay = 0\n return hparams", "docstring": "Atari parameters with stochastic discrete world model as policy." }, { "code": "def add_update(self, selector, update, multi=False, upsert=False,\n collation=None, array_filters=None):\n validate_ok_for_update(update)\n cmd = SON([('q', selector), ('u', update),\n ('multi', multi), ('upsert', upsert)])\n collation = validate_collation_or_none(collation)\n if collation is not None:\n self.uses_collation = True\n cmd['collation'] = collation\n if array_filters is not None:\n self.uses_array_filters = True\n cmd['arrayFilters'] = array_filters\n if multi:\n self.is_retryable = False\n self.ops.append((_UPDATE, cmd))", "docstring": "Create an update document and add it to the list of ops." }, { "code": "def get_sig_info(hdr):\n string = '%|DSAHEADER?{%{DSAHEADER:pgpsig}}:{%|RSAHEADER?{%{RSAHEADER:pgpsig}}:{%|SIGGPG?{%{SIGGPG:pgpsig}}:{%|SIGPGP?{%{SIGPGP:pgpsig}}:{(none)}|}|}|}|'\n siginfo = hdr.sprintf(string)\n if siginfo != '(none)':\n error = 0\n sigtype, sigdate, sigid = siginfo.split(',')\n else:\n error = 101\n sigtype = 'MD5'\n sigdate = 'None'\n sigid = 'None'\n infotuple = (sigtype, sigdate, sigid)\n return error, infotuple", "docstring": "hand back signature information and an error code\n\n Shamelessly stolen from Seth Vidal\n http://yum.baseurl.org/download/misc/checksig.py" }, { "code": "def name(self):\n if self._name_map is None:\n self._name_map = {}\n for key, value in self.__class__.__dict__.items():\n if isinstance(value, self.__class__):\n self._name_map[value] = key\n return self._name_map[self]", "docstring": "Get the enumeration name of this cursor kind." }, { "code": "def days_and_sids_for_frames(frames):\n if not frames:\n days = np.array([], dtype='datetime64[ns]')\n sids = np.array([], dtype='int64')\n return days, sids\n check_indexes_all_same(\n [frame.index for frame in frames],\n message='Frames have mistmatched days.',\n )\n check_indexes_all_same(\n [frame.columns for frame in frames],\n message='Frames have mismatched sids.',\n )\n return frames[0].index.values, frames[0].columns.values", "docstring": "Returns the date index and sid columns shared by a list of dataframes,\n ensuring they all match.\n\n Parameters\n ----------\n frames : list[pd.DataFrame]\n A list of dataframes indexed by day, with a column per sid.\n\n Returns\n -------\n days : np.array[datetime64[ns]]\n The days in these dataframes.\n sids : np.array[int64]\n The sids in these dataframes.\n\n Raises\n ------\n ValueError\n If the dataframes passed are not all indexed by the same days\n and sids." }, { "code": "def get_source(\n self, environment: Environment, template: str,\n ) -> Tuple[str, Optional[str], Callable]:\n for loader in self._loaders():\n try:\n return loader.get_source(environment, template)\n except TemplateNotFound:\n continue\n raise TemplateNotFound(template)", "docstring": "Returns the template source from the environment.\n\n This considers the loaders on the :attr:`app` and blueprints." }, { "code": "def get_public_orders(self, group=False):\n self._log('get public orders')\n return self._rest_client.get(\n endpoint='/order_book',\n params={'book': self.name, 'group': int(group)}\n )", "docstring": "Return public orders that are currently open.\n\n :param group: If set to True (default: False), orders with the same\n price are grouped.\n :type group: bool\n :return: Public orders currently open.\n :rtype: dict" }, { "code": "def get_datastream(self, datastream):\n response = self.http.get('/Datastream/' + str(datastream))\n datastream = Schemas.Datastream(datastream=response)\n return datastream", "docstring": "To get Datastream by id" }, { "code": "def text_extents(self, text):\n extents = ffi.new('cairo_text_extents_t *')\n cairo.cairo_text_extents(self._pointer, _encode_string(text), extents)\n self._check_status()\n return (\n extents.x_bearing, extents.y_bearing,\n extents.width, extents.height,\n extents.x_advance, extents.y_advance)", "docstring": "Returns the extents for a string of text.\n\n The extents describe a user-space rectangle\n that encloses the \"inked\" portion of the text,\n (as it would be drawn by :meth:`show_text`).\n Additionally, the :obj:`x_advance` and :obj:`y_advance` values\n indicate the amount by which the current point would be advanced\n by :meth:`show_text`.\n\n Note that whitespace characters do not directly contribute\n to the size of the rectangle (:obj:`width` and :obj:`height`).\n They do contribute indirectly by changing the position\n of non-whitespace characters.\n In particular, trailing whitespace characters are likely\n to not affect the size of the rectangle,\n though they will affect the x_advance and y_advance values.\n\n Because text extents are in user-space coordinates,\n they are mostly, but not entirely,\n independent of the current transformation matrix.\n If you call :meth:`context.scale(2) `,\n text will be drawn twice as big,\n but the reported text extents will not be doubled.\n They will change slightly due to hinting\n (so you can't assume that metrics are independent\n of the transformation matrix),\n but otherwise will remain unchanged.\n\n :param text: The text to measure, as an Unicode or UTF-8 string.\n :returns:\n A ``(x_bearing, y_bearing, width, height, x_advance, y_advance)``\n tuple of floats.\n\n :obj:`x_bearing`\n The horizontal distance\n from the origin to the leftmost part of the glyphs as drawn.\n Positive if the glyphs lie entirely to the right of the origin.\n\n :obj:`y_bearing`\n The vertical distance\n from the origin to the topmost part of the glyphs as drawn.\n Positive only if the glyphs lie completely below the origin;\n will usually be negative.\n\n :obj:`width`\n Width of the glyphs as drawn.\n\n :obj:`height`\n Height of the glyphs as drawn.\n\n :obj:`x_advance`\n Distance to advance in the X direction\n after drawing these glyphs.\n\n :obj:`y_advance`\n Distance to advance in the Y direction\n after drawing these glyphs.\n Will typically be zero except for vertical text layout\n as found in East-Asian languages." }, { "code": "def get_objective(self, sampler):\n def objective(params):\n circuit = self.get_circuit(params)\n circuit.make_cache()\n return self.get_energy(circuit, sampler)\n return objective", "docstring": "Get an objective function to be optimized." }, { "code": "def add_shortcut_to_tooltip(action, context, name):\r\n action.setToolTip(action.toolTip() + ' (%s)' %\r\n get_shortcut(context=context, name=name))", "docstring": "Add the shortcut associated with a given action to its tooltip" }, { "code": "def parse(self):\n\t\tc = Collection()\n\t\twhile self.index < self.datalen:\n\t\t\tg = self.parseOneGame()\n\t\t\tif g:\n\t\t\t\tc.append(g)\n\t\t\telse:\n\t\t\t\tbreak\n\t\treturn c", "docstring": "Parses the SGF data stored in 'self.data', and returns a 'Collection'." }, { "code": "def load_model(modelname, add_sentencizer=False):\n loading_start = time.time()\n nlp = spacy.load(modelname)\n if add_sentencizer:\n nlp.add_pipe(nlp.create_pipe('sentencizer'))\n loading_end = time.time()\n loading_time = loading_end - loading_start\n if add_sentencizer:\n return nlp, loading_time, modelname + '_sentencizer'\n return nlp, loading_time, modelname", "docstring": "Load a specific spaCy model" }, { "code": "def _add_person_to_group(person, group):\n from karaage.datastores import add_accounts_to_group\n from karaage.datastores import add_accounts_to_project\n from karaage.datastores import add_accounts_to_institute\n a_list = person.account_set\n add_accounts_to_group(a_list, group)\n for project in group.project_set.all():\n add_accounts_to_project(a_list, project)\n for institute in group.institute_set.all():\n add_accounts_to_institute(a_list, institute)", "docstring": "Call datastores after adding a person to a group." }, { "code": "def _populate_ranking_payoff_arrays(payoff_arrays, scores, costs):\n n = payoff_arrays[0].shape[0]\n for p, payoff_array in enumerate(payoff_arrays):\n payoff_array[0, :] = 0\n for i in range(1, n):\n for j in range(n):\n payoff_array[i, j] = -costs[p, i-1]\n prize = 1.\n for i in range(n):\n for j in range(n):\n if scores[0, i] > scores[1, j]:\n payoff_arrays[0][i, j] += prize\n elif scores[0, i] < scores[1, j]:\n payoff_arrays[1][j, i] += prize\n else:\n payoff_arrays[0][i, j] += prize / 2\n payoff_arrays[1][j, i] += prize / 2", "docstring": "Populate the ndarrays in `payoff_arrays` with the payoff values of\n the ranking game given `scores` and `costs`.\n\n Parameters\n ----------\n payoff_arrays : tuple(ndarray(float, ndim=2))\n Tuple of 2 ndarrays of shape (n, n). Modified in place.\n scores : ndarray(int, ndim=2)\n ndarray of shape (2, n) containing score values corresponding to\n the effort levels for the two players.\n costs : ndarray(float, ndim=2)\n ndarray of shape (2, n-1) containing cost values corresponding\n to the n-1 positive effort levels for the two players, with the\n assumption that the cost of the zero effort action is zero." }, { "code": "def _find_inline_images(contentsinfo):\n \"Find inline images in the contentstream\"\n for n, inline in enumerate(contentsinfo.inline_images):\n yield ImageInfo(\n name='inline-%02d' % n, shorthand=inline.shorthand, inline=inline\n )", "docstring": "Find inline images in the contentstream" }, { "code": "def width(self) -> int:\n max_x = -1.0\n for x, _ in self.entries.keys():\n max_x = max(max_x, x)\n for v in self.vertical_lines:\n max_x = max(max_x, v.x)\n for h in self.horizontal_lines:\n max_x = max(max_x, h.x1, h.x2)\n return 1 + int(max_x)", "docstring": "Determines how many entry columns are in the diagram." }, { "code": "def _adjust_inferential_results_for_parameter_constraints(self,\n constraints):\n if constraints is not None:\n inferential_attributes = [\"standard_errors\",\n \"tvalues\",\n \"pvalues\",\n \"robust_std_errs\",\n \"robust_t_stats\",\n \"robust_p_vals\"]\n assert all([hasattr(self, x) for x in inferential_attributes])\n assert hasattr(self, \"params\")\n all_names = self.params.index.tolist()\n for series in [getattr(self, x) for x in inferential_attributes]:\n for pos in constraints:\n series.loc[all_names[pos]] = np.nan\n return None", "docstring": "Ensure that parameters that were constrained during estimation do not\n have any values showed for inferential results. After all, no inference\n was performed.\n\n Parameters\n ----------\n constraints : list of ints, or None.\n If list, should contain the positions in the array of all estimated\n parameters that were constrained to their initial values.\n\n Returns\n -------\n None." }, { "code": "def loadScopeGroupbyName(self, name, service_group_id, callback=None, errback=None):\n import ns1.ipam\n scope_group = ns1.ipam.Scopegroup(self.config, name=name, service_group_id=service_group_id)\n return scope_group.load(callback=callback, errback=errback)", "docstring": "Load an existing Scope Group by name and service group id into a high level Scope Group object\n\n :param str name: Name of an existing Scope Group\n :param int service_group_id: id of the service group the Scope group is associated with" }, { "code": "def _sign(self, data: bytes) -> bytes:\n assert self._raiden_service is not None\n return self._raiden_service.signer.sign(data=data)", "docstring": "Use eth_sign compatible hasher to sign matrix data" }, { "code": "def compile(conf):\n with errorprint():\n config = ConfModule(conf)\n for conf in config.configurations:\n conf.format(do_print=True)", "docstring": "Compiles classic uWSGI configuration file using the default\n or given `uwsgiconf` configuration module." }, { "code": "def delete_jail(name):\n if is_jail(name):\n cmd = 'poudriere jail -d -j {0}'.format(name)\n __salt__['cmd.run'](cmd)\n if is_jail(name):\n return 'Looks like there was an issue deleteing jail \\\n {0}'.format(name)\n else:\n return 'Looks like jail {0} has not been created'.format(name)\n make_file = os.path.join(_config_dir(), '{0}-make.conf'.format(name))\n if os.path.isfile(make_file):\n try:\n os.remove(make_file)\n except (IOError, OSError):\n return ('Deleted jail \"{0}\" but was unable to remove jail make '\n 'file').format(name)\n __salt__['file.remove'](make_file)\n return 'Deleted jail {0}'.format(name)", "docstring": "Deletes poudriere jail with `name`\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' poudriere.delete_jail 90amd64" }, { "code": "def copy(self, newdata=None):\n if newdata is None:\n newdata = self.data.copy()\n return self.__class__(\n self.molecule, self.origin.copy(), self.axes.copy(),\n self.nrep.copy(), newdata, self.subtitle, self.nuclear_charges\n )", "docstring": "Return a copy of the cube with optionally new data." }, { "code": "def bitcoin_address(self) -> str:\n type_ = self.random.choice(['1', '3'])\n letters = string.ascii_letters + string.digits\n return type_ + ''.join(\n self.random.choice(letters) for _ in range(33))", "docstring": "Generate a random bitcoin address.\n\n :return: Bitcoin address.\n\n :Example:\n 3EktnHQD7RiAE6uzMj2ZifT9YgRrkSgzQX" }, { "code": "def derive_title(self):\n if not self.title:\n return _(\"Create %s\") % force_text(self.model._meta.verbose_name).title()\n else:\n return self.title", "docstring": "Derives our title from our object" }, { "code": "def get_attribute(module_name: str, attribute_name: str):\n assert isinstance(module_name, str)\n assert isinstance(attribute_name, str)\n _module = importlib.import_module(module_name)\n return getattr(_module, attribute_name)", "docstring": "Get the specified module attribute. It most cases, it will be a class or function.\n\n :param module_name: module name\n :param attribute_name: attribute name\n :return: module attribute" }, { "code": "def log_middleware(store):\n def wrapper(next_):\n def log_dispatch(action):\n print('Dispatch Action:', action)\n return next_(action)\n return log_dispatch\n return wrapper", "docstring": "log all actions to console as they are dispatched" }, { "code": "def adjustMinimumWidth( self ):\r\n pw = self.pixmapSize().width()\r\n self.setMinimumWidth(pw * self.maximum() + 3 * self.maximum())", "docstring": "Modifies the minimum width to factor in the size of the pixmaps and the\r\n number for the maximum." }, { "code": "def visit_Import(self, node):\n for alias in node.names:\n current_module = MODULES\n for path in alias.name.split('.'):\n if path not in current_module:\n raise PythranSyntaxError(\n \"Module '{0}' unknown.\".format(alias.name),\n node)\n else:\n current_module = current_module[path]", "docstring": "Check if imported module exists in MODULES." }, { "code": "def create_parser(self, prog_name, subcommand):\n parser = OptionParser(prog=prog_name,\n usage=self.usage(subcommand),\n option_list=self.option_list)\n return parser", "docstring": "Create an OptionParser\n prog_name - Name of a command\n subcommand - Name of a subcommand" }, { "code": "def _recursive_getitem(d, key):\n if key in d:\n return d\n else:\n for v in d.values():\n return _recursive_getitem(v, key)\n else:\n raise KeyError('Key not found: {}'.format(key))", "docstring": "Descend into a dict of dicts to return the one that contains\n a given key. Every value in the dict must be another dict." }, { "code": "def _get_raw_key(self, key_id):\n try:\n static_key = self._static_keys[key_id]\n except KeyError:\n static_key = os.urandom(32)\n self._static_keys[key_id] = static_key\n return WrappingKey(\n wrapping_algorithm=WrappingAlgorithm.AES_256_GCM_IV12_TAG16_NO_PADDING,\n wrapping_key=static_key,\n wrapping_key_type=EncryptionKeyType.SYMMETRIC,\n )", "docstring": "Returns a static, randomly-generated symmetric key for the specified key ID.\n\n :param str key_id: Key ID\n :returns: Wrapping key that contains the specified static key\n :rtype: :class:`aws_encryption_sdk.internal.crypto.WrappingKey`" }, { "code": "def add_before(self, pipeline):\n if not isinstance(pipeline, Pipeline):\n pipeline = Pipeline(pipeline)\n self.pipes = pipeline.pipes[:] + self.pipes[:]\n return self", "docstring": "Add a Pipeline to be applied before this processing pipeline.\n\n Arguments:\n pipeline: The Pipeline or callable to apply before this\n Pipeline." }, { "code": "def getvalue(self, v):\n if not is_measure(v):\n raise TypeError('Incorrect input type for getvalue()')\n import re\n rx = re.compile(\"m\\d+\")\n out = []\n keys = v.keys()[:]\n keys.sort()\n for key in keys:\n if re.match(rx, key):\n out.append(dq.quantity(v.get(key)))\n return out", "docstring": "Return a list of quantities making up the measures' value.\n\n :param v: a measure" }, { "code": "def serialize(self):\n if self.mate_chrom is None:\n remote_tag = \".\"\n else:\n if self.within_main_assembly:\n mate_chrom = self.mate_chrom\n else:\n mate_chrom = \"<{}>\".format(self.mate_chrom)\n tpl = {FORWARD: \"[{}:{}[\", REVERSE: \"]{}:{}]\"}[self.mate_orientation]\n remote_tag = tpl.format(mate_chrom, self.mate_pos)\n if self.orientation == FORWARD:\n return remote_tag + self.sequence\n else:\n return self.sequence + remote_tag", "docstring": "Return string representation for VCF" }, { "code": "def print_config():\n description =\n parser = argparse.ArgumentParser(\n description=textwrap.dedent(description)\n )\n parser.add_argument(\n 'config_uri', type=str, help='an integer for the accumulator'\n )\n parser.add_argument(\n '-k', '--key',\n dest='key',\n metavar='PREFIX',\n type=str,\n action='store',\n help=(\n \"Tells script to print only specified\"\n \" config tree provided by dotted name\"\n )\n )\n args = parser.parse_args(sys.argv[1:])\n config_uri = args.config_uri\n env = bootstrap(config_uri)\n config, closer = env['registry']['config'], env['closer']\n try:\n print(printer(slice_config(config, args.key)))\n except KeyError:\n print(\n 'Sorry, but the key path {0}, does not exists in Your config!'\n .format(args.key)\n )\n finally:\n closer()", "docstring": "Print config entry function." }, { "code": "def start(self):\n if self.running:\n self.stop()\n self._thread = threading.Thread(target=self._wrapped_target)\n self._thread.daemon = True\n self._thread.start()", "docstring": "Start the run method as a new thread.\n\n It will first stop the thread if it is already running." }, { "code": "def convert2wkt(self, set3D=True):\n features = self.getfeatures()\n for feature in features:\n try:\n feature.geometry().Set3D(set3D)\n except AttributeError:\n dim = 3 if set3D else 2\n feature.geometry().SetCoordinateDimension(dim)\n return [feature.geometry().ExportToWkt() for feature in features]", "docstring": "export the geometry of each feature as a wkt string\n\n Parameters\n ----------\n set3D: bool\n keep the third (height) dimension?\n\n Returns\n -------" }, { "code": "def delete_database(self, database):\n url = \"db/{0}\".format(database)\n self.request(\n url=url,\n method='DELETE',\n expected_response_code=204\n )\n return True", "docstring": "Drop a database on the InfluxDB server.\n\n :param database: the name of the database to delete\n :type database: string\n :rtype: boolean" }, { "code": "def deploy():\n _require_root()\n if not confirm(\"This will apply any available migrations to the database. Has the database been backed up?\"):\n abort(\"Aborted.\")\n if not confirm(\"Are you sure you want to deploy?\"):\n abort(\"Aborted.\")\n with lcd(PRODUCTION_DOCUMENT_ROOT):\n with shell_env(PRODUCTION=\"TRUE\"):\n local(\"git pull\")\n with open(\"requirements.txt\", \"r\") as req_file:\n requirements = req_file.read().strip().split()\n try:\n pkg_resources.require(requirements)\n except pkg_resources.DistributionNotFound:\n local(\"pip install -r requirements.txt\")\n except Exception:\n traceback.format_exc()\n local(\"pip install -r requirements.txt\")\n else:\n puts(\"Python requirements already satisfied.\")\n with prefix(\"source /usr/local/virtualenvs/ion/bin/activate\"):\n local(\"./manage.py collectstatic --noinput\", shell=\"/bin/bash\")\n local(\"./manage.py migrate\", shell=\"/bin/bash\")\n restart_production_gunicorn(skip=True)\n puts(\"Deploy complete.\")", "docstring": "Deploy to production." }, { "code": "def postToNodeInBox(self, msg, frm):\n logger.trace(\"{} appending to nodeInbox {}\".format(self, msg))\n self.nodeInBox.append((msg, frm))", "docstring": "Append the message to the node inbox\n\n :param msg: a node message\n :param frm: the name of the node that sent this `msg`" }, { "code": "def wiki(self):\n date = self.pull.created_at.strftime(\"%m/%d/%Y %H:%M\")\n return \"{} {} ({} [{} github])\\n\".format(self.pull.avatar_url, self.pull.body, date,\n self.pull.html_url)", "docstring": "Returns the wiki markup describing the details of the github pull request\n as well as a link to the details on github." }, { "code": "def get(self, name=None, default=None):\n if name is None:\n return self.data\n if not isinstance(name, list):\n name = [name]\n data = self.data\n try:\n for key in name:\n data = data[key]\n except KeyError:\n return default\n return data", "docstring": "Get attribute value or return default\n\n Whole data dictionary is returned when no attribute provided.\n Supports direct values retrieval from deep dictionaries as well.\n Dictionary path should be provided as list. The following two\n examples are equal:\n\n tree.data['hardware']['memory']['size']\n tree.get(['hardware', 'memory', 'size'])\n\n However the latter approach will also correctly handle providing\n default value when any of the dictionary keys does not exist." }, { "code": "def place_market_order(self, side: Side, amount: Number) -> Order:\n return self.place_order(side, OrderType.MARKET, amount)", "docstring": "Place a market order." }, { "code": "async def dump_message(obj, msg, field_archiver=None):\n mtype = msg.__class__\n fields = mtype.f_specs()\n obj = collections.OrderedDict() if obj is None else get_elem(obj)\n for field in fields:\n await dump_message_field(obj, msg=msg, field=field, field_archiver=field_archiver)\n return obj", "docstring": "Dumps message to the object.\n Returns message popo representation.\n\n :param obj:\n :param msg:\n :param field_archiver:\n :return:" }, { "code": "def make_url(path, protocol=None, hosts=None):\n protocol = 'https://' if not protocol else protocol\n host = hosts[random.randrange(len(hosts))] if hosts else 'archive.org'\n return protocol + host + path.strip()", "docstring": "Make an URL given a path, and optionally, a protocol and set of\n hosts to select from randomly.\n\n :param path: The Archive.org path.\n :type path: str\n\n :param protocol: (optional) The HTTP protocol to use. \"https://\" is\n used by default.\n :type protocol: str\n\n :param hosts: (optional) A set of hosts. A host will be chosen at\n random. The default host is \"archive.org\".\n :type hosts: iterable\n\n :rtype: str\n :returns: An Absolute URI." }, { "code": "def sg_summary_gradient(tensor, gradient, prefix=None, name=None):\n r\n prefix = '' if prefix is None else prefix + '/'\n name = prefix + _pretty_name(tensor) if name is None else prefix + name\n _scalar(name + '/grad', tf.reduce_mean(tf.abs(gradient)))\n _histogram(name + '/grad-h', tf.abs(gradient))", "docstring": "r\"\"\"Register `tensor` to summary report as `gradient`\n\n Args:\n tensor: A `Tensor` to log as gradient\n gradient: A 0-D `Tensor`. A gradient to log\n prefix: A `string`. A prefix to display in the tensor board web UI.\n name: A `string`. A name to display in the tensor board web UI.\n\n Returns:\n None" }, { "code": "def get_gradients(self) -> Dict[str, List[mx.nd.NDArray]]:\n return {\"dev_%d_%s\" % (i, name): exe.grad_arrays[j] for i, exe in enumerate(self.executors) for j, name in\n enumerate(self.executor_group.arg_names)\n if name in self.executor_group.param_names and self.executors[0].grad_arrays[j] is not None}", "docstring": "Returns a mapping of parameters names to gradient arrays. Parameter names are prefixed with the device." }, { "code": "def get_cmd(self):\n cmd = None\n if self.test_program in ('nose', 'nosetests'):\n cmd = \"nosetests %s\" % self.file_path\n elif self.test_program == 'django':\n executable = \"%s/manage.py\" % self.file_path\n if os.path.exists(executable):\n cmd = \"python %s/manage.py test\" % self.file_path\n else:\n cmd = \"django-admin.py test\"\n elif self.test_program == 'py':\n cmd = 'py.test %s' % self.file_path\n elif self.test_program == 'symfony':\n cmd = 'symfony test-all'\n elif self.test_program == 'jelix':\n cmd = 'php tests.php'\n elif self.test_program == 'phpunit':\n cmd = 'phpunit'\n elif self.test_program == 'sphinx':\n cmd = 'make html'\n elif self.test_program == 'tox':\n cmd = 'tox'\n if not cmd:\n raise InvalidTestProgram(\"The test program %s is unknown. Valid options are: `nose`, `django` and `py`\" % self.test_program)\n if self.custom_args:\n cmd = '%s %s' % (cmd, self.custom_args)\n return cmd", "docstring": "Returns the full command to be executed at runtime" }, { "code": "def from_edgelist(self, edges, strict=True):\n for edge in edges:\n if len(edge) == 3:\n self.update(edge[1], edge[0], **edge[2])\n elif len(edge) == 2:\n self.update(edge[1], edge[0])\n elif strict:\n raise ValueError('edge incorrect shape: {}'.format(str(edge)))", "docstring": "Load transform data from an edge list into the current\n scene graph.\n\n Parameters\n -------------\n edgelist : (n,) tuples\n (node_a, node_b, {key: value})\n strict : bool\n If true, raise a ValueError when a\n malformed edge is passed in a tuple." }, { "code": "def confidence_interval(self, confidenceLevel):\n if not (confidenceLevel >= 0 and confidenceLevel <= 1):\n raise ValueError(\"Parameter percentage has to be in [0,1]\")\n underestimations = []\n overestimations = []\n for error in self._errorValues:\n if error is None:\n continue\n if error >= 0:\n overestimations.append(error)\n if error <= 0:\n underestimations.append(error)\n overestimations.sort()\n underestimations.sort(reverse=True)\n overIdx = int(len(overestimations) * confidenceLevel) - 1\n underIdx = int(len(underestimations) * confidenceLevel) - 1\n overestimation = 0.0\n underestimation = 0.0\n if overIdx >= 0:\n overestimation = overestimations[overIdx]\n else:\n print len(overestimations), confidenceLevel\n if underIdx >= 0:\n underestimation = underestimations[underIdx]\n return underestimation, overestimation", "docstring": "Calculates for which value confidenceLevel% of the errors are closer to 0.\n\n :param float confidenceLevel: percentage of the errors that should be\n smaller than the returned value for overestimations and larger than\n the returned value for underestimations.\n confidenceLevel has to be in [0.0, 1.0]\n\n :return: return a tuple containing the underestimation and overestimation for\n the given confidenceLevel\n :rtype: tuple\n\n :warning: Index is still not calculated correctly" }, { "code": "def docgraph2freqt(docgraph, root=None, include_pos=False,\n escape_func=FREQT_ESCAPE_FUNC):\n if root is None:\n return u\"\\n\".join(\n sentence2freqt(docgraph, sentence, include_pos=include_pos,\n escape_func=escape_func)\n for sentence in docgraph.sentences)\n else:\n return sentence2freqt(docgraph, root, include_pos=include_pos,\n escape_func=escape_func)", "docstring": "convert a docgraph into a FREQT string." }, { "code": "def lookup_data(self, lookup, data):\n value = data\n parts = lookup.split('.')\n if not parts or not parts[0]:\n return value\n part = parts[0]\n remaining_lookup = '.'.join(parts[1:])\n if callable(getattr(data, 'keys', None)) and hasattr(data, '__getitem__'):\n value = data[part]\n elif data is not None:\n value = getattr(data, part)\n if callable(value) and not hasattr(value, 'db_manager'):\n value = value()\n if not remaining_lookup:\n return value\n return self.lookup_data(remaining_lookup, value)", "docstring": "Given a lookup string, attempts to descend through nested data looking for\n the value.\n\n Can work with either dictionary-alikes or objects (or any combination of\n those).\n\n Lookups should be a string. If it is a dotted path, it will be split on\n ``.`` & it will traverse through to find the final value. If not, it will\n simply attempt to find either a key or attribute of that name & return it.\n\n Example::\n\n >>> data = {\n ... 'type': 'message',\n ... 'greeting': {\n ... 'en': 'hello',\n ... 'fr': 'bonjour',\n ... 'es': 'hola',\n ... },\n ... 'person': Person(\n ... name='daniel'\n ... )\n ... }\n >>> lookup_data('type', data)\n 'message'\n >>> lookup_data('greeting.en', data)\n 'hello'\n >>> lookup_data('person.name', data)\n 'daniel'" }, { "code": "def list_(runas=None):\n ret = []\n output = _rbenv_exec(['install', '--list'], runas=runas)\n if output:\n for line in output.splitlines():\n if line == 'Available versions:':\n continue\n ret.append(line.strip())\n return ret", "docstring": "List the installable versions of ruby\n\n runas\n The user under which to run rbenv. If not specified, then rbenv will be\n run as the user under which Salt is running.\n\n CLI Example:\n\n .. code-block:: bash\n\n salt '*' rbenv.list" }, { "code": "def utc_dt(dt):\n if not dt.tzinfo:\n return pytz.utc.localize(dt)\n return dt.astimezone(pytz.utc)", "docstring": "Set UTC timezone on a datetime object.\n\n A naive datetime is assumed to be in UTC TZ." }, { "code": "def connect(self):\n try:\n for group in ('inlets', 'receivers', 'outlets', 'senders'):\n self._connect_subgroup(group)\n except BaseException:\n objecttools.augment_excmessage(\n 'While trying to build the node connection of the `%s` '\n 'sequences of the model handled by element `%s`'\n % (group[:-1], objecttools.devicename(self)))", "docstring": "Connect the link sequences of the actual model." }, { "code": "def wrap(self, string, width):\n if not string or width <= 0:\n logging.error(\"invalid string: %s or width: %s\" % (string, width))\n return False\n tmp = \"\"\n for line in string.splitlines():\n if len(line) <= width:\n tmp += line + \"\\n\"\n continue\n cur = 0\n length = len(line)\n while cur + width < length:\n cur = line[:cur+width].rfind(self.sep) + len(self.sep) - 1\n line = line[:cur] + \"\\n\" + line[cur+1:]\n tmp += line + \"\\n\\n\"\n return tmp", "docstring": "Wrap lines according to width\n Place '\\n' whenever necessary" }, { "code": "def from_database(cls, database):\n if isinstance(database, PostgresqlDatabase):\n return PostgresqlMigrator(database)\n if isinstance(database, SqliteDatabase):\n return SqliteMigrator(database)\n if isinstance(database, MySQLDatabase):\n return MySQLMigrator(database)\n return super(SchemaMigrator, cls).from_database(database)", "docstring": "Initialize migrator by db." }, { "code": "def get_all_formulae(chebi_ids):\n all_formulae = [get_formulae(chebi_id) for chebi_id in chebi_ids]\n return [x for sublist in all_formulae for x in sublist]", "docstring": "Returns all formulae" }, { "code": "def domain_score(self, domains):\n warn(\n 'OpenDNS Domain Scores endpoint is deprecated. Use '\n 'InvestigateApi.categorization() instead', DeprecationWarning,\n )\n url_path = 'domains/score/'\n return self._multi_post(url_path, domains)", "docstring": "Calls domain scores endpoint.\n\n This method is deprecated since OpenDNS Investigate API\n endpoint is also deprecated." }, { "code": "def get_wide_unicode(self, i):\n value = []\n for x in range(3):\n c = next(i)\n if c == '0':\n value.append(c)\n else:\n raise SyntaxError('Invalid wide Unicode character at %d!' % (i.index - 1))\n c = next(i)\n if c in ('0', '1'):\n value.append(c)\n else:\n raise SyntaxError('Invalid wide Unicode character at %d!' % (i.index - 1))\n for x in range(4):\n c = next(i)\n if c.lower() in _HEX:\n value.append(c)\n else:\n raise SyntaxError('Invalid wide Unicode character at %d!' % (i.index - 1))\n return ''.join(value)", "docstring": "Get narrow Unicode." }, { "code": "def get_plugins_info(self):\n d = {}\n for p in self.plugins:\n d.update(p.get_info())\n return d", "docstring": "Collect the current live info from all the registered plugins.\n\n Return a dictionary, keyed on the plugin name." }, { "code": "def transaction(data_access):\n old_autocommit = data_access.autocommit\n data_access.autocommit = False\n try:\n yield data_access\n except RollbackTransaction as ex:\n data_access.rollback()\n except Exception as ex:\n data_access.rollback()\n raise ex\n else:\n data_access.commit()\n finally:\n data_access.autocommit = old_autocommit", "docstring": "Wrap statements in a transaction. If the statements succeed, commit, otherwise rollback.\n\n :param data_access: a DataAccess instance" }, { "code": "def list_all_directories(self):\n def list_dirs_recursively(directory):\n if directory == self.filesystem:\n yield directory\n d_gen = itertools.chain(\n directory.directories,\n *tuple(list_dirs_recursively(d)\n for d in directory.directories))\n for d in d_gen:\n yield d\n return list_dirs_recursively(self.filesystem)", "docstring": "Utility method that yields all directories on the device's file\n systems." }, { "code": "def _form_datetimes(days, msecs):\n all_datetimes = []\n for i in range(days.size):\n day = int(days[i])\n msec = msecs[i]\n scanline_datetimes = []\n for j in range(int(VALUES_PER_SCAN_LINE / 4)):\n usec = 1000 * (j * VIEW_TIME_ADJUSTMENT + msec)\n delta = (dt.timedelta(days=day, microseconds=usec))\n for k in range(4):\n scanline_datetimes.append(delta.total_seconds())\n all_datetimes.append(scanline_datetimes)\n return np.array(all_datetimes, dtype=np.float64)", "docstring": "Calculate seconds since EPOCH from days and milliseconds for each of IASI scan." }, { "code": "def get_valid_cwd():\n try:\n cwd = _current_dir()\n except:\n warn(\"Your current directory is invalid. If you open a ticket at \" +\n \"https://github.com/milkbikis/powerline-shell/issues/new \" +\n \"we would love to help fix the issue.\")\n sys.stdout.write(\"> \")\n sys.exit(1)\n parts = cwd.split(os.sep)\n up = cwd\n while parts and not os.path.exists(up):\n parts.pop()\n up = os.sep.join(parts)\n if cwd != up:\n warn(\"Your current directory is invalid. Lowest valid directory: \"\n + up)\n return cwd", "docstring": "Determine and check the current working directory for validity.\n\n Typically, an directory arises when you checkout a different branch on git\n that doesn't have this directory. When an invalid directory is found, a\n warning is printed to the screen, but the directory is still returned\n as-is, since this is what the shell considers to be the cwd." }, { "code": "def get_history_by_tail_number(self, tail_number, page=1, limit=100):\n url = REG_BASE.format(tail_number, str(self.AUTH_TOKEN), page, limit)\n return self._fr24.get_data(url, True)", "docstring": "Fetch the history of a particular aircraft by its tail number.\n\n This method can be used to get the history of a particular aircraft by its tail number.\n It checks the user authentication and returns the data accordingly.\n\n Args:\n tail_number (str): The tail number, e.g. VT-ANL\n page (int): Optional page number; for users who are on a plan with flightradar24 they can pass in higher page numbers to get more data\n limit (int): Optional limit on number of records returned\n\n Returns:\n A list of dicts with the data; one dict for each row of data from flightradar24\n\n Example::\n\n from pyflightdata import FlightData\n f=FlightData()\n #optional login\n f.login(myemail,mypassword)\n f.get_history_by_flight_number('VT-ANL')\n f.get_history_by_flight_number('VT-ANL',page=1,limit=10)" }, { "code": "def findPrevStmt(self, block):\n stmtEnd = self._prevNonCommentBlock(block)\n stmtStart = self.findStmtStart(stmtEnd)\n return Statement(self._qpart, stmtStart, stmtEnd)", "docstring": "Returns a tuple that contains the first and last line of the\n previous statement before line." }, { "code": "def check_security_settings():\n in_production = not (current_app.debug or current_app.testing)\n secure = current_app.config.get('SESSION_COOKIE_SECURE')\n if in_production and not secure:\n current_app.logger.warning(\n \"SESSION_COOKIE_SECURE setting must be set to True to prevent the \"\n \"session cookie from being leaked over an insecure channel.\"\n )", "docstring": "Warn if session cookie is not secure in production." }, { "code": "def memoize(func):\n cache = {}\n def memoizer():\n if 0 not in cache:\n cache[0] = func()\n return cache[0]\n return functools.wraps(func)(memoizer)", "docstring": "Cache forever." }, { "code": "def _split_match_steps_into_match_traversals(match_steps):\n output = []\n current_list = None\n for step in match_steps:\n if isinstance(step.root_block, QueryRoot):\n if current_list is not None:\n output.append(current_list)\n current_list = [step]\n else:\n current_list.append(step)\n if current_list is None:\n raise AssertionError(u'current_list was unexpectedly None: {}'.format(match_steps))\n output.append(current_list)\n return output", "docstring": "Split a list of MatchSteps into multiple lists, each denoting a single MATCH traversal." }, { "code": "async def hmset(self, name, mapping):\n if not mapping:\n raise DataError(\"'hmset' with 'mapping' of length 0\")\n items = []\n for pair in iteritems(mapping):\n items.extend(pair)\n return await self.execute_command('HMSET', name, *items)", "docstring": "Set key to value within hash ``name`` for each corresponding\n key and value from the ``mapping`` dict." }, { "code": "def get_access_token(self):\n if (self.token is None) or (datetime.utcnow() > self.reuse_token_until):\n headers = {'Ocp-Apim-Subscription-Key': self.client_secret}\n response = requests.post(self.base_url, headers=headers)\n response.raise_for_status()\n self.token = response.content\n self.reuse_token_until = datetime.utcnow() + timedelta(minutes=5)\n return self.token.decode('utf-8')", "docstring": "Returns an access token for the specified subscription.\n\n This method uses a cache to limit the number of requests to the token service.\n A fresh token can be re-used during its lifetime of 10 minutes. After a successful\n request to the token service, this method caches the access token. Subsequent\n invocations of the method return the cached token for the next 5 minutes. After\n 5 minutes, a new token is fetched from the token service and the cache is updated." }, { "code": "def str(self,local=False,ifempty=None):\n ts = self.get(local)\n if not ts: return ifempty\n return ts.strftime('%Y-%m-%d %H:%M:%S')", "docstring": "Returns the string representation of the datetime" }, { "code": "def single(self):\n nodes = super(OneOrMore, self).all()\n if nodes:\n return nodes[0]\n raise CardinalityViolation(self, 'none')", "docstring": "Fetch one of the related nodes\n\n :return: Node" }, { "code": "def getLogger(name=None, **kwargs):\n adapter = _LOGGERS.get(name)\n if not adapter:\n adapter = KeywordArgumentAdapter(logging.getLogger(name), kwargs)\n _LOGGERS[name] = adapter\n return adapter", "docstring": "Build a logger with the given name.\n\n :param name: The name for the logger. This is usually the module\n name, ``__name__``.\n :type name: string" }, { "code": "def check_notebooks_for_errors(notebooks_directory):\n print(\"Checking notebooks in directory {} for errors\".format(notebooks_directory))\n failed_notebooks_count = 0\n for file in os.listdir(notebooks_directory):\n if file.endswith(\".ipynb\"):\n print(\"Checking notebook \" + file)\n full_file_path = os.path.join(notebooks_directory, file)\n output, errors = run_notebook(full_file_path)\n if errors is not None and len(errors) > 0:\n failed_notebooks_count += 1\n print(\"Errors in notebook \" + file)\n print(errors)\n if failed_notebooks_count == 0:\n print(\"No errors found in notebooks under \" + notebooks_directory)", "docstring": "Evaluates all notebooks in given directory and prints errors, if any" }, { "code": "def utc_datetime_and_leap_second(self):\n year, month, day, hour, minute, second = self._utc_tuple(\n _half_millisecond)\n second, fraction = divmod(second, 1.0)\n second = second.astype(int)\n leap_second = second // 60\n second -= leap_second\n milli = (fraction * 1000).astype(int) * 1000\n if self.shape:\n utcs = [utc] * self.shape[0]\n argsets = zip(year, month, day, hour, minute, second, milli, utcs)\n dt = array([datetime(*args) for args in argsets])\n else:\n dt = datetime(year, month, day, hour, minute, second, milli, utc)\n return dt, leap_second", "docstring": "Convert to a Python ``datetime`` in UTC, plus a leap second value.\n\n Convert this time to a `datetime`_ object and a leap second::\n\n dt, leap_second = t.utc_datetime_and_leap_second()\n\n If the third-party `pytz`_ package is available, then its\n ``utc`` timezone will be used as the timezone of the return\n value. Otherwise, Skyfield uses its own ``utc`` timezone.\n\n The leap second value is provided because a Python ``datetime``\n can only number seconds ``0`` through ``59``, but leap seconds\n have a designation of at least ``60``. The leap second return\n value will normally be ``0``, but will instead be ``1`` if the\n date and time are a UTC leap second. Add the leap second value\n to the ``second`` field of the ``datetime`` to learn the real\n name of the second.\n\n If this time is an array, then an array of ``datetime`` objects\n and an array of leap second integers is returned, instead of a\n single value each." }, { "code": "def get_quoted_foreign_columns(self, platform):\n columns = []\n for column in self._foreign_column_names.values():\n columns.append(column.get_quoted_name(platform))\n return columns", "docstring": "Returns the quoted representation of the referenced table column names\n the foreign key constraint is associated with.\n\n But only if they were defined with one or the referenced table column name\n is a keyword reserved by the platform.\n Otherwise the plain unquoted value as inserted is returned.\n\n :param platform: The platform to use for quotation.\n :type platform: Platform\n\n :rtype: list" }, { "code": "def dict_clip(a_dict, inlude_keys_lst=[]):\n return dict([[i[0], i[1]] for i in list(a_dict.items()) if i[0] in inlude_keys_lst])", "docstring": "returns a new dict with keys not in included in inlude_keys_lst clipped off" }, { "code": "def apply_trend_constraint(self, limit, dt, **kwargs):\n if 'RV monitoring' not in self.constraints:\n self.constraints.append('RV monitoring')\n for pop in self.poplist:\n if not hasattr(pop,'dRV'):\n continue\n pop.apply_trend_constraint(limit, dt, **kwargs)\n self.trend_limit = limit\n self.trend_dt = dt", "docstring": "Applies constraint corresponding to RV trend non-detection to each population\n\n See :func:`stars.StarPopulation.apply_trend_constraint`;\n all arguments passed to that function for each population." }, { "code": "def warning(cls, name, message, *args):\n cls.getLogger(name).warning(message, *args)", "docstring": "Convenience function to log a message at the WARNING level.\n\n :param name: The name of the logger instance in the VSG namespace (VSG.)\n :param message: A message format string.\n :param args: The arguments that are are merged into msg using the string formatting operator.\n :..note: The native logger's `kwargs` are not used in this function." }, { "code": "def register_event(self, event_name, event_level, message):\n self.events[event_name] = (event_level, message)", "docstring": "Registers an event so that it can be logged later." }, { "code": "def assert_conditions(self):\n self.assert_condition_md5()\n etag = self.clean_etag(self.call_method('get_etag'))\n self.response.last_modified = self.call_method('get_last_modified')\n self.assert_condition_etag()\n self.assert_condition_last_modified()", "docstring": "Handles various HTTP conditions and raises HTTP exceptions to\n abort the request.\n\n - Content-MD5 request header must match the MD5 hash of the full\n input (:func:`assert_condition_md5`).\n - If-Match and If-None-Match etags are checked against the ETag of\n this resource (:func:`assert_condition_etag`).\n - If-Modified-Since and If-Unmodified-Since are checked against\n the modification date of this resource\n (:func:`assert_condition_last_modified`).\n\n .. todo:: Return a 501 exception when any Content-* headers have been\n set in the request. (See :rfc:`2616`, section 9.6)" }, { "code": "def read(self, size = -1):\n\t\tif size < -1:\n\t\t\traise Exception('You shouldnt be doing this')\n\t\tif size == -1:\n\t\t\tt = self.current_segment.remaining_len(self.current_position)\n\t\t\tif not t:\n\t\t\t\treturn None\n\t\t\told_new_pos = self.current_position\n\t\t\tself.current_position = self.current_segment.end_address\n\t\t\treturn self.current_segment.data[old_new_pos - self.current_segment.start_address:]\n\t\tt = self.current_position + size\n\t\tif not self.current_segment.inrange(t):\n\t\t\traise Exception('Would read over segment boundaries!')\n\t\told_new_pos = self.current_position\n\t\tself.current_position = t\t\t\n\t\treturn self.current_segment.data[old_new_pos - self.current_segment.start_address :t - self.current_segment.start_address]", "docstring": "Returns data bytes of size size from the current segment. If size is -1 it returns all the remaining data bytes from memory segment" }, { "code": "def _no_proxy(method):\n @wraps(method)\n def wrapper(self, *args, **kwargs):\n notproxied = _oga(self, \"__notproxied__\")\n _osa(self, \"__notproxied__\", True)\n try:\n return method(self, *args, **kwargs)\n finally:\n _osa(self, \"__notproxied__\", notproxied)\n return wrapper", "docstring": "Returns a wrapped version of `method`, such that proxying is turned off\n during the method call." }, { "code": "def calc_path_and_create_folders(folder, import_path):\n file_path = abspath(path_join(folder, import_path[:import_path.rfind(\".\")].replace(\".\", folder_seperator) + \".py\"))\n mkdir_p(dirname(file_path))\n return file_path", "docstring": "calculate the path and create the needed folders" }, { "code": "def get_model(is_netfree=False, without_reset=False, seeds=None, effective=False):\n try:\n if seeds is not None or is_netfree:\n m = ecell4_base.core.NetfreeModel()\n else:\n m = ecell4_base.core.NetworkModel()\n for sp in SPECIES_ATTRIBUTES:\n m.add_species_attribute(sp)\n for rr in REACTION_RULES:\n m.add_reaction_rule(rr)\n if not without_reset:\n reset_model()\n if seeds is not None:\n return m.expand(seeds)\n if isinstance(m, ecell4_base.core.NetfreeModel):\n m.set_effective(effective)\n except Exception as e:\n reset_model()\n raise e\n return m", "docstring": "Generate a model with parameters in the global scope, ``SPECIES_ATTRIBUTES``\n and ``REACTIONRULES``.\n\n Parameters\n ----------\n is_netfree : bool, optional\n Return ``NetfreeModel`` if True, and ``NetworkModel`` if else.\n Default is False.\n without_reset : bool, optional\n Do not reset the global variables after the generation if True.\n Default is False.\n seeds : list, optional\n A list of seed ``Species`` for expanding the model.\n If this is not None, generate a ``NetfreeModel`` once, and return a\n ``NetworkModel``, which is an expanded form of that with the given seeds.\n Default is None.\n effective : bool, optional\n See ``NetfreeModel.effective`` and ``Netfree.set_effective``.\n Only meaningfull with option ``is_netfree=True``.\n Default is False\n\n Returns\n -------\n model : NetworkModel, NetfreeModel" }, { "code": "def from_list(cls, database, key, data, clear=False):\n arr = cls(database, key)\n if clear:\n arr.clear()\n arr.extend(data)\n return arr", "docstring": "Create and populate an Array object from a data dictionary." }, { "code": "def read_datafiles(files, dtype, column):\n pha = []\n pha_fpi = []\n for filename, filetype in zip(files, dtype):\n if filetype == 'cov':\n cov = load_cov(filename)\n elif filetype == 'mag':\n mag = load_rho(filename, column)\n elif filetype == 'pha':\n pha = load_rho(filename, 2)\n elif filetype == 'pha_fpi':\n pha_fpi = load_rho(filename, 2)\n return cov, mag, pha, pha_fpi", "docstring": "Load the datafiles and return cov, mag, phase and fpi phase values." }, { "code": "def report(data):\n work_dir = dd.get_work_dir(data[0][0])\n out_dir = op.join(work_dir, \"report\")\n safe_makedir(out_dir)\n summary_file = op.join(out_dir, \"summary.csv\")\n with file_transaction(summary_file) as out_tx:\n with open(out_tx, 'w') as out_handle:\n out_handle.write(\"sample_id,%s\\n\" % _guess_header(data[0][0]))\n for sample in data:\n info = sample[0]\n group = _guess_group(info)\n files = info[\"seqbuster\"] if \"seqbuster\" in info else \"None\"\n out_handle.write(\",\".join([dd.get_sample_name(info),\n group]) + \"\\n\")\n _modify_report(work_dir, out_dir)\n return summary_file", "docstring": "Create a Rmd report for small RNAseq analysis" }, { "code": "def cancel_signature_request(self, signature_request_id):\n request = self._get_request()\n request.post(url=self.SIGNATURE_REQUEST_CANCEL_URL + signature_request_id, get_json=False)", "docstring": "Cancels a SignatureRequest\n\n Cancels a SignatureRequest. After canceling, no one will be able to sign\n or access the SignatureRequest or its documents. Only the requester can\n cancel and only before everyone has signed.\n\n Args:\n\n signing_request_id (str): The id of the signature request to cancel\n\n Returns:\n None" }, { "code": "def do_move_to(self, element, decl, pseudo):\n target = serialize(decl.value).strip()\n step = self.state[self.state['current_step']]\n elem = self.current_target().tree\n actions = step['actions']\n for pos, action in enumerate(reversed(actions)):\n if action[0] == 'move' and action[1] == elem:\n target_index = - pos - 1\n actions[target_index:] = actions[target_index+1:]\n break\n _, valstep = self.lookup('pending', target)\n if not valstep:\n step['pending'][target] = [('move', elem)]\n else:\n self.state[valstep]['pending'][target].append(('move', elem))", "docstring": "Implement move-to declaration." }, { "code": "def is_obtuse(p1, v, p2):\n p1x = p1[:,1]\n p1y = p1[:,0]\n p2x = p2[:,1]\n p2y = p2[:,0]\n vx = v[:,1]\n vy = v[:,0]\n Dx = vx - p2x\n Dy = vy - p2y\n Dvp1x = p1x - vx\n Dvp1y = p1y - vy\n return Dvp1x * Dx + Dvp1y * Dy > 0", "docstring": "Determine whether the angle, p1 - v - p2 is obtuse\n \n p1 - N x 2 array of coordinates of first point on edge\n v - N x 2 array of vertex coordinates\n p2 - N x 2 array of coordinates of second point on edge\n \n returns vector of booleans" }, { "code": "def discover_handler_classes(handlers_package):\n if handlers_package is None:\n return\n sys.path.insert(0, os.getcwd())\n package = import_module(handlers_package)\n if hasattr(package, '__path__'):\n for _, modname, _ in pkgutil.iter_modules(package.__path__):\n import_module('{package}.{module}'.format(package=package.__name__, module=modname))\n return registered_handlers", "docstring": "Looks for handler classes within handler path module.\n\n Currently it's not looking deep into nested module.\n\n :param handlers_package: module path to handlers\n :type handlers_package: string\n :return: list of handler classes" }, { "code": "def track_change(self, instance, resolution_level=0):\n tobj = self.objects[id(instance)]\n tobj.set_resolution_level(resolution_level)", "docstring": "Change tracking options for the already tracked object 'instance'.\n If instance is not tracked, a KeyError will be raised." }, { "code": "def default_logging(grab_log=None,\n network_log=None,\n level=logging.DEBUG, mode='a',\n propagate_network_logger=False):\n logging.basicConfig(level=level)\n network_logger = logging.getLogger('grab.network')\n network_logger.propagate = propagate_network_logger\n if network_log:\n hdl = logging.FileHandler(network_log, mode)\n network_logger.addHandler(hdl)\n network_logger.setLevel(level)\n grab_logger = logging.getLogger('grab')\n if grab_log:\n hdl = logging.FileHandler(grab_log, mode)\n grab_logger.addHandler(hdl)\n grab_logger.setLevel(level)", "docstring": "Customize logging output to display all log messages\n except grab network logs.\n\n Redirect grab network logs into file." }, { "code": "def get_current_url(request, ignore_params=None):\n if ignore_params is None:\n ignore_params = set()\n protocol = u'https' if request.is_secure() else u\"http\"\n service_url = u\"%s://%s%s\" % (protocol, request.get_host(), request.path)\n if request.GET:\n params = copy_params(request.GET, ignore_params)\n if params:\n service_url += u\"?%s\" % urlencode(params)\n return service_url", "docstring": "Giving a django request, return the current http url, possibly ignoring some GET parameters\n\n :param django.http.HttpRequest request: The current request object.\n :param set ignore_params: An optional set of GET parameters to ignore\n :return: The URL of the current page, possibly omitting some parameters from\n ``ignore_params`` in the querystring.\n :rtype: unicode" }, { "code": "def shell_sqlalchemy(session: SqlalchemySession, backend: ShellBackend):\n namespace = {\n 'session': session\n }\n namespace.update(backend.get_namespace())\n embed(user_ns=namespace, header=backend.header)", "docstring": "This command includes SQLAlchemy DB Session" }, { "code": "def _FlushCache(cls, format_categories):\n if definitions.FORMAT_CATEGORY_ARCHIVE in format_categories:\n cls._archive_remainder_list = None\n cls._archive_scanner = None\n cls._archive_store = None\n if definitions.FORMAT_CATEGORY_COMPRESSED_STREAM in format_categories:\n cls._compressed_stream_remainder_list = None\n cls._compressed_stream_scanner = None\n cls._compressed_stream_store = None\n if definitions.FORMAT_CATEGORY_FILE_SYSTEM in format_categories:\n cls._file_system_remainder_list = None\n cls._file_system_scanner = None\n cls._file_system_store = None\n if definitions.FORMAT_CATEGORY_STORAGE_MEDIA_IMAGE in format_categories:\n cls._storage_media_image_remainder_list = None\n cls._storage_media_image_scanner = None\n cls._storage_media_image_store = None\n if definitions.FORMAT_CATEGORY_VOLUME_SYSTEM in format_categories:\n cls._volume_system_remainder_list = None\n cls._volume_system_scanner = None\n cls._volume_system_store = None", "docstring": "Flushes the cached objects for the specified format categories.\n\n Args:\n format_categories (set[str]): format categories." }, { "code": "def capture(self, event_type, data=None, date=None, time_spent=None,\n extra=None, stack=None, tags=None, sample_rate=None,\n **kwargs):\n if not self.is_enabled():\n return\n exc_info = kwargs.get('exc_info')\n if exc_info is not None:\n if self.skip_error_for_logging(exc_info):\n return\n elif not self.should_capture(exc_info):\n self.logger.info(\n 'Not capturing exception due to filters: %s', exc_info[0],\n exc_info=sys.exc_info())\n return\n self.record_exception_seen(exc_info)\n data = self.build_msg(\n event_type, data, date, time_spent, extra, stack, tags=tags,\n **kwargs)\n if sample_rate is None:\n sample_rate = self.sample_rate\n if self._random.random() < sample_rate:\n self.send(**data)\n self._local_state.last_event_id = data['event_id']\n return data['event_id']", "docstring": "Captures and processes an event and pipes it off to SentryClient.send.\n\n To use structured data (interfaces) with capture:\n\n >>> capture('raven.events.Message', message='foo', data={\n >>> 'request': {\n >>> 'url': '...',\n >>> 'data': {},\n >>> 'query_string': '...',\n >>> 'method': 'POST',\n >>> },\n >>> 'logger': 'logger.name',\n >>> }, extra={\n >>> 'key': 'value',\n >>> })\n\n The finalized ``data`` structure contains the following (some optional)\n builtin values:\n\n >>> {\n >>> # the culprit and version information\n >>> 'culprit': 'full.module.name', # or /arbitrary/path\n >>>\n >>> # all detectable installed modules\n >>> 'modules': {\n >>> 'full.module.name': 'version string',\n >>> },\n >>>\n >>> # arbitrary data provided by user\n >>> 'extra': {\n >>> 'key': 'value',\n >>> }\n >>> }\n\n :param event_type: the module path to the Event class. Builtins can use\n shorthand class notation and exclude the full module\n path.\n :param data: the data base, useful for specifying structured data\n interfaces. Any key which contains a '.' will be\n assumed to be a data interface.\n :param date: the datetime of this event\n :param time_spent: a integer value representing the duration of the\n event (in milliseconds)\n :param extra: a dictionary of additional standard metadata\n :param stack: a stacktrace for the event\n :param tags: dict of extra tags\n :param sample_rate: a float in the range [0, 1] to sample this message\n :return: a 32-length string identifying this event" }, { "code": "def prevmonday(num):\n today = get_today()\n lastmonday = today - timedelta(days=today.weekday(), weeks=num)\n return lastmonday", "docstring": "Return unix SECOND timestamp of \"num\" mondays ago" }, { "code": "def _load_physical_network_mappings(self, phys_net_vswitch_mappings):\n for mapping in phys_net_vswitch_mappings:\n parts = mapping.split(':')\n if len(parts) != 2:\n LOG.debug('Invalid physical network mapping: %s', mapping)\n else:\n pattern = re.escape(parts[0].strip()).replace('\\\\*', '.*')\n pattern = pattern + '$'\n vswitch = parts[1].strip()\n self._physical_network_mappings[pattern] = vswitch", "docstring": "Load all the information regarding the physical network." }, { "code": "def _add_current_quay_tag(repo, container_tags):\n if ':' in repo:\n return repo, container_tags\n try:\n latest_tag = container_tags[repo]\n except KeyError:\n repo_id = repo[repo.find('/') + 1:]\n tags = requests.request(\"GET\", \"https://quay.io/api/v1/repository/\" + repo_id).json()[\"tags\"]\n latest_tag = None\n latest_modified = None\n for tag, info in tags.items():\n if latest_tag:\n if (dateutil.parser.parse(info['last_modified']) > dateutil.parser.parse(latest_modified)\n and tag != 'latest'):\n latest_modified = info['last_modified']\n latest_tag = tag\n else:\n latest_modified = info['last_modified']\n latest_tag = tag\n container_tags[repo] = str(latest_tag)\n latest_pull = repo + ':' + str(latest_tag)\n return latest_pull, container_tags", "docstring": "Lookup the current quay tag for the repository, adding to repo string.\n\n Enables generation of CWL explicitly tied to revisions." }, { "code": "def monitor_deletion():\n monitors = {}\n def set_deleted(x):\n def _(weakref):\n del monitors[x]\n return _\n def monitor(item, name):\n monitors[name] = ref(item, set_deleted(name))\n def is_alive(name):\n return monitors.get(name, None) is not None\n return monitor, is_alive", "docstring": "Function for checking for correct deletion of weakref-able objects.\n\n Example usage::\n\n monitor, is_alive = monitor_deletion()\n obj = set()\n monitor(obj, \"obj\")\n assert is_alive(\"obj\") # True because there is a ref to `obj` is_alive\n del obj\n assert not is_alive(\"obj\") # True because there `obj` is deleted" }, { "code": "def splitkeyurl(url):\n key = url[-22:]\n urlid = url[-34:-24]\n service = url[:-43]\n return service, urlid, key", "docstring": "Splits a Send url into key, urlid and 'prefix' for the Send server\n Should handle any hostname, but will brake on key & id length changes" }, { "code": "def guess_file_name_stream_type_header(args):\n ftype = None\n fheader = None\n if isinstance(args, (tuple, list)):\n if len(args) == 2:\n fname, fstream = args\n elif len(args) == 3:\n fname, fstream, ftype = args\n else:\n fname, fstream, ftype, fheader = args\n else:\n fname, fstream = guess_filename_stream(args)\n ftype = guess_content_type(fname)\n if isinstance(fstream, (str, bytes, bytearray)):\n fdata = fstream\n else:\n fdata = fstream.read()\n return fname, fdata, ftype, fheader", "docstring": "Guess filename, file stream, file type, file header from args.\n\n :param args: may be string (filepath), 2-tuples (filename, fileobj), 3-tuples (filename, fileobj,\n contentype) or 4-tuples (filename, fileobj, contentype, custom_headers).\n :return: filename, file stream, file type, file header" }, { "code": "def sortJobs(jobTypes, options):\n longforms = {\"med\": \"median\",\n \"ave\": \"average\",\n \"min\": \"min\",\n \"total\": \"total\",\n \"max\": \"max\",}\n sortField = longforms[options.sortField]\n if (options.sortCategory == \"time\" or\n options.sortCategory == \"clock\" or\n options.sortCategory == \"wait\" or\n options.sortCategory == \"memory\"\n ):\n return sorted(\n jobTypes,\n key=lambda tag: getattr(tag, \"%s_%s\"\n % (sortField, options.sortCategory)),\n reverse=options.sortReverse)\n elif options.sortCategory == \"alpha\":\n return sorted(\n jobTypes, key=lambda tag: tag.name,\n reverse=options.sortReverse)\n elif options.sortCategory == \"count\":\n return sorted(jobTypes, key=lambda tag: tag.total_number,\n reverse=options.sortReverse)", "docstring": "Return a jobTypes all sorted." }, { "code": "def has_perm(self, user_obj, perm, obj=None):\n if not is_authenticated(user_obj):\n return False\n change_permission = self.get_full_permission_string('change')\n delete_permission = self.get_full_permission_string('delete')\n if obj is None:\n if self.any_permission:\n return True\n if self.change_permission and perm == change_permission:\n return True\n if self.delete_permission and perm == delete_permission:\n return True\n return False\n elif user_obj.is_active:\n if obj == user_obj:\n if self.any_permission:\n return True\n if (self.change_permission and\n perm == change_permission):\n return True\n if (self.delete_permission and\n perm == delete_permission):\n return True\n return False", "docstring": "Check if user have permission of himself\n\n If the user_obj is not authenticated, it return ``False``.\n\n If no object is specified, it return ``True`` when the corresponding\n permission was specified to ``True`` (changed from v0.7.0).\n This behavior is based on the django system.\n https://code.djangoproject.com/wiki/RowLevelPermissions\n\n If an object is specified, it will return ``True`` if the object is the\n user.\n So users can change or delete themselves (you can change this behavior\n to set ``any_permission``, ``change_permissino`` or\n ``delete_permission`` attributes of this instance).\n\n Parameters\n ----------\n user_obj : django user model instance\n A django user model instance which be checked\n perm : string\n `app_label.codename` formatted permission string\n obj : None or django model instance\n None or django model instance for object permission\n\n Returns\n -------\n boolean\n Whether the specified user have specified permission (of specified\n object)." }, { "code": "def choose(formatter, value, name, option, format):\n if not option:\n return\n words = format.split('|')\n num_words = len(words)\n if num_words < 2:\n return\n choices = option.split('|')\n num_choices = len(choices)\n if num_words not in (num_choices, num_choices + 1):\n n = num_choices\n raise ValueError('specify %d or %d choices' % (n, n + 1))\n choice = get_choice(value)\n try:\n index = choices.index(choice)\n except ValueError:\n if num_words == num_choices:\n raise ValueError('no default choice supplied')\n index = -1\n return formatter.format(words[index], value)", "docstring": "Adds simple logic to format strings.\n\n Spec: `{:c[hoose](choice1|choice2|...):word1|word2|...[|default]}`\n\n Example::\n\n >>> smart.format(u'{num:choose(1|2|3):one|two|three|other}, num=1)\n u'one'\n >>> smart.format(u'{num:choose(1|2|3):one|two|three|other}, num=4)\n u'other'" }, { "code": "def authorize(ctx, public_key, append):\n wva = get_wva(ctx)\n http_client = wva.get_http_client()\n authorized_keys_uri = \"/files/userfs/WEB/python/.ssh/authorized_keys\"\n authorized_key_contents = public_key\n if append:\n try:\n existing_contents = http_client.get(authorized_keys_uri)\n authorized_key_contents = \"{}\\n{}\".format(existing_contents, public_key)\n except WVAHttpNotFoundError:\n pass\n http_client.put(authorized_keys_uri, authorized_key_contents)\n print(\"Public key written to authorized_keys for python user.\")\n print(\"You should now be able to ssh to the device by doing the following:\")\n print(\"\")\n print(\" $ ssh python@{}\".format(get_root_ctx(ctx).hostname))", "docstring": "Enable ssh login as the Python user for the current user\n\nThis command will create an authorized_keys file on the target device\ncontaining the current users public key. This will allow ssh to\nthe WVA from this machine." }, { "code": "def output_snapshot_profile(gandi, profile, output_keys, justify=13):\n schedules = 'schedules' in output_keys\n if schedules:\n output_keys.remove('schedules')\n output_generic(gandi, profile, output_keys, justify)\n if schedules:\n schedule_keys = ['name', 'kept_version']\n for schedule in profile['schedules']:\n gandi.separator_line()\n output_generic(gandi, schedule, schedule_keys, justify)", "docstring": "Helper to output a snapshot_profile." }, { "code": "def _check_key(self, key):\n if not len(key) == 2:\n raise TypeError('invalid key: %r' % key)\n elif key[1] not in TYPES:\n raise TypeError('invalid datatype: %s' % key[1])", "docstring": "Ensures well-formedness of a key." }, { "code": "def iter_events(self, public=False, number=-1, etag=None):\n path = ['events']\n if public:\n path.append('public')\n url = self._build_url(*path, base_url=self._api)\n return self._iter(int(number), url, Event, etag=etag)", "docstring": "Iterate over events performed by this user.\n\n :param bool public: (optional), only list public events for the\n authenticated user\n :param int number: (optional), number of events to return. Default: -1\n returns all available events.\n :param str etag: (optional), ETag from a previous request to the same\n endpoint\n :returns: list of :class:`Event `\\ s" }, { "code": "def wait_until(what, times=-1):\n while times:\n logger.info('Waiting times left %d', times)\n try:\n if what() is True:\n return True\n except:\n logger.exception('Wait failed')\n else:\n logger.warning('Trial[%d] failed', times)\n times -= 1\n time.sleep(1)\n return False", "docstring": "Wait until `what` return True\n\n Args:\n what (Callable[bool]): Call `wait()` again and again until it returns True\n times (int): Maximum times of trials before giving up\n\n Returns:\n True if success, False if times threshold reached" }, { "code": "def init(textCNN, vocab, model_mode, context, lr):\n textCNN.initialize(mx.init.Xavier(), ctx=context, force_reinit=True)\n if model_mode != 'rand':\n textCNN.embedding.weight.set_data(vocab.embedding.idx_to_vec)\n if model_mode == 'multichannel':\n textCNN.embedding_extend.weight.set_data(vocab.embedding.idx_to_vec)\n if model_mode == 'static' or model_mode == 'multichannel':\n textCNN.embedding.collect_params().setattr('grad_req', 'null')\n trainer = gluon.Trainer(textCNN.collect_params(), 'adam', {'learning_rate': lr})\n return textCNN, trainer", "docstring": "Initialize parameters." }, { "code": "def item(self):\n url = self._contentURL\n return Item(url=self._contentURL,\n securityHandler=self._securityHandler,\n proxy_url=self._proxy_url,\n proxy_port=self._proxy_port,\n initalize=True)", "docstring": "returns the Item class of an Item" }, { "code": "def pending_assignment(self):\n return {\n self.partitions[pid].name: [\n self.brokers[bid].id for bid in self.replicas[pid]\n ]\n for pid in set(self.pending_partitions)\n }", "docstring": "Return the pending partition assignment that this state represents." }, { "code": "def reset(self):\n self.alive.value = False\n qsize = 0\n try:\n while True:\n self.queue.get(timeout=0.1)\n qsize += 1\n except QEmptyExcept:\n pass\n print(\"Queue size on reset: {}\".format(qsize))\n for i, p in enumerate(self.proc):\n p.join()\n self.proc.clear()", "docstring": "Resets the generator by stopping all processes" }, { "code": "def _make_property_from_dict(self, property_def: Dict) -> Property:\n property_hash = hash_dump(property_def)\n edge_property_model = self.object_cache_property.get(property_hash)\n if edge_property_model is None:\n edge_property_model = self.get_property_by_hash(property_hash)\n if not edge_property_model:\n property_def['sha512'] = property_hash\n edge_property_model = Property(**property_def)\n self.object_cache_property[property_hash] = edge_property_model\n return edge_property_model", "docstring": "Build an edge property from a dictionary." }, { "code": "def del_node(self, name, index=None):\n if isinstance(name, Node):\n name = name.get_name()\n if name in self.obj_dict['nodes']:\n if (index is not None and\n index < len(self.obj_dict['nodes'][name])):\n del self.obj_dict['nodes'][name][index]\n return True\n else:\n del self.obj_dict['nodes'][name]\n return True\n return False", "docstring": "Delete a node from the graph.\n\n Given a node's name all node(s) with that same name\n will be deleted if 'index' is not specified or set\n to None.\n If there are several nodes with that same name and\n 'index' is given, only the node in that position\n will be deleted.\n\n 'index' should be an integer specifying the position\n of the node to delete. If index is larger than the\n number of nodes with that name, no action is taken.\n\n If nodes are deleted it returns True. If no action\n is taken it returns False." }, { "code": "def server_args(self, parsed_args):\n args = {\n arg: value\n for arg, value in vars(parsed_args).items()\n if not arg.startswith('_') and value is not None\n }\n args.update(vars(self))\n return args", "docstring": "Return keyword args for Server class." }, { "code": "def monitor(self, message, *args, **kws):\n if self.isEnabledFor(MON):\n self._log(MON, message, args, **kws)", "docstring": "Define a monitoring logger that will be added to Logger\n\n :param self: The logging object\n :param message: The logging message\n :param args: Positional arguments\n :param kws: Keyword arguments\n :return:" }, { "code": "def create_ecdsap256_key_pair():\n pub = ECDSAP256PublicKey()\n priv = ECDSAP256PrivateKey()\n rc = _lib.xtt_crypto_create_ecdsap256_key_pair(pub.native, priv.native)\n if rc == RC.SUCCESS:\n return (pub, priv)\n else:\n raise error_from_code(rc)", "docstring": "Create a new ECDSAP256 key pair.\n\n :returns: a tuple of the public and private keys" }, { "code": "def _distance_squared(self, p2: \"Point2\") -> Union[int, float]:\n return (self[0] - p2[0]) ** 2 + (self[1] - p2[1]) ** 2", "docstring": "Function used to not take the square root as the distances will stay proportionally the same. This is to speed up the sorting process." }, { "code": "def offsets(self, group=None):\n if not group:\n return {\n 'fetch': self.offsets('fetch'),\n 'commit': self.offsets('commit'),\n 'task_done': self.offsets('task_done'),\n 'highwater': self.offsets('highwater')\n }\n else:\n return dict(deepcopy(getattr(self._offsets, group)))", "docstring": "Get internal consumer offset values\n\n Keyword Arguments:\n group: Either \"fetch\", \"commit\", \"task_done\", or \"highwater\".\n If no group specified, returns all groups.\n\n Returns:\n A copy of internal offsets struct" }, { "code": "def ufo_create_background_layer_for_all_glyphs(ufo_font):\n if \"public.background\" in ufo_font.layers:\n background = ufo_font.layers[\"public.background\"]\n else:\n background = ufo_font.newLayer(\"public.background\")\n for glyph in ufo_font:\n if glyph.name not in background:\n background.newGlyph(glyph.name)", "docstring": "Create a background layer for all glyphs in ufo_font if not present to\n reduce roundtrip differences." }, { "code": "def get(self, key, filepath):\n if not filepath:\n raise RuntimeError(\"Configuration file not given\")\n if not self.__check_config_key(key):\n raise RuntimeError(\"%s parameter does not exists\" % key)\n if not os.path.isfile(filepath):\n raise RuntimeError(\"%s config file does not exist\" % filepath)\n section, option = key.split('.')\n config = configparser.SafeConfigParser()\n config.read(filepath)\n try:\n option = config.get(section, option)\n self.display('config.tmpl', key=key, option=option)\n except (configparser.NoSectionError, configparser.NoOptionError):\n pass\n return CMD_SUCCESS", "docstring": "Get configuration parameter.\n\n Reads 'key' configuration parameter from the configuration file given\n in 'filepath'. Configuration parameter in 'key' must follow the schema\n
.