code
stringlengths
75
104k
docstring
stringlengths
1
46.9k
text
stringlengths
164
112k
async def wait_for_election_success(cls): """Await this function if your cluster must have a leader""" if cls.leader is None: cls.leader_future = asyncio.Future(loop=cls.loop) await cls.leader_future
Await this function if your cluster must have a leader
Below is the the instruction that describes the task: ### Input: Await this function if your cluster must have a leader ### Response: async def wait_for_election_success(cls): """Await this function if your cluster must have a leader""" if cls.leader is None: cls.leader_future = asyncio.Future(loop=cls.loop) await cls.leader_future
def alias_repository(self, repository_id, alias_id): """Adds an ``Id`` to a ``Repository`` for the purpose of creating compatibility. The primary ``Id`` of the ``Repository`` is determined by the provider. The new ``Id`` is an alias to the primary ``Id``. If the alias is a pointer to another repository, it is reassigned to the given repository ``Id``. arg: repository_id (osid.id.Id): the ``Id`` of a ``Repository`` arg: alias_id (osid.id.Id): the alias ``Id`` raise: AlreadyExists - ``alias_id`` is in use as a primary ``Id`` raise: NotFound - ``repository_id`` not found raise: NullArgument - ``repository_id`` or ``alias_id`` is ``null`` raise: OperationFailed - unable to complete request raise: PermissionDenied - authorization failure *compliance: mandatory -- This method must be implemented.* """ # Implemented from template for # osid.resource.BinLookupSession.alias_bin_template if self._catalog_session is not None: return self._catalog_session.alias_catalog(catalog_id=repository_id, alias_id=alias_id) self._alias_id(primary_id=repository_id, equivalent_id=alias_id)
Adds an ``Id`` to a ``Repository`` for the purpose of creating compatibility. The primary ``Id`` of the ``Repository`` is determined by the provider. The new ``Id`` is an alias to the primary ``Id``. If the alias is a pointer to another repository, it is reassigned to the given repository ``Id``. arg: repository_id (osid.id.Id): the ``Id`` of a ``Repository`` arg: alias_id (osid.id.Id): the alias ``Id`` raise: AlreadyExists - ``alias_id`` is in use as a primary ``Id`` raise: NotFound - ``repository_id`` not found raise: NullArgument - ``repository_id`` or ``alias_id`` is ``null`` raise: OperationFailed - unable to complete request raise: PermissionDenied - authorization failure *compliance: mandatory -- This method must be implemented.*
Below is the the instruction that describes the task: ### Input: Adds an ``Id`` to a ``Repository`` for the purpose of creating compatibility. The primary ``Id`` of the ``Repository`` is determined by the provider. The new ``Id`` is an alias to the primary ``Id``. If the alias is a pointer to another repository, it is reassigned to the given repository ``Id``. arg: repository_id (osid.id.Id): the ``Id`` of a ``Repository`` arg: alias_id (osid.id.Id): the alias ``Id`` raise: AlreadyExists - ``alias_id`` is in use as a primary ``Id`` raise: NotFound - ``repository_id`` not found raise: NullArgument - ``repository_id`` or ``alias_id`` is ``null`` raise: OperationFailed - unable to complete request raise: PermissionDenied - authorization failure *compliance: mandatory -- This method must be implemented.* ### Response: def alias_repository(self, repository_id, alias_id): """Adds an ``Id`` to a ``Repository`` for the purpose of creating compatibility. The primary ``Id`` of the ``Repository`` is determined by the provider. The new ``Id`` is an alias to the primary ``Id``. If the alias is a pointer to another repository, it is reassigned to the given repository ``Id``. arg: repository_id (osid.id.Id): the ``Id`` of a ``Repository`` arg: alias_id (osid.id.Id): the alias ``Id`` raise: AlreadyExists - ``alias_id`` is in use as a primary ``Id`` raise: NotFound - ``repository_id`` not found raise: NullArgument - ``repository_id`` or ``alias_id`` is ``null`` raise: OperationFailed - unable to complete request raise: PermissionDenied - authorization failure *compliance: mandatory -- This method must be implemented.* """ # Implemented from template for # osid.resource.BinLookupSession.alias_bin_template if self._catalog_session is not None: return self._catalog_session.alias_catalog(catalog_id=repository_id, alias_id=alias_id) self._alias_id(primary_id=repository_id, equivalent_id=alias_id)
def get_managed_policies(group, **conn): """Get a list of the managed policy names that are attached to the group.""" managed_policies = list_attached_group_managed_policies(group['GroupName'], **conn) managed_policy_names = [] for policy in managed_policies: managed_policy_names.append(policy['PolicyName']) return managed_policy_names
Get a list of the managed policy names that are attached to the group.
Below is the the instruction that describes the task: ### Input: Get a list of the managed policy names that are attached to the group. ### Response: def get_managed_policies(group, **conn): """Get a list of the managed policy names that are attached to the group.""" managed_policies = list_attached_group_managed_policies(group['GroupName'], **conn) managed_policy_names = [] for policy in managed_policies: managed_policy_names.append(policy['PolicyName']) return managed_policy_names
def delete(self, template_id, session): '''taobao.delivery.template.delete 删除运费模板 根据用户指定的模板ID删除指定的模板''' request = TOPRequest('taobao.delivery.template.delete') request['template_id'] = template_id self.create(self.execute(request, session), fields=['complete', ]) return self.complete
taobao.delivery.template.delete 删除运费模板 根据用户指定的模板ID删除指定的模板
Below is the the instruction that describes the task: ### Input: taobao.delivery.template.delete 删除运费模板 根据用户指定的模板ID删除指定的模板 ### Response: def delete(self, template_id, session): '''taobao.delivery.template.delete 删除运费模板 根据用户指定的模板ID删除指定的模板''' request = TOPRequest('taobao.delivery.template.delete') request['template_id'] = template_id self.create(self.execute(request, session), fields=['complete', ]) return self.complete
def set_parent(self, new_site): """ Set self.site as either an empty string, or with a new Site. """ if new_site: if not isinstance(new_site, Site): raise Exception self.site = new_site self.propagate_data() return new_site
Set self.site as either an empty string, or with a new Site.
Below is the the instruction that describes the task: ### Input: Set self.site as either an empty string, or with a new Site. ### Response: def set_parent(self, new_site): """ Set self.site as either an empty string, or with a new Site. """ if new_site: if not isinstance(new_site, Site): raise Exception self.site = new_site self.propagate_data() return new_site
def add_blank_row(self, label): """ Add a blank row with only an index value to self.df. This is done inplace. """ col_labels = self.df.columns blank_item = pd.Series({}, index=col_labels, name=label) # use .loc to add in place (append won't do that) self.df.loc[blank_item.name] = blank_item return self.df
Add a blank row with only an index value to self.df. This is done inplace.
Below is the the instruction that describes the task: ### Input: Add a blank row with only an index value to self.df. This is done inplace. ### Response: def add_blank_row(self, label): """ Add a blank row with only an index value to self.df. This is done inplace. """ col_labels = self.df.columns blank_item = pd.Series({}, index=col_labels, name=label) # use .loc to add in place (append won't do that) self.df.loc[blank_item.name] = blank_item return self.df
def hierarchy_cycles(rdf, fix=False): """Check if the graph contains skos:broader cycles and optionally break these. :param Graph rdf: An rdflib.graph.Graph object. :param bool fix: Fix the problem by removing any skos:broader that overlaps with skos:broaderTransitive. """ top_concepts = sorted(rdf.subject_objects(SKOS.hasTopConcept)) status = {} for cs, root in top_concepts: _hierarchy_cycles_visit( rdf, root, None, fix, status=status) # double check that all concepts were actually visited in the search, # and visit remaining ones if necessary recheck_top_concepts = False for conc in sorted(rdf.subjects(RDF.type, SKOS.Concept)): if conc not in status: recheck_top_concepts = True _hierarchy_cycles_visit( rdf, conc, None, fix, status=status) return recheck_top_concepts
Check if the graph contains skos:broader cycles and optionally break these. :param Graph rdf: An rdflib.graph.Graph object. :param bool fix: Fix the problem by removing any skos:broader that overlaps with skos:broaderTransitive.
Below is the the instruction that describes the task: ### Input: Check if the graph contains skos:broader cycles and optionally break these. :param Graph rdf: An rdflib.graph.Graph object. :param bool fix: Fix the problem by removing any skos:broader that overlaps with skos:broaderTransitive. ### Response: def hierarchy_cycles(rdf, fix=False): """Check if the graph contains skos:broader cycles and optionally break these. :param Graph rdf: An rdflib.graph.Graph object. :param bool fix: Fix the problem by removing any skos:broader that overlaps with skos:broaderTransitive. """ top_concepts = sorted(rdf.subject_objects(SKOS.hasTopConcept)) status = {} for cs, root in top_concepts: _hierarchy_cycles_visit( rdf, root, None, fix, status=status) # double check that all concepts were actually visited in the search, # and visit remaining ones if necessary recheck_top_concepts = False for conc in sorted(rdf.subjects(RDF.type, SKOS.Concept)): if conc not in status: recheck_top_concepts = True _hierarchy_cycles_visit( rdf, conc, None, fix, status=status) return recheck_top_concepts
def temp_directory(*args, **kwargs): """ Context manager returns a path created by mkdtemp and cleans it up afterwards. """ path = tempfile.mkdtemp(*args, **kwargs) try: yield path finally: shutil.rmtree(path)
Context manager returns a path created by mkdtemp and cleans it up afterwards.
Below is the the instruction that describes the task: ### Input: Context manager returns a path created by mkdtemp and cleans it up afterwards. ### Response: def temp_directory(*args, **kwargs): """ Context manager returns a path created by mkdtemp and cleans it up afterwards. """ path = tempfile.mkdtemp(*args, **kwargs) try: yield path finally: shutil.rmtree(path)
def as_url(cls, api=None, name_prefix='', url_prefix=''): """ Generate url for resource. :return RegexURLPattern: Django URL """ url_prefix = url_prefix and "%s/" % url_prefix name_prefix = name_prefix and "%s-" % name_prefix url_regex = '^%s%s/?$' % ( url_prefix, cls._meta.url_regex.lstrip('^').rstrip('/$')) url_regex = url_regex.replace('//', '/') url_name = '%s%s' % (name_prefix, cls._meta.url_name) return url(url_regex, cls.as_view(api=api), name=url_name)
Generate url for resource. :return RegexURLPattern: Django URL
Below is the the instruction that describes the task: ### Input: Generate url for resource. :return RegexURLPattern: Django URL ### Response: def as_url(cls, api=None, name_prefix='', url_prefix=''): """ Generate url for resource. :return RegexURLPattern: Django URL """ url_prefix = url_prefix and "%s/" % url_prefix name_prefix = name_prefix and "%s-" % name_prefix url_regex = '^%s%s/?$' % ( url_prefix, cls._meta.url_regex.lstrip('^').rstrip('/$')) url_regex = url_regex.replace('//', '/') url_name = '%s%s' % (name_prefix, cls._meta.url_name) return url(url_regex, cls.as_view(api=api), name=url_name)
def parse_range_list(ranges): """Split a string like 2,3-5,8,9-11 into a list of integers. This is intended to ease adding command-line options for dealing with affinity. """ if not ranges: return [] parts = ranges.split(',') out = [] for part in parts: fields = part.split('-', 1) if len(fields) == 2: start = int(fields[0]) end = int(fields[1]) out.extend(range(start, end + 1)) else: out.append(int(fields[0])) return out
Split a string like 2,3-5,8,9-11 into a list of integers. This is intended to ease adding command-line options for dealing with affinity.
Below is the the instruction that describes the task: ### Input: Split a string like 2,3-5,8,9-11 into a list of integers. This is intended to ease adding command-line options for dealing with affinity. ### Response: def parse_range_list(ranges): """Split a string like 2,3-5,8,9-11 into a list of integers. This is intended to ease adding command-line options for dealing with affinity. """ if not ranges: return [] parts = ranges.split(',') out = [] for part in parts: fields = part.split('-', 1) if len(fields) == 2: start = int(fields[0]) end = int(fields[1]) out.extend(range(start, end + 1)) else: out.append(int(fields[0])) return out
def set_host(ip, alias): ''' Set the host entry in the hosts file for the given ip, this will overwrite any previous entry for the given ip .. versionchanged:: 2016.3.0 If ``alias`` does not include any host names (it is the empty string or contains only whitespace), all entries for the given IP address are removed. CLI Example: .. code-block:: bash salt '*' hosts.set_host <ip> <alias> ''' hfn = _get_or_create_hostfile() ovr = False if not os.path.isfile(hfn): return False # Make sure future calls to _list_hosts() will re-read the file __context__.pop('hosts._list_hosts', None) line_to_add = salt.utils.stringutils.to_bytes( ip + '\t\t' + alias + os.linesep ) # support removing a host entry by providing an empty string if not alias.strip(): line_to_add = b'' with salt.utils.files.fopen(hfn, 'rb') as fp_: lines = fp_.readlines() for ind, _ in enumerate(lines): tmpline = lines[ind].strip() if not tmpline: continue if tmpline.startswith(b'#'): continue comps = tmpline.split() if comps[0] == salt.utils.stringutils.to_bytes(ip): if not ovr: lines[ind] = line_to_add ovr = True else: # remove other entries lines[ind] = b'' linesep_bytes = salt.utils.stringutils.to_bytes(os.linesep) if not ovr: # make sure there is a newline if lines and not lines[-1].endswith(linesep_bytes): lines[-1] += linesep_bytes line = line_to_add lines.append(line) with salt.utils.files.fopen(hfn, 'wb') as ofile: ofile.writelines(lines) return True
Set the host entry in the hosts file for the given ip, this will overwrite any previous entry for the given ip .. versionchanged:: 2016.3.0 If ``alias`` does not include any host names (it is the empty string or contains only whitespace), all entries for the given IP address are removed. CLI Example: .. code-block:: bash salt '*' hosts.set_host <ip> <alias>
Below is the the instruction that describes the task: ### Input: Set the host entry in the hosts file for the given ip, this will overwrite any previous entry for the given ip .. versionchanged:: 2016.3.0 If ``alias`` does not include any host names (it is the empty string or contains only whitespace), all entries for the given IP address are removed. CLI Example: .. code-block:: bash salt '*' hosts.set_host <ip> <alias> ### Response: def set_host(ip, alias): ''' Set the host entry in the hosts file for the given ip, this will overwrite any previous entry for the given ip .. versionchanged:: 2016.3.0 If ``alias`` does not include any host names (it is the empty string or contains only whitespace), all entries for the given IP address are removed. CLI Example: .. code-block:: bash salt '*' hosts.set_host <ip> <alias> ''' hfn = _get_or_create_hostfile() ovr = False if not os.path.isfile(hfn): return False # Make sure future calls to _list_hosts() will re-read the file __context__.pop('hosts._list_hosts', None) line_to_add = salt.utils.stringutils.to_bytes( ip + '\t\t' + alias + os.linesep ) # support removing a host entry by providing an empty string if not alias.strip(): line_to_add = b'' with salt.utils.files.fopen(hfn, 'rb') as fp_: lines = fp_.readlines() for ind, _ in enumerate(lines): tmpline = lines[ind].strip() if not tmpline: continue if tmpline.startswith(b'#'): continue comps = tmpline.split() if comps[0] == salt.utils.stringutils.to_bytes(ip): if not ovr: lines[ind] = line_to_add ovr = True else: # remove other entries lines[ind] = b'' linesep_bytes = salt.utils.stringutils.to_bytes(os.linesep) if not ovr: # make sure there is a newline if lines and not lines[-1].endswith(linesep_bytes): lines[-1] += linesep_bytes line = line_to_add lines.append(line) with salt.utils.files.fopen(hfn, 'wb') as ofile: ofile.writelines(lines) return True
def init_with_context(self, context): """ Initialize the menu. """ # Apply the include/exclude patterns: listitems = self._visible_models(context['request']) # Convert to a similar data structure like the dashboard icons have. # This allows sorting the items identically. models = [ {'name': model._meta.model_name, 'app_name': model._meta.app_label, 'title': capfirst(model._meta.verbose_name_plural), 'url': self._get_admin_change_url(model, context) } for model, perms in listitems if self.is_item_visible(model, perms) ] # Sort models. sort_cms_models(models) # Convert to items for model in models: self.children.append(items.MenuItem(title=model['title'], url=model['url']))
Initialize the menu.
Below is the the instruction that describes the task: ### Input: Initialize the menu. ### Response: def init_with_context(self, context): """ Initialize the menu. """ # Apply the include/exclude patterns: listitems = self._visible_models(context['request']) # Convert to a similar data structure like the dashboard icons have. # This allows sorting the items identically. models = [ {'name': model._meta.model_name, 'app_name': model._meta.app_label, 'title': capfirst(model._meta.verbose_name_plural), 'url': self._get_admin_change_url(model, context) } for model, perms in listitems if self.is_item_visible(model, perms) ] # Sort models. sort_cms_models(models) # Convert to items for model in models: self.children.append(items.MenuItem(title=model['title'], url=model['url']))
def optimize(exp_rets, covs): """ Return parameters for portfolio optimization. Parameters ---------- exp_rets : ndarray Vector of expected returns for each investment.. covs : ndarray Covariance matrix for the given investments. Returns --------- a : ndarray The first vector (to be combined with target return as scalar) in the linear equation for optimal weights. b : ndarray The second (constant) vector in the linear equation for optimal weights. least_risk_ret : int The return achieved on the portfolio that combines the given equities so as to achieve the lowest possible risk. Notes --------- * The length of `exp_rets` must match the number of rows and columns in the `covs` matrix. * The weights for an optimal portfolio with expected return `ret` is given by the formula `w = ret * a + b` where `a` and `b` are the vectors returned here. The weights `w` for the portfolio with lowest risk are given by `w = least_risk_ret * a + b`. * An exception will be raised if the covariance matrix is singular or if each prospective investment has the same expected return. """ _cov_inv = np.linalg.inv(covs) # unit vector _u = np.ones((len(exp_rets))) # compute some dot products one time only _u_cov_inv = _u.dot(_cov_inv) _rets_cov_inv = exp_rets.dot(_cov_inv) # helper matrix for deriving Lagrange multipliers _m = np.empty((2, 2)) _m[0, 0] = _rets_cov_inv.dot(exp_rets) _m[0, 1] = _u_cov_inv.dot(exp_rets) _m[1, 0] = _rets_cov_inv.dot(_u) _m[1, 1] = _u_cov_inv.dot(_u) # compute values to return _m_inv = np.linalg.inv(_m) a = _m_inv[0, 0] * _rets_cov_inv + _m_inv[1, 0] * _u_cov_inv b = _m_inv[0, 1] * _rets_cov_inv + _m_inv[1, 1] * _u_cov_inv least_risk_ret = _m[0, 1] / _m[1, 1] return a, b, least_risk_ret
Return parameters for portfolio optimization. Parameters ---------- exp_rets : ndarray Vector of expected returns for each investment.. covs : ndarray Covariance matrix for the given investments. Returns --------- a : ndarray The first vector (to be combined with target return as scalar) in the linear equation for optimal weights. b : ndarray The second (constant) vector in the linear equation for optimal weights. least_risk_ret : int The return achieved on the portfolio that combines the given equities so as to achieve the lowest possible risk. Notes --------- * The length of `exp_rets` must match the number of rows and columns in the `covs` matrix. * The weights for an optimal portfolio with expected return `ret` is given by the formula `w = ret * a + b` where `a` and `b` are the vectors returned here. The weights `w` for the portfolio with lowest risk are given by `w = least_risk_ret * a + b`. * An exception will be raised if the covariance matrix is singular or if each prospective investment has the same expected return.
Below is the the instruction that describes the task: ### Input: Return parameters for portfolio optimization. Parameters ---------- exp_rets : ndarray Vector of expected returns for each investment.. covs : ndarray Covariance matrix for the given investments. Returns --------- a : ndarray The first vector (to be combined with target return as scalar) in the linear equation for optimal weights. b : ndarray The second (constant) vector in the linear equation for optimal weights. least_risk_ret : int The return achieved on the portfolio that combines the given equities so as to achieve the lowest possible risk. Notes --------- * The length of `exp_rets` must match the number of rows and columns in the `covs` matrix. * The weights for an optimal portfolio with expected return `ret` is given by the formula `w = ret * a + b` where `a` and `b` are the vectors returned here. The weights `w` for the portfolio with lowest risk are given by `w = least_risk_ret * a + b`. * An exception will be raised if the covariance matrix is singular or if each prospective investment has the same expected return. ### Response: def optimize(exp_rets, covs): """ Return parameters for portfolio optimization. Parameters ---------- exp_rets : ndarray Vector of expected returns for each investment.. covs : ndarray Covariance matrix for the given investments. Returns --------- a : ndarray The first vector (to be combined with target return as scalar) in the linear equation for optimal weights. b : ndarray The second (constant) vector in the linear equation for optimal weights. least_risk_ret : int The return achieved on the portfolio that combines the given equities so as to achieve the lowest possible risk. Notes --------- * The length of `exp_rets` must match the number of rows and columns in the `covs` matrix. * The weights for an optimal portfolio with expected return `ret` is given by the formula `w = ret * a + b` where `a` and `b` are the vectors returned here. The weights `w` for the portfolio with lowest risk are given by `w = least_risk_ret * a + b`. * An exception will be raised if the covariance matrix is singular or if each prospective investment has the same expected return. """ _cov_inv = np.linalg.inv(covs) # unit vector _u = np.ones((len(exp_rets))) # compute some dot products one time only _u_cov_inv = _u.dot(_cov_inv) _rets_cov_inv = exp_rets.dot(_cov_inv) # helper matrix for deriving Lagrange multipliers _m = np.empty((2, 2)) _m[0, 0] = _rets_cov_inv.dot(exp_rets) _m[0, 1] = _u_cov_inv.dot(exp_rets) _m[1, 0] = _rets_cov_inv.dot(_u) _m[1, 1] = _u_cov_inv.dot(_u) # compute values to return _m_inv = np.linalg.inv(_m) a = _m_inv[0, 0] * _rets_cov_inv + _m_inv[1, 0] * _u_cov_inv b = _m_inv[0, 1] * _rets_cov_inv + _m_inv[1, 1] * _u_cov_inv least_risk_ret = _m[0, 1] / _m[1, 1] return a, b, least_risk_ret
def _ite(f, g, h): """Return node that results from recursively applying ITE(f, g, h).""" # ITE(f, 1, 0) = f if g is BDDNODEONE and h is BDDNODEZERO: return f # ITE(f, 0, 1) = f' elif g is BDDNODEZERO and h is BDDNODEONE: return _neg(f) # ITE(1, g, h) = g elif f is BDDNODEONE: return g # ITE(0, g, h) = h elif f is BDDNODEZERO: return h # ITE(f, g, g) = g elif g is h: return g else: # ITE(f, g, h) = ITE(x, ITE(fx', gx', hx'), ITE(fx, gx, hx)) root = min(node.root for node in (f, g, h) if node.root > 0) npoint0 = {root: BDDNODEZERO} npoint1 = {root: BDDNODEONE} fv0, gv0, hv0 = [_restrict(node, npoint0) for node in (f, g, h)] fv1, gv1, hv1 = [_restrict(node, npoint1) for node in (f, g, h)] return _bddnode(root, _ite(fv0, gv0, hv0), _ite(fv1, gv1, hv1))
Return node that results from recursively applying ITE(f, g, h).
Below is the the instruction that describes the task: ### Input: Return node that results from recursively applying ITE(f, g, h). ### Response: def _ite(f, g, h): """Return node that results from recursively applying ITE(f, g, h).""" # ITE(f, 1, 0) = f if g is BDDNODEONE and h is BDDNODEZERO: return f # ITE(f, 0, 1) = f' elif g is BDDNODEZERO and h is BDDNODEONE: return _neg(f) # ITE(1, g, h) = g elif f is BDDNODEONE: return g # ITE(0, g, h) = h elif f is BDDNODEZERO: return h # ITE(f, g, g) = g elif g is h: return g else: # ITE(f, g, h) = ITE(x, ITE(fx', gx', hx'), ITE(fx, gx, hx)) root = min(node.root for node in (f, g, h) if node.root > 0) npoint0 = {root: BDDNODEZERO} npoint1 = {root: BDDNODEONE} fv0, gv0, hv0 = [_restrict(node, npoint0) for node in (f, g, h)] fv1, gv1, hv1 = [_restrict(node, npoint1) for node in (f, g, h)] return _bddnode(root, _ite(fv0, gv0, hv0), _ite(fv1, gv1, hv1))
def replace_csi_driver(self, name, body, **kwargs): """ replace the specified CSIDriver This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.replace_csi_driver(name, body, async_req=True) >>> result = thread.get() :param async_req bool :param str name: name of the CSIDriver (required) :param V1beta1CSIDriver body: (required) :param str pretty: If 'true', then the output is pretty printed. :param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed :param str field_manager: fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. :return: V1beta1CSIDriver If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.replace_csi_driver_with_http_info(name, body, **kwargs) else: (data) = self.replace_csi_driver_with_http_info(name, body, **kwargs) return data
replace the specified CSIDriver This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.replace_csi_driver(name, body, async_req=True) >>> result = thread.get() :param async_req bool :param str name: name of the CSIDriver (required) :param V1beta1CSIDriver body: (required) :param str pretty: If 'true', then the output is pretty printed. :param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed :param str field_manager: fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. :return: V1beta1CSIDriver If the method is called asynchronously, returns the request thread.
Below is the the instruction that describes the task: ### Input: replace the specified CSIDriver This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.replace_csi_driver(name, body, async_req=True) >>> result = thread.get() :param async_req bool :param str name: name of the CSIDriver (required) :param V1beta1CSIDriver body: (required) :param str pretty: If 'true', then the output is pretty printed. :param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed :param str field_manager: fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. :return: V1beta1CSIDriver If the method is called asynchronously, returns the request thread. ### Response: def replace_csi_driver(self, name, body, **kwargs): """ replace the specified CSIDriver This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True >>> thread = api.replace_csi_driver(name, body, async_req=True) >>> result = thread.get() :param async_req bool :param str name: name of the CSIDriver (required) :param V1beta1CSIDriver body: (required) :param str pretty: If 'true', then the output is pretty printed. :param str dry_run: When present, indicates that modifications should not be persisted. An invalid or unrecognized dryRun directive will result in an error response and no further processing of the request. Valid values are: - All: all dry run stages will be processed :param str field_manager: fieldManager is a name associated with the actor or entity that is making these changes. The value must be less than or 128 characters long, and only contain printable characters, as defined by https://golang.org/pkg/unicode/#IsPrint. :return: V1beta1CSIDriver If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async_req'): return self.replace_csi_driver_with_http_info(name, body, **kwargs) else: (data) = self.replace_csi_driver_with_http_info(name, body, **kwargs) return data
def load_manuf(filename): """Load manuf file from Wireshark. param: - filename: the file to load the manuf file from""" manufdb = ManufDA(_name=filename) with open(filename, "rb") as fdesc: for line in fdesc: try: line = line.strip() if not line or line.startswith(b"#"): continue parts = line.split(None, 2) oui, shrt = parts[:2] lng = parts[2].lstrip(b"#").strip() if len(parts) > 2 else "" lng = lng or shrt manufdb[oui] = plain_str(shrt), plain_str(lng) except Exception: log_loading.warning("Couldn't parse one line from [%s] [%r]", filename, line, exc_info=True) return manufdb
Load manuf file from Wireshark. param: - filename: the file to load the manuf file from
Below is the the instruction that describes the task: ### Input: Load manuf file from Wireshark. param: - filename: the file to load the manuf file from ### Response: def load_manuf(filename): """Load manuf file from Wireshark. param: - filename: the file to load the manuf file from""" manufdb = ManufDA(_name=filename) with open(filename, "rb") as fdesc: for line in fdesc: try: line = line.strip() if not line or line.startswith(b"#"): continue parts = line.split(None, 2) oui, shrt = parts[:2] lng = parts[2].lstrip(b"#").strip() if len(parts) > 2 else "" lng = lng or shrt manufdb[oui] = plain_str(shrt), plain_str(lng) except Exception: log_loading.warning("Couldn't parse one line from [%s] [%r]", filename, line, exc_info=True) return manufdb
def get_bytes_from_blob(val) -> bytes: """ 不同数据库从blob拿出的数据有所差别,有的是memoryview有的是bytes """ if isinstance(val, bytes): return val elif isinstance(val, memoryview): return val.tobytes() else: raise TypeError('invalid type for get bytes')
不同数据库从blob拿出的数据有所差别,有的是memoryview有的是bytes
Below is the the instruction that describes the task: ### Input: 不同数据库从blob拿出的数据有所差别,有的是memoryview有的是bytes ### Response: def get_bytes_from_blob(val) -> bytes: """ 不同数据库从blob拿出的数据有所差别,有的是memoryview有的是bytes """ if isinstance(val, bytes): return val elif isinstance(val, memoryview): return val.tobytes() else: raise TypeError('invalid type for get bytes')
def parent(self, resource): """Set parent resource :param resource: parent resource :type resource: Resource :raises ResourceNotFound: resource not found on the API """ resource.check() self['parent_type'] = resource.type self['parent_uuid'] = resource.uuid
Set parent resource :param resource: parent resource :type resource: Resource :raises ResourceNotFound: resource not found on the API
Below is the the instruction that describes the task: ### Input: Set parent resource :param resource: parent resource :type resource: Resource :raises ResourceNotFound: resource not found on the API ### Response: def parent(self, resource): """Set parent resource :param resource: parent resource :type resource: Resource :raises ResourceNotFound: resource not found on the API """ resource.check() self['parent_type'] = resource.type self['parent_uuid'] = resource.uuid
def _copy(master_fd, master_read=_read, stdin_read=_read): """Parent copy loop. Copies pty master -> standard output (master_read) standard input -> pty master (stdin_read)""" fds = [master_fd, STDIN_FILENO] while True: rfds, wfds, xfds = select(fds, [], []) if master_fd in rfds: data = master_read(master_fd) if not data: # Reached EOF. return else: os.write(STDOUT_FILENO, data) if STDIN_FILENO in rfds: data = stdin_read(STDIN_FILENO) if not data: fds.remove(STDIN_FILENO) else: _writen(master_fd, data)
Parent copy loop. Copies pty master -> standard output (master_read) standard input -> pty master (stdin_read)
Below is the the instruction that describes the task: ### Input: Parent copy loop. Copies pty master -> standard output (master_read) standard input -> pty master (stdin_read) ### Response: def _copy(master_fd, master_read=_read, stdin_read=_read): """Parent copy loop. Copies pty master -> standard output (master_read) standard input -> pty master (stdin_read)""" fds = [master_fd, STDIN_FILENO] while True: rfds, wfds, xfds = select(fds, [], []) if master_fd in rfds: data = master_read(master_fd) if not data: # Reached EOF. return else: os.write(STDOUT_FILENO, data) if STDIN_FILENO in rfds: data = stdin_read(STDIN_FILENO) if not data: fds.remove(STDIN_FILENO) else: _writen(master_fd, data)
def _generate_examples(self, label_images): """Generate example for each image in the dict.""" for label, image_paths in label_images.items(): for image_path in image_paths: yield { "image": image_path, "label": label, }
Generate example for each image in the dict.
Below is the the instruction that describes the task: ### Input: Generate example for each image in the dict. ### Response: def _generate_examples(self, label_images): """Generate example for each image in the dict.""" for label, image_paths in label_images.items(): for image_path in image_paths: yield { "image": image_path, "label": label, }
def bind_license(self, license_item_id=None): """ Auto bind license, uses dynamic if POS is not found :param str license_item_id: license id :raises LicenseError: binding license failed, possibly no licenses :return: None """ params = {'license_item_id': license_item_id} self.make_request( LicenseError, method='create', resource='bind', params=params)
Auto bind license, uses dynamic if POS is not found :param str license_item_id: license id :raises LicenseError: binding license failed, possibly no licenses :return: None
Below is the the instruction that describes the task: ### Input: Auto bind license, uses dynamic if POS is not found :param str license_item_id: license id :raises LicenseError: binding license failed, possibly no licenses :return: None ### Response: def bind_license(self, license_item_id=None): """ Auto bind license, uses dynamic if POS is not found :param str license_item_id: license id :raises LicenseError: binding license failed, possibly no licenses :return: None """ params = {'license_item_id': license_item_id} self.make_request( LicenseError, method='create', resource='bind', params=params)
def _super_pprint(obj, p, cycle): """The pprint for the super type.""" p.begin_group(8, '<super: ') p.pretty(obj.__self_class__) p.text(',') p.breakable() p.pretty(obj.__self__) p.end_group(8, '>')
The pprint for the super type.
Below is the the instruction that describes the task: ### Input: The pprint for the super type. ### Response: def _super_pprint(obj, p, cycle): """The pprint for the super type.""" p.begin_group(8, '<super: ') p.pretty(obj.__self_class__) p.text(',') p.breakable() p.pretty(obj.__self__) p.end_group(8, '>')
def encrypt(self, sa, esp, key): """ Encrypt an ESP packet @param sa: the SecurityAssociation associated with the ESP packet. @param esp: an unencrypted _ESPPlain packet with valid padding @param key: the secret key used for encryption @return: a valid ESP packet encrypted with this algorithm """ data = esp.data_for_encryption() if self.cipher: mode_iv = self._format_mode_iv(algo=self, sa=sa, iv=esp.iv) cipher = self.new_cipher(key, mode_iv) encryptor = cipher.encryptor() if self.is_aead: aad = struct.pack('!LL', esp.spi, esp.seq) encryptor.authenticate_additional_data(aad) data = encryptor.update(data) + encryptor.finalize() data += encryptor.tag[:self.icv_size] else: data = encryptor.update(data) + encryptor.finalize() return ESP(spi=esp.spi, seq=esp.seq, data=esp.iv + data)
Encrypt an ESP packet @param sa: the SecurityAssociation associated with the ESP packet. @param esp: an unencrypted _ESPPlain packet with valid padding @param key: the secret key used for encryption @return: a valid ESP packet encrypted with this algorithm
Below is the the instruction that describes the task: ### Input: Encrypt an ESP packet @param sa: the SecurityAssociation associated with the ESP packet. @param esp: an unencrypted _ESPPlain packet with valid padding @param key: the secret key used for encryption @return: a valid ESP packet encrypted with this algorithm ### Response: def encrypt(self, sa, esp, key): """ Encrypt an ESP packet @param sa: the SecurityAssociation associated with the ESP packet. @param esp: an unencrypted _ESPPlain packet with valid padding @param key: the secret key used for encryption @return: a valid ESP packet encrypted with this algorithm """ data = esp.data_for_encryption() if self.cipher: mode_iv = self._format_mode_iv(algo=self, sa=sa, iv=esp.iv) cipher = self.new_cipher(key, mode_iv) encryptor = cipher.encryptor() if self.is_aead: aad = struct.pack('!LL', esp.spi, esp.seq) encryptor.authenticate_additional_data(aad) data = encryptor.update(data) + encryptor.finalize() data += encryptor.tag[:self.icv_size] else: data = encryptor.update(data) + encryptor.finalize() return ESP(spi=esp.spi, seq=esp.seq, data=esp.iv + data)
def get_status(self, response, finished=False): """Given the stdout from the command returned by :meth:`cmd_status`, return one of the status code defined in :mod:`clusterjob.status`""" for line in response.split("\n"): if line.strip() in self.status_mapping: return self.status_mapping[line.strip()] return None
Given the stdout from the command returned by :meth:`cmd_status`, return one of the status code defined in :mod:`clusterjob.status`
Below is the the instruction that describes the task: ### Input: Given the stdout from the command returned by :meth:`cmd_status`, return one of the status code defined in :mod:`clusterjob.status` ### Response: def get_status(self, response, finished=False): """Given the stdout from the command returned by :meth:`cmd_status`, return one of the status code defined in :mod:`clusterjob.status`""" for line in response.split("\n"): if line.strip() in self.status_mapping: return self.status_mapping[line.strip()] return None
def reduce_chunk(func, array): """Reduce with `func`, chunk by chunk, the passed pytable `array`. """ res = [] for slice in iter_chunk_slice(array.shape[-1], array.chunkshape[-1]): res.append(func(array[..., slice])) return func(res)
Reduce with `func`, chunk by chunk, the passed pytable `array`.
Below is the the instruction that describes the task: ### Input: Reduce with `func`, chunk by chunk, the passed pytable `array`. ### Response: def reduce_chunk(func, array): """Reduce with `func`, chunk by chunk, the passed pytable `array`. """ res = [] for slice in iter_chunk_slice(array.shape[-1], array.chunkshape[-1]): res.append(func(array[..., slice])) return func(res)
def parse(readDataInstance): """ Returns a new L{DosHeader} object. @type readDataInstance: L{ReadData} @param readDataInstance: A L{ReadData} object with data to be parsed as a L{DosHeader} object. @rtype: L{DosHeader} @return: A new L{DosHeader} object. """ dosHdr = DosHeader() dosHdr.e_magic.value = readDataInstance.readWord() dosHdr.e_cblp.value = readDataInstance.readWord() dosHdr.e_cp.value = readDataInstance.readWord() dosHdr.e_crlc.value = readDataInstance.readWord() dosHdr.e_cparhdr.value = readDataInstance.readWord() dosHdr.e_minalloc.value = readDataInstance.readWord() dosHdr.e_maxalloc.value = readDataInstance.readWord() dosHdr.e_ss.value = readDataInstance.readWord() dosHdr.e_sp.value = readDataInstance.readWord() dosHdr.e_csum.value = readDataInstance.readWord() dosHdr.e_ip.value = readDataInstance.readWord() dosHdr.e_cs.value = readDataInstance.readWord() dosHdr.e_lfarlc.value = readDataInstance.readWord() dosHdr.e_ovno.value = readDataInstance.readWord() dosHdr.e_res = datatypes.Array(datatypes.TYPE_WORD) for i in range(4): dosHdr.e_res.append(datatypes.WORD(readDataInstance.readWord())) dosHdr.e_oemid.value = readDataInstance.readWord() dosHdr.e_oeminfo.value = readDataInstance.readWord() dosHdr.e_res2 = datatypes.Array(datatypes.TYPE_WORD) for i in range (10): dosHdr.e_res2.append(datatypes.WORD(readDataInstance.readWord())) dosHdr.e_lfanew.value = readDataInstance.readDword() return dosHdr
Returns a new L{DosHeader} object. @type readDataInstance: L{ReadData} @param readDataInstance: A L{ReadData} object with data to be parsed as a L{DosHeader} object. @rtype: L{DosHeader} @return: A new L{DosHeader} object.
Below is the the instruction that describes the task: ### Input: Returns a new L{DosHeader} object. @type readDataInstance: L{ReadData} @param readDataInstance: A L{ReadData} object with data to be parsed as a L{DosHeader} object. @rtype: L{DosHeader} @return: A new L{DosHeader} object. ### Response: def parse(readDataInstance): """ Returns a new L{DosHeader} object. @type readDataInstance: L{ReadData} @param readDataInstance: A L{ReadData} object with data to be parsed as a L{DosHeader} object. @rtype: L{DosHeader} @return: A new L{DosHeader} object. """ dosHdr = DosHeader() dosHdr.e_magic.value = readDataInstance.readWord() dosHdr.e_cblp.value = readDataInstance.readWord() dosHdr.e_cp.value = readDataInstance.readWord() dosHdr.e_crlc.value = readDataInstance.readWord() dosHdr.e_cparhdr.value = readDataInstance.readWord() dosHdr.e_minalloc.value = readDataInstance.readWord() dosHdr.e_maxalloc.value = readDataInstance.readWord() dosHdr.e_ss.value = readDataInstance.readWord() dosHdr.e_sp.value = readDataInstance.readWord() dosHdr.e_csum.value = readDataInstance.readWord() dosHdr.e_ip.value = readDataInstance.readWord() dosHdr.e_cs.value = readDataInstance.readWord() dosHdr.e_lfarlc.value = readDataInstance.readWord() dosHdr.e_ovno.value = readDataInstance.readWord() dosHdr.e_res = datatypes.Array(datatypes.TYPE_WORD) for i in range(4): dosHdr.e_res.append(datatypes.WORD(readDataInstance.readWord())) dosHdr.e_oemid.value = readDataInstance.readWord() dosHdr.e_oeminfo.value = readDataInstance.readWord() dosHdr.e_res2 = datatypes.Array(datatypes.TYPE_WORD) for i in range (10): dosHdr.e_res2.append(datatypes.WORD(readDataInstance.readWord())) dosHdr.e_lfanew.value = readDataInstance.readDword() return dosHdr
def accept(self): """Method invoked when OK button is clicked.""" output_path = self.output_path_line_edit.text() if not output_path: display_warning_message_box( self, tr('Empty Output Path'), tr('Output path can not be empty')) return try: self.convert_metadata() except MetadataConversionError as e: display_warning_message_box( self, tr('Metadata Conversion Failed'), str(e)) return if not os.path.exists(output_path): display_warning_message_box( self, tr('Metadata Conversion Failed'), tr('Result file is not found.')) return display_success_message_bar( tr('Metadata Conversion Success'), tr('You can find your copied layer with metadata version 3.5 in ' '%s' % output_path), iface_object=self.iface ) super(MetadataConverterDialog, self).accept()
Method invoked when OK button is clicked.
Below is the the instruction that describes the task: ### Input: Method invoked when OK button is clicked. ### Response: def accept(self): """Method invoked when OK button is clicked.""" output_path = self.output_path_line_edit.text() if not output_path: display_warning_message_box( self, tr('Empty Output Path'), tr('Output path can not be empty')) return try: self.convert_metadata() except MetadataConversionError as e: display_warning_message_box( self, tr('Metadata Conversion Failed'), str(e)) return if not os.path.exists(output_path): display_warning_message_box( self, tr('Metadata Conversion Failed'), tr('Result file is not found.')) return display_success_message_bar( tr('Metadata Conversion Success'), tr('You can find your copied layer with metadata version 3.5 in ' '%s' % output_path), iface_object=self.iface ) super(MetadataConverterDialog, self).accept()
def copyto(self, other): """Copies the value of this array to another array. If ``other`` is a ``NDArray`` object, then ``other.shape`` and ``self.shape`` should be the same. This function copies the value from ``self`` to ``other``. If ``other`` is a context, a new ``NDArray`` will be first created on the target context, and the value of ``self`` is copied. Parameters ---------- other : NDArray or Context The destination array or context. Returns ------- NDArray, CSRNDArray or RowSparseNDArray The copied array. If ``other`` is an ``NDArray``, then the return value and ``other`` will point to the same ``NDArray``. Examples -------- >>> x = mx.nd.ones((2,3)) >>> y = mx.nd.zeros((2,3), mx.gpu(0)) >>> z = x.copyto(y) >>> z is y True >>> y.asnumpy() array([[ 1., 1., 1.], [ 1., 1., 1.]], dtype=float32) >>> y.copyto(mx.gpu(0)) <NDArray 2x3 @gpu(0)> """ if isinstance(other, NDArray): if other.handle is self.handle: warnings.warn('You are attempting to copy an array to itself', RuntimeWarning) return False return _internal._copyto(self, out=other) elif isinstance(other, Context): hret = NDArray(_new_alloc_handle(self.shape, other, True, self.dtype)) return _internal._copyto(self, out=hret) else: raise TypeError('copyto does not support type ' + str(type(other)))
Copies the value of this array to another array. If ``other`` is a ``NDArray`` object, then ``other.shape`` and ``self.shape`` should be the same. This function copies the value from ``self`` to ``other``. If ``other`` is a context, a new ``NDArray`` will be first created on the target context, and the value of ``self`` is copied. Parameters ---------- other : NDArray or Context The destination array or context. Returns ------- NDArray, CSRNDArray or RowSparseNDArray The copied array. If ``other`` is an ``NDArray``, then the return value and ``other`` will point to the same ``NDArray``. Examples -------- >>> x = mx.nd.ones((2,3)) >>> y = mx.nd.zeros((2,3), mx.gpu(0)) >>> z = x.copyto(y) >>> z is y True >>> y.asnumpy() array([[ 1., 1., 1.], [ 1., 1., 1.]], dtype=float32) >>> y.copyto(mx.gpu(0)) <NDArray 2x3 @gpu(0)>
Below is the the instruction that describes the task: ### Input: Copies the value of this array to another array. If ``other`` is a ``NDArray`` object, then ``other.shape`` and ``self.shape`` should be the same. This function copies the value from ``self`` to ``other``. If ``other`` is a context, a new ``NDArray`` will be first created on the target context, and the value of ``self`` is copied. Parameters ---------- other : NDArray or Context The destination array or context. Returns ------- NDArray, CSRNDArray or RowSparseNDArray The copied array. If ``other`` is an ``NDArray``, then the return value and ``other`` will point to the same ``NDArray``. Examples -------- >>> x = mx.nd.ones((2,3)) >>> y = mx.nd.zeros((2,3), mx.gpu(0)) >>> z = x.copyto(y) >>> z is y True >>> y.asnumpy() array([[ 1., 1., 1.], [ 1., 1., 1.]], dtype=float32) >>> y.copyto(mx.gpu(0)) <NDArray 2x3 @gpu(0)> ### Response: def copyto(self, other): """Copies the value of this array to another array. If ``other`` is a ``NDArray`` object, then ``other.shape`` and ``self.shape`` should be the same. This function copies the value from ``self`` to ``other``. If ``other`` is a context, a new ``NDArray`` will be first created on the target context, and the value of ``self`` is copied. Parameters ---------- other : NDArray or Context The destination array or context. Returns ------- NDArray, CSRNDArray or RowSparseNDArray The copied array. If ``other`` is an ``NDArray``, then the return value and ``other`` will point to the same ``NDArray``. Examples -------- >>> x = mx.nd.ones((2,3)) >>> y = mx.nd.zeros((2,3), mx.gpu(0)) >>> z = x.copyto(y) >>> z is y True >>> y.asnumpy() array([[ 1., 1., 1.], [ 1., 1., 1.]], dtype=float32) >>> y.copyto(mx.gpu(0)) <NDArray 2x3 @gpu(0)> """ if isinstance(other, NDArray): if other.handle is self.handle: warnings.warn('You are attempting to copy an array to itself', RuntimeWarning) return False return _internal._copyto(self, out=other) elif isinstance(other, Context): hret = NDArray(_new_alloc_handle(self.shape, other, True, self.dtype)) return _internal._copyto(self, out=hret) else: raise TypeError('copyto does not support type ' + str(type(other)))
def insert(self, inst): """Insert a vdata or a vgroup in the vgroup. Args:: inst vdata or vgroup instance to add Returns:: index of the inserted vdata or vgroup (0 based) C library equivalent : Vinsert """ if isinstance(inst, VD): id = inst._id elif isinstance(inst, VG): id = inst._id else: raise HDF4Error("insrt: bad argument") index = _C.Vinsert(self._id, id) _checkErr('insert', index, "cannot insert in vgroup") return index
Insert a vdata or a vgroup in the vgroup. Args:: inst vdata or vgroup instance to add Returns:: index of the inserted vdata or vgroup (0 based) C library equivalent : Vinsert
Below is the the instruction that describes the task: ### Input: Insert a vdata or a vgroup in the vgroup. Args:: inst vdata or vgroup instance to add Returns:: index of the inserted vdata or vgroup (0 based) C library equivalent : Vinsert ### Response: def insert(self, inst): """Insert a vdata or a vgroup in the vgroup. Args:: inst vdata or vgroup instance to add Returns:: index of the inserted vdata or vgroup (0 based) C library equivalent : Vinsert """ if isinstance(inst, VD): id = inst._id elif isinstance(inst, VG): id = inst._id else: raise HDF4Error("insrt: bad argument") index = _C.Vinsert(self._id, id) _checkErr('insert', index, "cannot insert in vgroup") return index
def eval_master(self, opts, timeout=60, safe=True, failed=False, failback=False): ''' Evaluates and returns a tuple of the current master address and the pub_channel. In standard mode, just creates a pub_channel with the given master address. With master_type=func evaluates the current master address from the given module and then creates a pub_channel. With master_type=failover takes the list of masters and loops through them. The first one that allows the minion to create a pub_channel is then returned. If this function is called outside the minions initialization phase (for example from the minions main event-loop when a master connection loss was detected), 'failed' should be set to True. The current (possibly failed) master will then be removed from the list of masters. ''' # return early if we are not connecting to a master if opts['master_type'] == 'disable': log.warning('Master is set to disable, skipping connection') self.connected = False raise tornado.gen.Return((None, None)) # Run masters discovery over SSDP. This may modify the whole configuration, # depending of the networking and sets of masters. # if we are using multimaster, discovery can only happen at start time # because MinionManager handles it. by eval_master time the minion doesn't # know about other siblings currently running if isinstance(self.opts['discovery'], dict) and not self.opts['discovery'].get('multimaster'): self._discover_masters() # check if master_type was altered from its default if opts['master_type'] != 'str' and opts['__role'] != 'syndic': # check for a valid keyword if opts['master_type'] == 'func': eval_master_func(opts) # if failover or distributed is set, master has to be of type list elif opts['master_type'] in ('failover', 'distributed'): if isinstance(opts['master'], list): log.info( 'Got list of available master addresses: %s', opts['master'] ) if opts['master_type'] == 'distributed': master_len = len(opts['master']) if master_len > 1: secondary_masters = opts['master'][1:] master_idx = crc32(opts['id']) % master_len try: preferred_masters = opts['master'] preferred_masters[0] = opts['master'][master_idx] preferred_masters[1:] = [m for m in opts['master'] if m != preferred_masters[0]] opts['master'] = preferred_masters log.info('Distributed to the master at \'%s\'.', opts['master'][0]) except (KeyError, AttributeError, TypeError): log.warning('Failed to distribute to a specific master.') else: log.warning('master_type = distributed needs more than 1 master.') if opts['master_shuffle']: log.warning( 'Use of \'master_shuffle\' detected. \'master_shuffle\' is deprecated in favor ' 'of \'random_master\'. Please update your minion config file.' ) opts['random_master'] = opts['master_shuffle'] opts['auth_tries'] = 0 if opts['master_failback'] and opts['master_failback_interval'] == 0: opts['master_failback_interval'] = opts['master_alive_interval'] # if opts['master'] is a str and we have never created opts['master_list'] elif isinstance(opts['master'], six.string_types) and ('master_list' not in opts): # We have a string, but a list was what was intended. Convert. # See issue 23611 for details opts['master'] = [opts['master']] elif opts['__role'] == 'syndic': log.info('Syndic setting master_syndic to \'%s\'', opts['master']) # if failed=True, the minion was previously connected # we're probably called from the minions main-event-loop # because a master connection loss was detected. remove # the possibly failed master from the list of masters. elif failed: if failback: # failback list of masters to original config opts['master'] = opts['master_list'] else: log.info( 'Moving possibly failed master %s to the end of ' 'the list of masters', opts['master'] ) if opts['master'] in opts['local_masters']: # create new list of master with the possibly failed # one moved to the end failed_master = opts['master'] opts['master'] = [x for x in opts['local_masters'] if opts['master'] != x] opts['master'].append(failed_master) else: opts['master'] = opts['master_list'] else: msg = ('master_type set to \'failover\' but \'master\' ' 'is not of type list but of type ' '{0}'.format(type(opts['master']))) log.error(msg) sys.exit(salt.defaults.exitcodes.EX_GENERIC) # If failover is set, minion have to failover on DNS errors instead of retry DNS resolve. # See issue 21082 for details if opts['retry_dns'] and opts['master_type'] == 'failover': msg = ('\'master_type\' set to \'failover\' but \'retry_dns\' is not 0. ' 'Setting \'retry_dns\' to 0 to failover to the next master on DNS errors.') log.critical(msg) opts['retry_dns'] = 0 else: msg = ('Invalid keyword \'{0}\' for variable ' '\'master_type\''.format(opts['master_type'])) log.error(msg) sys.exit(salt.defaults.exitcodes.EX_GENERIC) # FIXME: if SMinion don't define io_loop, it can't switch master see #29088 # Specify kwargs for the channel factory so that SMinion doesn't need to define an io_loop # (The channel factories will set a default if the kwarg isn't passed) factory_kwargs = {'timeout': timeout, 'safe': safe} if getattr(self, 'io_loop', None): factory_kwargs['io_loop'] = self.io_loop # pylint: disable=no-member tries = opts.get('master_tries', 1) attempts = 0 # if we have a list of masters, loop through them and be # happy with the first one that allows us to connect if isinstance(opts['master'], list): conn = False last_exc = None opts['master_uri_list'] = [] opts['local_masters'] = copy.copy(opts['master']) # shuffle the masters and then loop through them if opts['random_master']: # master_failback is only used when master_type is set to failover if opts['master_type'] == 'failover' and opts['master_failback']: secondary_masters = opts['local_masters'][1:] shuffle(secondary_masters) opts['local_masters'][1:] = secondary_masters else: shuffle(opts['local_masters']) # This sits outside of the connection loop below because it needs to set # up a list of master URIs regardless of which masters are available # to connect _to_. This is primarily used for masterless mode, when # we need a list of master URIs to fire calls back to. for master in opts['local_masters']: opts['master'] = master opts.update(prep_ip_port(opts)) opts['master_uri_list'].append(resolve_dns(opts)['master_uri']) while True: if attempts != 0: # Give up a little time between connection attempts # to allow the IOLoop to run any other scheduled tasks. yield tornado.gen.sleep(opts['acceptance_wait_time']) attempts += 1 if tries > 0: log.debug( 'Connecting to master. Attempt %s of %s', attempts, tries ) else: log.debug( 'Connecting to master. Attempt %s (infinite attempts)', attempts ) for master in opts['local_masters']: opts['master'] = master opts.update(prep_ip_port(opts)) opts.update(resolve_dns(opts)) # on first run, update self.opts with the whole master list # to enable a minion to re-use old masters if they get fixed if 'master_list' not in opts: opts['master_list'] = copy.copy(opts['local_masters']) self.opts = opts pub_channel = salt.transport.client.AsyncPubChannel.factory(opts, **factory_kwargs) try: yield pub_channel.connect() conn = True break except SaltClientError as exc: last_exc = exc if exc.strerror.startswith('Could not access'): msg = ( 'Failed to initiate connection with Master ' '%s: check ownership/permissions. Error ' 'message: %s', opts['master'], exc ) else: msg = ('Master %s could not be reached, trying next ' 'next master (if any)', opts['master']) log.info(msg) continue if not conn: if attempts == tries: # Exhausted all attempts. Return exception. self.connected = False self.opts['master'] = copy.copy(self.opts['local_masters']) log.error( 'No master could be reached or all masters ' 'denied the minion\'s connection attempt.' ) # If the code reaches this point, 'last_exc' # should already be set. raise last_exc # pylint: disable=E0702 else: self.tok = pub_channel.auth.gen_token(b'salt') self.connected = True raise tornado.gen.Return((opts['master'], pub_channel)) # single master sign in else: if opts['random_master']: log.warning('random_master is True but there is only one master specified. Ignoring.') while True: if attempts != 0: # Give up a little time between connection attempts # to allow the IOLoop to run any other scheduled tasks. yield tornado.gen.sleep(opts['acceptance_wait_time']) attempts += 1 if tries > 0: log.debug( 'Connecting to master. Attempt %s of %s', attempts, tries ) else: log.debug( 'Connecting to master. Attempt %s (infinite attempts)', attempts ) opts.update(prep_ip_port(opts)) opts.update(resolve_dns(opts)) try: if self.opts['transport'] == 'detect': self.opts['detect_mode'] = True for trans in ('zeromq', 'tcp'): if trans == 'zeromq' and not zmq: continue self.opts['transport'] = trans pub_channel = salt.transport.client.AsyncPubChannel.factory(self.opts, **factory_kwargs) yield pub_channel.connect() if not pub_channel.auth.authenticated: continue del self.opts['detect_mode'] break else: pub_channel = salt.transport.client.AsyncPubChannel.factory(self.opts, **factory_kwargs) yield pub_channel.connect() self.tok = pub_channel.auth.gen_token(b'salt') self.connected = True raise tornado.gen.Return((opts['master'], pub_channel)) except SaltClientError as exc: if attempts == tries: # Exhausted all attempts. Return exception. self.connected = False raise exc
Evaluates and returns a tuple of the current master address and the pub_channel. In standard mode, just creates a pub_channel with the given master address. With master_type=func evaluates the current master address from the given module and then creates a pub_channel. With master_type=failover takes the list of masters and loops through them. The first one that allows the minion to create a pub_channel is then returned. If this function is called outside the minions initialization phase (for example from the minions main event-loop when a master connection loss was detected), 'failed' should be set to True. The current (possibly failed) master will then be removed from the list of masters.
Below is the the instruction that describes the task: ### Input: Evaluates and returns a tuple of the current master address and the pub_channel. In standard mode, just creates a pub_channel with the given master address. With master_type=func evaluates the current master address from the given module and then creates a pub_channel. With master_type=failover takes the list of masters and loops through them. The first one that allows the minion to create a pub_channel is then returned. If this function is called outside the minions initialization phase (for example from the minions main event-loop when a master connection loss was detected), 'failed' should be set to True. The current (possibly failed) master will then be removed from the list of masters. ### Response: def eval_master(self, opts, timeout=60, safe=True, failed=False, failback=False): ''' Evaluates and returns a tuple of the current master address and the pub_channel. In standard mode, just creates a pub_channel with the given master address. With master_type=func evaluates the current master address from the given module and then creates a pub_channel. With master_type=failover takes the list of masters and loops through them. The first one that allows the minion to create a pub_channel is then returned. If this function is called outside the minions initialization phase (for example from the minions main event-loop when a master connection loss was detected), 'failed' should be set to True. The current (possibly failed) master will then be removed from the list of masters. ''' # return early if we are not connecting to a master if opts['master_type'] == 'disable': log.warning('Master is set to disable, skipping connection') self.connected = False raise tornado.gen.Return((None, None)) # Run masters discovery over SSDP. This may modify the whole configuration, # depending of the networking and sets of masters. # if we are using multimaster, discovery can only happen at start time # because MinionManager handles it. by eval_master time the minion doesn't # know about other siblings currently running if isinstance(self.opts['discovery'], dict) and not self.opts['discovery'].get('multimaster'): self._discover_masters() # check if master_type was altered from its default if opts['master_type'] != 'str' and opts['__role'] != 'syndic': # check for a valid keyword if opts['master_type'] == 'func': eval_master_func(opts) # if failover or distributed is set, master has to be of type list elif opts['master_type'] in ('failover', 'distributed'): if isinstance(opts['master'], list): log.info( 'Got list of available master addresses: %s', opts['master'] ) if opts['master_type'] == 'distributed': master_len = len(opts['master']) if master_len > 1: secondary_masters = opts['master'][1:] master_idx = crc32(opts['id']) % master_len try: preferred_masters = opts['master'] preferred_masters[0] = opts['master'][master_idx] preferred_masters[1:] = [m for m in opts['master'] if m != preferred_masters[0]] opts['master'] = preferred_masters log.info('Distributed to the master at \'%s\'.', opts['master'][0]) except (KeyError, AttributeError, TypeError): log.warning('Failed to distribute to a specific master.') else: log.warning('master_type = distributed needs more than 1 master.') if opts['master_shuffle']: log.warning( 'Use of \'master_shuffle\' detected. \'master_shuffle\' is deprecated in favor ' 'of \'random_master\'. Please update your minion config file.' ) opts['random_master'] = opts['master_shuffle'] opts['auth_tries'] = 0 if opts['master_failback'] and opts['master_failback_interval'] == 0: opts['master_failback_interval'] = opts['master_alive_interval'] # if opts['master'] is a str and we have never created opts['master_list'] elif isinstance(opts['master'], six.string_types) and ('master_list' not in opts): # We have a string, but a list was what was intended. Convert. # See issue 23611 for details opts['master'] = [opts['master']] elif opts['__role'] == 'syndic': log.info('Syndic setting master_syndic to \'%s\'', opts['master']) # if failed=True, the minion was previously connected # we're probably called from the minions main-event-loop # because a master connection loss was detected. remove # the possibly failed master from the list of masters. elif failed: if failback: # failback list of masters to original config opts['master'] = opts['master_list'] else: log.info( 'Moving possibly failed master %s to the end of ' 'the list of masters', opts['master'] ) if opts['master'] in opts['local_masters']: # create new list of master with the possibly failed # one moved to the end failed_master = opts['master'] opts['master'] = [x for x in opts['local_masters'] if opts['master'] != x] opts['master'].append(failed_master) else: opts['master'] = opts['master_list'] else: msg = ('master_type set to \'failover\' but \'master\' ' 'is not of type list but of type ' '{0}'.format(type(opts['master']))) log.error(msg) sys.exit(salt.defaults.exitcodes.EX_GENERIC) # If failover is set, minion have to failover on DNS errors instead of retry DNS resolve. # See issue 21082 for details if opts['retry_dns'] and opts['master_type'] == 'failover': msg = ('\'master_type\' set to \'failover\' but \'retry_dns\' is not 0. ' 'Setting \'retry_dns\' to 0 to failover to the next master on DNS errors.') log.critical(msg) opts['retry_dns'] = 0 else: msg = ('Invalid keyword \'{0}\' for variable ' '\'master_type\''.format(opts['master_type'])) log.error(msg) sys.exit(salt.defaults.exitcodes.EX_GENERIC) # FIXME: if SMinion don't define io_loop, it can't switch master see #29088 # Specify kwargs for the channel factory so that SMinion doesn't need to define an io_loop # (The channel factories will set a default if the kwarg isn't passed) factory_kwargs = {'timeout': timeout, 'safe': safe} if getattr(self, 'io_loop', None): factory_kwargs['io_loop'] = self.io_loop # pylint: disable=no-member tries = opts.get('master_tries', 1) attempts = 0 # if we have a list of masters, loop through them and be # happy with the first one that allows us to connect if isinstance(opts['master'], list): conn = False last_exc = None opts['master_uri_list'] = [] opts['local_masters'] = copy.copy(opts['master']) # shuffle the masters and then loop through them if opts['random_master']: # master_failback is only used when master_type is set to failover if opts['master_type'] == 'failover' and opts['master_failback']: secondary_masters = opts['local_masters'][1:] shuffle(secondary_masters) opts['local_masters'][1:] = secondary_masters else: shuffle(opts['local_masters']) # This sits outside of the connection loop below because it needs to set # up a list of master URIs regardless of which masters are available # to connect _to_. This is primarily used for masterless mode, when # we need a list of master URIs to fire calls back to. for master in opts['local_masters']: opts['master'] = master opts.update(prep_ip_port(opts)) opts['master_uri_list'].append(resolve_dns(opts)['master_uri']) while True: if attempts != 0: # Give up a little time between connection attempts # to allow the IOLoop to run any other scheduled tasks. yield tornado.gen.sleep(opts['acceptance_wait_time']) attempts += 1 if tries > 0: log.debug( 'Connecting to master. Attempt %s of %s', attempts, tries ) else: log.debug( 'Connecting to master. Attempt %s (infinite attempts)', attempts ) for master in opts['local_masters']: opts['master'] = master opts.update(prep_ip_port(opts)) opts.update(resolve_dns(opts)) # on first run, update self.opts with the whole master list # to enable a minion to re-use old masters if they get fixed if 'master_list' not in opts: opts['master_list'] = copy.copy(opts['local_masters']) self.opts = opts pub_channel = salt.transport.client.AsyncPubChannel.factory(opts, **factory_kwargs) try: yield pub_channel.connect() conn = True break except SaltClientError as exc: last_exc = exc if exc.strerror.startswith('Could not access'): msg = ( 'Failed to initiate connection with Master ' '%s: check ownership/permissions. Error ' 'message: %s', opts['master'], exc ) else: msg = ('Master %s could not be reached, trying next ' 'next master (if any)', opts['master']) log.info(msg) continue if not conn: if attempts == tries: # Exhausted all attempts. Return exception. self.connected = False self.opts['master'] = copy.copy(self.opts['local_masters']) log.error( 'No master could be reached or all masters ' 'denied the minion\'s connection attempt.' ) # If the code reaches this point, 'last_exc' # should already be set. raise last_exc # pylint: disable=E0702 else: self.tok = pub_channel.auth.gen_token(b'salt') self.connected = True raise tornado.gen.Return((opts['master'], pub_channel)) # single master sign in else: if opts['random_master']: log.warning('random_master is True but there is only one master specified. Ignoring.') while True: if attempts != 0: # Give up a little time between connection attempts # to allow the IOLoop to run any other scheduled tasks. yield tornado.gen.sleep(opts['acceptance_wait_time']) attempts += 1 if tries > 0: log.debug( 'Connecting to master. Attempt %s of %s', attempts, tries ) else: log.debug( 'Connecting to master. Attempt %s (infinite attempts)', attempts ) opts.update(prep_ip_port(opts)) opts.update(resolve_dns(opts)) try: if self.opts['transport'] == 'detect': self.opts['detect_mode'] = True for trans in ('zeromq', 'tcp'): if trans == 'zeromq' and not zmq: continue self.opts['transport'] = trans pub_channel = salt.transport.client.AsyncPubChannel.factory(self.opts, **factory_kwargs) yield pub_channel.connect() if not pub_channel.auth.authenticated: continue del self.opts['detect_mode'] break else: pub_channel = salt.transport.client.AsyncPubChannel.factory(self.opts, **factory_kwargs) yield pub_channel.connect() self.tok = pub_channel.auth.gen_token(b'salt') self.connected = True raise tornado.gen.Return((opts['master'], pub_channel)) except SaltClientError as exc: if attempts == tries: # Exhausted all attempts. Return exception. self.connected = False raise exc
def swo_supported_speeds(self, cpu_speed, num_speeds=3): """Retrives a list of SWO speeds supported by both the target and the connected J-Link. The supported speeds are returned in order from highest to lowest. Args: self (JLink): the ``JLink`` instance cpu_speed (int): the target's CPU speed in Hz num_speeds (int): the number of compatible speeds to return Returns: A list of compatible SWO speeds in Hz in order from highest to lowest. """ buf_size = num_speeds buf = (ctypes.c_uint32 * buf_size)() res = self._dll.JLINKARM_SWO_GetCompatibleSpeeds(cpu_speed, 0, buf, buf_size) if res < 0: raise errors.JLinkException(res) return list(buf)[:res]
Retrives a list of SWO speeds supported by both the target and the connected J-Link. The supported speeds are returned in order from highest to lowest. Args: self (JLink): the ``JLink`` instance cpu_speed (int): the target's CPU speed in Hz num_speeds (int): the number of compatible speeds to return Returns: A list of compatible SWO speeds in Hz in order from highest to lowest.
Below is the the instruction that describes the task: ### Input: Retrives a list of SWO speeds supported by both the target and the connected J-Link. The supported speeds are returned in order from highest to lowest. Args: self (JLink): the ``JLink`` instance cpu_speed (int): the target's CPU speed in Hz num_speeds (int): the number of compatible speeds to return Returns: A list of compatible SWO speeds in Hz in order from highest to lowest. ### Response: def swo_supported_speeds(self, cpu_speed, num_speeds=3): """Retrives a list of SWO speeds supported by both the target and the connected J-Link. The supported speeds are returned in order from highest to lowest. Args: self (JLink): the ``JLink`` instance cpu_speed (int): the target's CPU speed in Hz num_speeds (int): the number of compatible speeds to return Returns: A list of compatible SWO speeds in Hz in order from highest to lowest. """ buf_size = num_speeds buf = (ctypes.c_uint32 * buf_size)() res = self._dll.JLINKARM_SWO_GetCompatibleSpeeds(cpu_speed, 0, buf, buf_size) if res < 0: raise errors.JLinkException(res) return list(buf)[:res]
def payment_end(self, account, wallet): """ End a payment session. Marks the account as available for use in a payment session. :param account: Account to mark available :type account: str :param wallet: Wallet to end payment session for :type wallet: str :raises: :py:exc:`nano.rpc.RPCException` >>> rpc.payment_end( ... account="xrb_3e3j5tkog48pnny9dmfzj1r16pg8t1e76dz5tmac6iq689wyjfpi00000000", ... wallet="FFFD1BAEC8EC20814BBB9059B393051AAA8380F9B5A2E6B2489A277D81789EEE" ... ) True """ account = self._process_value(account, 'account') wallet = self._process_value(wallet, 'wallet') payload = {"account": account, "wallet": wallet} resp = self.call('payment_end', payload) return resp == {}
End a payment session. Marks the account as available for use in a payment session. :param account: Account to mark available :type account: str :param wallet: Wallet to end payment session for :type wallet: str :raises: :py:exc:`nano.rpc.RPCException` >>> rpc.payment_end( ... account="xrb_3e3j5tkog48pnny9dmfzj1r16pg8t1e76dz5tmac6iq689wyjfpi00000000", ... wallet="FFFD1BAEC8EC20814BBB9059B393051AAA8380F9B5A2E6B2489A277D81789EEE" ... ) True
Below is the the instruction that describes the task: ### Input: End a payment session. Marks the account as available for use in a payment session. :param account: Account to mark available :type account: str :param wallet: Wallet to end payment session for :type wallet: str :raises: :py:exc:`nano.rpc.RPCException` >>> rpc.payment_end( ... account="xrb_3e3j5tkog48pnny9dmfzj1r16pg8t1e76dz5tmac6iq689wyjfpi00000000", ... wallet="FFFD1BAEC8EC20814BBB9059B393051AAA8380F9B5A2E6B2489A277D81789EEE" ... ) True ### Response: def payment_end(self, account, wallet): """ End a payment session. Marks the account as available for use in a payment session. :param account: Account to mark available :type account: str :param wallet: Wallet to end payment session for :type wallet: str :raises: :py:exc:`nano.rpc.RPCException` >>> rpc.payment_end( ... account="xrb_3e3j5tkog48pnny9dmfzj1r16pg8t1e76dz5tmac6iq689wyjfpi00000000", ... wallet="FFFD1BAEC8EC20814BBB9059B393051AAA8380F9B5A2E6B2489A277D81789EEE" ... ) True """ account = self._process_value(account, 'account') wallet = self._process_value(wallet, 'wallet') payload = {"account": account, "wallet": wallet} resp = self.call('payment_end', payload) return resp == {}
def wait(self): ''' Waits for the current application to idle or window update event occurs. Usage: d.wait.idle(timeout=1000) d.wait.update(timeout=1000, package_name="com.android.settings") ''' @param_to_property(action=["idle", "update"]) def _wait(action, timeout=1000, package_name=None): if timeout / 1000 + 5 > int(os.environ.get("JSONRPC_TIMEOUT", 90)): http_timeout = timeout / 1000 + 5 else: http_timeout = int(os.environ.get("JSONRPC_TIMEOUT", 90)) if action == "idle": return self.server.jsonrpc_wrap(timeout=http_timeout).waitForIdle(timeout) elif action == "update": return self.server.jsonrpc_wrap(timeout=http_timeout).waitForWindowUpdate(package_name, timeout) return _wait
Waits for the current application to idle or window update event occurs. Usage: d.wait.idle(timeout=1000) d.wait.update(timeout=1000, package_name="com.android.settings")
Below is the the instruction that describes the task: ### Input: Waits for the current application to idle or window update event occurs. Usage: d.wait.idle(timeout=1000) d.wait.update(timeout=1000, package_name="com.android.settings") ### Response: def wait(self): ''' Waits for the current application to idle or window update event occurs. Usage: d.wait.idle(timeout=1000) d.wait.update(timeout=1000, package_name="com.android.settings") ''' @param_to_property(action=["idle", "update"]) def _wait(action, timeout=1000, package_name=None): if timeout / 1000 + 5 > int(os.environ.get("JSONRPC_TIMEOUT", 90)): http_timeout = timeout / 1000 + 5 else: http_timeout = int(os.environ.get("JSONRPC_TIMEOUT", 90)) if action == "idle": return self.server.jsonrpc_wrap(timeout=http_timeout).waitForIdle(timeout) elif action == "update": return self.server.jsonrpc_wrap(timeout=http_timeout).waitForWindowUpdate(package_name, timeout) return _wait
def close(self): """ Closes the connection to the bridge. """ self.is_closed = True self.is_ready = False self._command_queue.put(None)
Closes the connection to the bridge.
Below is the the instruction that describes the task: ### Input: Closes the connection to the bridge. ### Response: def close(self): """ Closes the connection to the bridge. """ self.is_closed = True self.is_ready = False self._command_queue.put(None)
def section(self, section): """Creates a section block Args: section (str or :class:`Section`): name of section or object Returns: self for chaining """ if not isinstance(self._container, ConfigUpdater): raise ValueError("Sections can only be added at section level!") if isinstance(section, str): # create a new section section = Section(section, container=self._container) elif not isinstance(section, Section): raise ValueError("Parameter must be a string or Section type!") if section.name in [block.name for block in self._container if isinstance(block, Section)]: raise DuplicateSectionError(section.name) self._container.structure.insert(self._idx, section) self._idx += 1 return self
Creates a section block Args: section (str or :class:`Section`): name of section or object Returns: self for chaining
Below is the the instruction that describes the task: ### Input: Creates a section block Args: section (str or :class:`Section`): name of section or object Returns: self for chaining ### Response: def section(self, section): """Creates a section block Args: section (str or :class:`Section`): name of section or object Returns: self for chaining """ if not isinstance(self._container, ConfigUpdater): raise ValueError("Sections can only be added at section level!") if isinstance(section, str): # create a new section section = Section(section, container=self._container) elif not isinstance(section, Section): raise ValueError("Parameter must be a string or Section type!") if section.name in [block.name for block in self._container if isinstance(block, Section)]: raise DuplicateSectionError(section.name) self._container.structure.insert(self._idx, section) self._idx += 1 return self
def merge_insert(ins_chunks, doc): """ doc is the already-handled document (as a list of text chunks); here we add <ins>ins_chunks</ins> to the end of that. """ # Though we don't throw away unbalanced_start or unbalanced_end # (we assume there is accompanying markup later or earlier in the # document), we only put <ins> around the balanced portion. unbalanced_start, balanced, unbalanced_end = split_unbalanced(ins_chunks) doc.extend(unbalanced_start) if doc and not doc[-1].endswith(' '): # Fix up the case where the word before the insert didn't end with # a space doc[-1] += ' ' doc.append('<ins>') if balanced and balanced[-1].endswith(' '): # We move space outside of </ins> balanced[-1] = balanced[-1][:-1] doc.extend(balanced) doc.append('</ins> ') doc.extend(unbalanced_end)
doc is the already-handled document (as a list of text chunks); here we add <ins>ins_chunks</ins> to the end of that.
Below is the the instruction that describes the task: ### Input: doc is the already-handled document (as a list of text chunks); here we add <ins>ins_chunks</ins> to the end of that. ### Response: def merge_insert(ins_chunks, doc): """ doc is the already-handled document (as a list of text chunks); here we add <ins>ins_chunks</ins> to the end of that. """ # Though we don't throw away unbalanced_start or unbalanced_end # (we assume there is accompanying markup later or earlier in the # document), we only put <ins> around the balanced portion. unbalanced_start, balanced, unbalanced_end = split_unbalanced(ins_chunks) doc.extend(unbalanced_start) if doc and not doc[-1].endswith(' '): # Fix up the case where the word before the insert didn't end with # a space doc[-1] += ' ' doc.append('<ins>') if balanced and balanced[-1].endswith(' '): # We move space outside of </ins> balanced[-1] = balanced[-1][:-1] doc.extend(balanced) doc.append('</ins> ') doc.extend(unbalanced_end)
def parse_devices(self, json): """Parse result from API.""" result = [] for json_device in json: license_plate = json_device['EquipmentHeader']['SerialNumber'] device = Device(self, license_plate) device.update_from_json(json_device) result.append(device) return result
Parse result from API.
Below is the the instruction that describes the task: ### Input: Parse result from API. ### Response: def parse_devices(self, json): """Parse result from API.""" result = [] for json_device in json: license_plate = json_device['EquipmentHeader']['SerialNumber'] device = Device(self, license_plate) device.update_from_json(json_device) result.append(device) return result
def generate(env): """Add Builders and construction variables for Borland ilink to an Environment.""" SCons.Tool.createSharedLibBuilder(env) SCons.Tool.createProgBuilder(env) env['LINK'] = '$CC' env['LINKFLAGS'] = SCons.Util.CLVar('') env['LINKCOM'] = '$LINK -q $LINKFLAGS -e$TARGET $SOURCES $LIBS' env['LIBDIRPREFIX']='' env['LIBDIRSUFFIX']='' env['LIBLINKPREFIX']='' env['LIBLINKSUFFIX']='$LIBSUFFIX'
Add Builders and construction variables for Borland ilink to an Environment.
Below is the the instruction that describes the task: ### Input: Add Builders and construction variables for Borland ilink to an Environment. ### Response: def generate(env): """Add Builders and construction variables for Borland ilink to an Environment.""" SCons.Tool.createSharedLibBuilder(env) SCons.Tool.createProgBuilder(env) env['LINK'] = '$CC' env['LINKFLAGS'] = SCons.Util.CLVar('') env['LINKCOM'] = '$LINK -q $LINKFLAGS -e$TARGET $SOURCES $LIBS' env['LIBDIRPREFIX']='' env['LIBDIRSUFFIX']='' env['LIBLINKPREFIX']='' env['LIBLINKSUFFIX']='$LIBSUFFIX'
def forward(self, inputs, begin_state=None): # pylint: disable=arguments-differ """Defines the forward computation. Arguments can be either :py:class:`NDArray` or :py:class:`Symbol`. Parameters ----------- inputs : NDArray input tensor with shape `(sequence_length, batch_size)` when `layout` is "TNC". begin_state : list initial recurrent state tensor with length equals to num_layers-1. the initial state with shape `(num_layers, batch_size, num_hidden)` Returns -------- out: NDArray output tensor with shape `(sequence_length, batch_size, input_size)` when `layout` is "TNC". out_states: list output recurrent state tensor with length equals to num_layers-1. the state with shape `(num_layers, batch_size, num_hidden)` encoded_raw: list The list of last output of the model's encoder. the shape of last encoder's output `(sequence_length, batch_size, num_hidden)` encoded_dropped: list The list of last output with dropout of the model's encoder. the shape of last encoder's dropped output `(sequence_length, batch_size, num_hidden)` """ encoded = self.embedding(inputs) if not begin_state: begin_state = self.begin_state(batch_size=inputs.shape[1]) encoded_raw = [] encoded_dropped = [] encoded, state = self.encoder(encoded, begin_state) encoded_raw.append(encoded) if self._dropout: encoded = nd.Dropout(encoded, p=self._dropout, axes=(0,)) out = self.decoder(encoded) return out, state, encoded_raw, encoded_dropped
Defines the forward computation. Arguments can be either :py:class:`NDArray` or :py:class:`Symbol`. Parameters ----------- inputs : NDArray input tensor with shape `(sequence_length, batch_size)` when `layout` is "TNC". begin_state : list initial recurrent state tensor with length equals to num_layers-1. the initial state with shape `(num_layers, batch_size, num_hidden)` Returns -------- out: NDArray output tensor with shape `(sequence_length, batch_size, input_size)` when `layout` is "TNC". out_states: list output recurrent state tensor with length equals to num_layers-1. the state with shape `(num_layers, batch_size, num_hidden)` encoded_raw: list The list of last output of the model's encoder. the shape of last encoder's output `(sequence_length, batch_size, num_hidden)` encoded_dropped: list The list of last output with dropout of the model's encoder. the shape of last encoder's dropped output `(sequence_length, batch_size, num_hidden)`
Below is the the instruction that describes the task: ### Input: Defines the forward computation. Arguments can be either :py:class:`NDArray` or :py:class:`Symbol`. Parameters ----------- inputs : NDArray input tensor with shape `(sequence_length, batch_size)` when `layout` is "TNC". begin_state : list initial recurrent state tensor with length equals to num_layers-1. the initial state with shape `(num_layers, batch_size, num_hidden)` Returns -------- out: NDArray output tensor with shape `(sequence_length, batch_size, input_size)` when `layout` is "TNC". out_states: list output recurrent state tensor with length equals to num_layers-1. the state with shape `(num_layers, batch_size, num_hidden)` encoded_raw: list The list of last output of the model's encoder. the shape of last encoder's output `(sequence_length, batch_size, num_hidden)` encoded_dropped: list The list of last output with dropout of the model's encoder. the shape of last encoder's dropped output `(sequence_length, batch_size, num_hidden)` ### Response: def forward(self, inputs, begin_state=None): # pylint: disable=arguments-differ """Defines the forward computation. Arguments can be either :py:class:`NDArray` or :py:class:`Symbol`. Parameters ----------- inputs : NDArray input tensor with shape `(sequence_length, batch_size)` when `layout` is "TNC". begin_state : list initial recurrent state tensor with length equals to num_layers-1. the initial state with shape `(num_layers, batch_size, num_hidden)` Returns -------- out: NDArray output tensor with shape `(sequence_length, batch_size, input_size)` when `layout` is "TNC". out_states: list output recurrent state tensor with length equals to num_layers-1. the state with shape `(num_layers, batch_size, num_hidden)` encoded_raw: list The list of last output of the model's encoder. the shape of last encoder's output `(sequence_length, batch_size, num_hidden)` encoded_dropped: list The list of last output with dropout of the model's encoder. the shape of last encoder's dropped output `(sequence_length, batch_size, num_hidden)` """ encoded = self.embedding(inputs) if not begin_state: begin_state = self.begin_state(batch_size=inputs.shape[1]) encoded_raw = [] encoded_dropped = [] encoded, state = self.encoder(encoded, begin_state) encoded_raw.append(encoded) if self._dropout: encoded = nd.Dropout(encoded, p=self._dropout, axes=(0,)) out = self.decoder(encoded) return out, state, encoded_raw, encoded_dropped
def get_as_nullable_boolean(self, key): """ Converts map element into a boolean or returns None if conversion is not possible :param key: an index of element to get. :return: boolean value of the element or None if conversion is not supported. """ value = self.get(key) return BooleanConverter.to_nullable_boolean(value)
Converts map element into a boolean or returns None if conversion is not possible :param key: an index of element to get. :return: boolean value of the element or None if conversion is not supported.
Below is the the instruction that describes the task: ### Input: Converts map element into a boolean or returns None if conversion is not possible :param key: an index of element to get. :return: boolean value of the element or None if conversion is not supported. ### Response: def get_as_nullable_boolean(self, key): """ Converts map element into a boolean or returns None if conversion is not possible :param key: an index of element to get. :return: boolean value of the element or None if conversion is not supported. """ value = self.get(key) return BooleanConverter.to_nullable_boolean(value)
def get(self): """ Reloads the measurements from the backing store. :return: 200 if success. """ try: self._measurementController.reloadCompletedMeasurements() return None, 200 except: logger.exception("Failed to reload measurements") return str(sys.exc_info()), 500
Reloads the measurements from the backing store. :return: 200 if success.
Below is the the instruction that describes the task: ### Input: Reloads the measurements from the backing store. :return: 200 if success. ### Response: def get(self): """ Reloads the measurements from the backing store. :return: 200 if success. """ try: self._measurementController.reloadCompletedMeasurements() return None, 200 except: logger.exception("Failed to reload measurements") return str(sys.exc_info()), 500
def login(self, username=None, password=None, **kwargs): """Login to a reddit site. **DEPRECATED**. Will be removed in a future version of PRAW. https://www.reddit.com/comments/2ujhkr/ https://www.reddit.com/comments/37e2mv/ Look for username first in parameter, then praw.ini and finally if both were empty get it from stdin. Look for password in parameter, then praw.ini (but only if username matches that in praw.ini) and finally if they both are empty get it with getpass. Add the variables ``user`` (username) and ``pswd`` (password) to your praw.ini file to allow for auto-login. A successful login will overwrite any existing authentication. """ if password and not username: raise Exception('Username must be provided when password is.') user = username or self.config.user if not user: sys.stdout.write('Username: ') sys.stdout.flush() user = sys.stdin.readline().strip() pswd = None else: pswd = password or self.config.pswd if not pswd: import getpass pswd = getpass.getpass('Password for {0}: '.format(user) .encode('ascii', 'ignore')) data = {'passwd': pswd, 'user': user} self.clear_authentication() self.request_json(self.config['login'], data=data) # Update authentication settings self._authentication = True self.user = self.get_redditor(user) self.user.__class__ = objects.LoggedInRedditor
Login to a reddit site. **DEPRECATED**. Will be removed in a future version of PRAW. https://www.reddit.com/comments/2ujhkr/ https://www.reddit.com/comments/37e2mv/ Look for username first in parameter, then praw.ini and finally if both were empty get it from stdin. Look for password in parameter, then praw.ini (but only if username matches that in praw.ini) and finally if they both are empty get it with getpass. Add the variables ``user`` (username) and ``pswd`` (password) to your praw.ini file to allow for auto-login. A successful login will overwrite any existing authentication.
Below is the the instruction that describes the task: ### Input: Login to a reddit site. **DEPRECATED**. Will be removed in a future version of PRAW. https://www.reddit.com/comments/2ujhkr/ https://www.reddit.com/comments/37e2mv/ Look for username first in parameter, then praw.ini and finally if both were empty get it from stdin. Look for password in parameter, then praw.ini (but only if username matches that in praw.ini) and finally if they both are empty get it with getpass. Add the variables ``user`` (username) and ``pswd`` (password) to your praw.ini file to allow for auto-login. A successful login will overwrite any existing authentication. ### Response: def login(self, username=None, password=None, **kwargs): """Login to a reddit site. **DEPRECATED**. Will be removed in a future version of PRAW. https://www.reddit.com/comments/2ujhkr/ https://www.reddit.com/comments/37e2mv/ Look for username first in parameter, then praw.ini and finally if both were empty get it from stdin. Look for password in parameter, then praw.ini (but only if username matches that in praw.ini) and finally if they both are empty get it with getpass. Add the variables ``user`` (username) and ``pswd`` (password) to your praw.ini file to allow for auto-login. A successful login will overwrite any existing authentication. """ if password and not username: raise Exception('Username must be provided when password is.') user = username or self.config.user if not user: sys.stdout.write('Username: ') sys.stdout.flush() user = sys.stdin.readline().strip() pswd = None else: pswd = password or self.config.pswd if not pswd: import getpass pswd = getpass.getpass('Password for {0}: '.format(user) .encode('ascii', 'ignore')) data = {'passwd': pswd, 'user': user} self.clear_authentication() self.request_json(self.config['login'], data=data) # Update authentication settings self._authentication = True self.user = self.get_redditor(user) self.user.__class__ = objects.LoggedInRedditor
def c_module_relocs(self): """Build relocation for the module variable.""" if self.opts.no_structs or self.opts.windll: return '', '' x86 = reloc_var( self.name, self._c_struct_names()[1], self.opts.reloc_delta, self._c_uses_pointer() ) x64 = '{0} *{1} = &_{1};\n'.format( self._c_struct_names()[1], self.name ) if self._c_uses_pointer() else '' return x86, x64
Build relocation for the module variable.
Below is the the instruction that describes the task: ### Input: Build relocation for the module variable. ### Response: def c_module_relocs(self): """Build relocation for the module variable.""" if self.opts.no_structs or self.opts.windll: return '', '' x86 = reloc_var( self.name, self._c_struct_names()[1], self.opts.reloc_delta, self._c_uses_pointer() ) x64 = '{0} *{1} = &_{1};\n'.format( self._c_struct_names()[1], self.name ) if self._c_uses_pointer() else '' return x86, x64
def finalize(self, process_row = None): """ Restore the LigolwSegmentList objects to the XML tables in preparation for output. All segments from all segment lists are inserted into the tables in time order, but this is NOT behaviour external applications should rely on. This is done simply in the belief that it might assist in constructing well balanced indexed databases from the resulting files. If that proves not to be the case, or for some reason this behaviour proves inconvenient to preserve, then it might be discontinued without notice. You've been warned. """ if process_row is not None: process_id = process_row.process_id elif self.process is not None: process_id = self.process.process_id else: raise ValueError("must supply a process row to .__init__()") # # ensure ID generators are synchronized with table contents # self.segment_def_table.sync_next_id() self.segment_table.sync_next_id() self.segment_sum_table.sync_next_id() # # put all segment lists in time order # self.sort() # # generator function to convert segments into row objects, # each paired with the table to which the row is to be # appended # def row_generator(segs, target_table, process_id, segment_def_id): id_column = target_table.next_id.column_name for seg in segs: row = target_table.RowType() row.segment = seg row.process_id = process_id row.segment_def_id = segment_def_id setattr(row, id_column, target_table.get_next_id()) if 'comment' in target_table.validcolumns: row.comment = None yield row, target_table # # populate the segment_definer table from the list of # LigolwSegmentList objects and construct a matching list # of table row generators. empty ourselves to prevent this # process from being repeated # row_generators = [] while self: ligolw_segment_list = self.pop() segment_def_row = self.segment_def_table.RowType() segment_def_row.process_id = process_id segment_def_row.segment_def_id = self.segment_def_table.get_next_id() segment_def_row.instruments = ligolw_segment_list.instruments segment_def_row.name = ligolw_segment_list.name segment_def_row.version = ligolw_segment_list.version segment_def_row.comment = ligolw_segment_list.comment self.segment_def_table.append(segment_def_row) row_generators.append(row_generator(ligolw_segment_list.valid, self.segment_sum_table, process_id, segment_def_row.segment_def_id)) row_generators.append(row_generator(ligolw_segment_list.active, self.segment_table, process_id, segment_def_row.segment_def_id)) # # populate segment and segment_summary tables by pulling # rows from the generators in time order # for row, target_table in iterutils.inorder(*row_generators): target_table.append(row)
Restore the LigolwSegmentList objects to the XML tables in preparation for output. All segments from all segment lists are inserted into the tables in time order, but this is NOT behaviour external applications should rely on. This is done simply in the belief that it might assist in constructing well balanced indexed databases from the resulting files. If that proves not to be the case, or for some reason this behaviour proves inconvenient to preserve, then it might be discontinued without notice. You've been warned.
Below is the the instruction that describes the task: ### Input: Restore the LigolwSegmentList objects to the XML tables in preparation for output. All segments from all segment lists are inserted into the tables in time order, but this is NOT behaviour external applications should rely on. This is done simply in the belief that it might assist in constructing well balanced indexed databases from the resulting files. If that proves not to be the case, or for some reason this behaviour proves inconvenient to preserve, then it might be discontinued without notice. You've been warned. ### Response: def finalize(self, process_row = None): """ Restore the LigolwSegmentList objects to the XML tables in preparation for output. All segments from all segment lists are inserted into the tables in time order, but this is NOT behaviour external applications should rely on. This is done simply in the belief that it might assist in constructing well balanced indexed databases from the resulting files. If that proves not to be the case, or for some reason this behaviour proves inconvenient to preserve, then it might be discontinued without notice. You've been warned. """ if process_row is not None: process_id = process_row.process_id elif self.process is not None: process_id = self.process.process_id else: raise ValueError("must supply a process row to .__init__()") # # ensure ID generators are synchronized with table contents # self.segment_def_table.sync_next_id() self.segment_table.sync_next_id() self.segment_sum_table.sync_next_id() # # put all segment lists in time order # self.sort() # # generator function to convert segments into row objects, # each paired with the table to which the row is to be # appended # def row_generator(segs, target_table, process_id, segment_def_id): id_column = target_table.next_id.column_name for seg in segs: row = target_table.RowType() row.segment = seg row.process_id = process_id row.segment_def_id = segment_def_id setattr(row, id_column, target_table.get_next_id()) if 'comment' in target_table.validcolumns: row.comment = None yield row, target_table # # populate the segment_definer table from the list of # LigolwSegmentList objects and construct a matching list # of table row generators. empty ourselves to prevent this # process from being repeated # row_generators = [] while self: ligolw_segment_list = self.pop() segment_def_row = self.segment_def_table.RowType() segment_def_row.process_id = process_id segment_def_row.segment_def_id = self.segment_def_table.get_next_id() segment_def_row.instruments = ligolw_segment_list.instruments segment_def_row.name = ligolw_segment_list.name segment_def_row.version = ligolw_segment_list.version segment_def_row.comment = ligolw_segment_list.comment self.segment_def_table.append(segment_def_row) row_generators.append(row_generator(ligolw_segment_list.valid, self.segment_sum_table, process_id, segment_def_row.segment_def_id)) row_generators.append(row_generator(ligolw_segment_list.active, self.segment_table, process_id, segment_def_row.segment_def_id)) # # populate segment and segment_summary tables by pulling # rows from the generators in time order # for row, target_table in iterutils.inorder(*row_generators): target_table.append(row)
def _negotiateHandler(self, request): """ Negotiate a handler based on the content types acceptable to the client. :rtype: 2-`tuple` of `twisted.web.iweb.IResource` and `bytes` :return: Pair of a resource and the content type. """ accept = _parseAccept(request.requestHeaders.getRawHeaders('Accept')) for contentType in accept.keys(): handler = self._acceptHandlers.get(contentType.lower()) if handler is not None: return handler, handler.contentType if self._fallback: handler = self._handlers[0] return handler, handler.contentType return NotAcceptable(), None
Negotiate a handler based on the content types acceptable to the client. :rtype: 2-`tuple` of `twisted.web.iweb.IResource` and `bytes` :return: Pair of a resource and the content type.
Below is the the instruction that describes the task: ### Input: Negotiate a handler based on the content types acceptable to the client. :rtype: 2-`tuple` of `twisted.web.iweb.IResource` and `bytes` :return: Pair of a resource and the content type. ### Response: def _negotiateHandler(self, request): """ Negotiate a handler based on the content types acceptable to the client. :rtype: 2-`tuple` of `twisted.web.iweb.IResource` and `bytes` :return: Pair of a resource and the content type. """ accept = _parseAccept(request.requestHeaders.getRawHeaders('Accept')) for contentType in accept.keys(): handler = self._acceptHandlers.get(contentType.lower()) if handler is not None: return handler, handler.contentType if self._fallback: handler = self._handlers[0] return handler, handler.contentType return NotAcceptable(), None
def filter_with_schema(self, model=None, context=None): """ Perform model filtering with schema """ if model is None or self.schema is None: return self._schema.filter( model=model, context=context if self.use_context else None )
Perform model filtering with schema
Below is the the instruction that describes the task: ### Input: Perform model filtering with schema ### Response: def filter_with_schema(self, model=None, context=None): """ Perform model filtering with schema """ if model is None or self.schema is None: return self._schema.filter( model=model, context=context if self.use_context else None )
def get_bnum(opts, minions, quiet): ''' Return the active number of minions to maintain ''' partition = lambda x: float(x) / 100.0 * len(minions) try: if '%' in opts['batch']: res = partition(float(opts['batch'].strip('%'))) if res < 1: return int(math.ceil(res)) else: return int(res) else: return int(opts['batch']) except ValueError: if not quiet: salt.utils.stringutils.print_cli('Invalid batch data sent: {0}\nData must be in the ' 'form of %10, 10% or 3'.format(opts['batch']))
Return the active number of minions to maintain
Below is the the instruction that describes the task: ### Input: Return the active number of minions to maintain ### Response: def get_bnum(opts, minions, quiet): ''' Return the active number of minions to maintain ''' partition = lambda x: float(x) / 100.0 * len(minions) try: if '%' in opts['batch']: res = partition(float(opts['batch'].strip('%'))) if res < 1: return int(math.ceil(res)) else: return int(res) else: return int(opts['batch']) except ValueError: if not quiet: salt.utils.stringutils.print_cli('Invalid batch data sent: {0}\nData must be in the ' 'form of %10, 10% or 3'.format(opts['batch']))
def sendSomeData(self, howMany): """ Send some DATA commands to my peer(s) to relay some data. @param howMany: an int, the number of chunks to send out. """ # print 'sending some data', howMany if self.transport is None: return peer = self.transport.getQ2QPeer() while howMany > 0: # sort transloads so that the least-frequently-serviced ones will # come first tloads = [ (findin(tl.name, self.sentTransloads), tl) for tl in self.nexus.transloadsForPeer(peer)] tloads.sort() tloads = [tl for (idx, tl) in tloads if tl.peerNeedsData(peer)] if not tloads: break wasHowMany = howMany for myTransload in tloads: # move this transload to the end so it will be sorted last next # time. name = myTransload.name if name in self.sentTransloads: self.sentTransloads.remove(name) self.sentTransloads.append(name) knowledge = myTransload.peers[peer] chunkNumber, chunkData = myTransload.selectOptimalChunk(peer) if chunkNumber is None: continue peerToIntroduce = knowledge.selectPeerToIntroduce( myTransload.peers.keys()) if peerToIntroduce is not None: self.introduce(myTransload.name, peerToIntroduce) self.data(name, chunkNumber, chunkData) # Don't re-send that chunk again unless they explicitly tell us # they need it for some reason knowledge.mask[chunkNumber] = 1 howMany -= 1 if howMany <= 0: break if wasHowMany == howMany: # couldn't find anything to send. break
Send some DATA commands to my peer(s) to relay some data. @param howMany: an int, the number of chunks to send out.
Below is the the instruction that describes the task: ### Input: Send some DATA commands to my peer(s) to relay some data. @param howMany: an int, the number of chunks to send out. ### Response: def sendSomeData(self, howMany): """ Send some DATA commands to my peer(s) to relay some data. @param howMany: an int, the number of chunks to send out. """ # print 'sending some data', howMany if self.transport is None: return peer = self.transport.getQ2QPeer() while howMany > 0: # sort transloads so that the least-frequently-serviced ones will # come first tloads = [ (findin(tl.name, self.sentTransloads), tl) for tl in self.nexus.transloadsForPeer(peer)] tloads.sort() tloads = [tl for (idx, tl) in tloads if tl.peerNeedsData(peer)] if not tloads: break wasHowMany = howMany for myTransload in tloads: # move this transload to the end so it will be sorted last next # time. name = myTransload.name if name in self.sentTransloads: self.sentTransloads.remove(name) self.sentTransloads.append(name) knowledge = myTransload.peers[peer] chunkNumber, chunkData = myTransload.selectOptimalChunk(peer) if chunkNumber is None: continue peerToIntroduce = knowledge.selectPeerToIntroduce( myTransload.peers.keys()) if peerToIntroduce is not None: self.introduce(myTransload.name, peerToIntroduce) self.data(name, chunkNumber, chunkData) # Don't re-send that chunk again unless they explicitly tell us # they need it for some reason knowledge.mask[chunkNumber] = 1 howMany -= 1 if howMany <= 0: break if wasHowMany == howMany: # couldn't find anything to send. break
def install_virtualenv(parser_args): """ Installs virtual environment """ python_version = '.'.join(str(v) for v in sys.version_info[:2]) sys.stdout.write('Installing Python {0} virtualenv into {1} \n'.format(python_version, VE_ROOT)) if sys.version_info < (3, 3): install_virtualenv_p2(VE_ROOT, python_version) else: install_virtualenv_p3(VE_ROOT, python_version)
Installs virtual environment
Below is the the instruction that describes the task: ### Input: Installs virtual environment ### Response: def install_virtualenv(parser_args): """ Installs virtual environment """ python_version = '.'.join(str(v) for v in sys.version_info[:2]) sys.stdout.write('Installing Python {0} virtualenv into {1} \n'.format(python_version, VE_ROOT)) if sys.version_info < (3, 3): install_virtualenv_p2(VE_ROOT, python_version) else: install_virtualenv_p3(VE_ROOT, python_version)
def get_groups(self, condition=None, page_size=1000): """Return an iterator over all groups in this device cloud account Optionally, a condition can be specified to limit the number of groups returned. Examples:: # Get all groups and print information about them for group in dc.devicecore.get_groups(): print group # Iterate over all devices which are in a group with a specific # ID. group = dc.devicore.get_groups(group_id == 123)[0] for device in dc.devicecore.get_devices(group_path == group.get_path()): print device.get_mac() :param condition: A condition to use when filtering the results set. If unspecified, all groups will be returned. :param int page_size: The number of results to fetch in a single page. In general, the default will suffice. :returns: Generator over the groups in this device cloud account. No guarantees about the order of results is provided and child links between nodes will not be populated. """ query_kwargs = {} if condition is not None: query_kwargs["condition"] = condition.compile() for group_data in self._conn.iter_json_pages("/ws/Group", page_size=page_size, **query_kwargs): yield Group.from_json(group_data)
Return an iterator over all groups in this device cloud account Optionally, a condition can be specified to limit the number of groups returned. Examples:: # Get all groups and print information about them for group in dc.devicecore.get_groups(): print group # Iterate over all devices which are in a group with a specific # ID. group = dc.devicore.get_groups(group_id == 123)[0] for device in dc.devicecore.get_devices(group_path == group.get_path()): print device.get_mac() :param condition: A condition to use when filtering the results set. If unspecified, all groups will be returned. :param int page_size: The number of results to fetch in a single page. In general, the default will suffice. :returns: Generator over the groups in this device cloud account. No guarantees about the order of results is provided and child links between nodes will not be populated.
Below is the the instruction that describes the task: ### Input: Return an iterator over all groups in this device cloud account Optionally, a condition can be specified to limit the number of groups returned. Examples:: # Get all groups and print information about them for group in dc.devicecore.get_groups(): print group # Iterate over all devices which are in a group with a specific # ID. group = dc.devicore.get_groups(group_id == 123)[0] for device in dc.devicecore.get_devices(group_path == group.get_path()): print device.get_mac() :param condition: A condition to use when filtering the results set. If unspecified, all groups will be returned. :param int page_size: The number of results to fetch in a single page. In general, the default will suffice. :returns: Generator over the groups in this device cloud account. No guarantees about the order of results is provided and child links between nodes will not be populated. ### Response: def get_groups(self, condition=None, page_size=1000): """Return an iterator over all groups in this device cloud account Optionally, a condition can be specified to limit the number of groups returned. Examples:: # Get all groups and print information about them for group in dc.devicecore.get_groups(): print group # Iterate over all devices which are in a group with a specific # ID. group = dc.devicore.get_groups(group_id == 123)[0] for device in dc.devicecore.get_devices(group_path == group.get_path()): print device.get_mac() :param condition: A condition to use when filtering the results set. If unspecified, all groups will be returned. :param int page_size: The number of results to fetch in a single page. In general, the default will suffice. :returns: Generator over the groups in this device cloud account. No guarantees about the order of results is provided and child links between nodes will not be populated. """ query_kwargs = {} if condition is not None: query_kwargs["condition"] = condition.compile() for group_data in self._conn.iter_json_pages("/ws/Group", page_size=page_size, **query_kwargs): yield Group.from_json(group_data)
def close(self): ''' Close the application and all installed plugins. ''' for plugin in self.plugins: if hasattr(plugin, 'close'): plugin.close() self.stopped = True
Close the application and all installed plugins.
Below is the the instruction that describes the task: ### Input: Close the application and all installed plugins. ### Response: def close(self): ''' Close the application and all installed plugins. ''' for plugin in self.plugins: if hasattr(plugin, 'close'): plugin.close() self.stopped = True
def add_path_object(self, *args): """ Add custom path objects :type: path_object: static_bundle.paths.AbstractPath """ for obj in args: obj.bundle = self self.files.append(obj)
Add custom path objects :type: path_object: static_bundle.paths.AbstractPath
Below is the the instruction that describes the task: ### Input: Add custom path objects :type: path_object: static_bundle.paths.AbstractPath ### Response: def add_path_object(self, *args): """ Add custom path objects :type: path_object: static_bundle.paths.AbstractPath """ for obj in args: obj.bundle = self self.files.append(obj)
def part_search(self, part_query): ''' handles the part lookup/search for the given part query part_query: part string to search as product name outputs result on stdout ''' limit = 100 results = self._e.parts_search(q=part_query, limit=limit) start = 0 hits = results[0]['hits'] if hits == 0: print("No result") return ReturnValues.NO_RESULTS print("Searched for: '{}'".format(results[0]['request']['q'])) def show_result(r): print(' → {:30} {:30} {}'.format( r['item']['mpn'], r['item']['manufacturer']['name'], r['snippet'] )) for r in results[1]: show_result(r) while hits - limit > limit: start += limit hits -= limit results = self._e.parts_search(q=part_query, limit=limit, start=start) for r in results[1]: show_result(r) if hits-limit > 0: start += limit hits -= limit results = self._e.parts_search(q=part_query, limit=hits, start=start) for r in results[1]: show_result(r) return ReturnValues.OK
handles the part lookup/search for the given part query part_query: part string to search as product name outputs result on stdout
Below is the the instruction that describes the task: ### Input: handles the part lookup/search for the given part query part_query: part string to search as product name outputs result on stdout ### Response: def part_search(self, part_query): ''' handles the part lookup/search for the given part query part_query: part string to search as product name outputs result on stdout ''' limit = 100 results = self._e.parts_search(q=part_query, limit=limit) start = 0 hits = results[0]['hits'] if hits == 0: print("No result") return ReturnValues.NO_RESULTS print("Searched for: '{}'".format(results[0]['request']['q'])) def show_result(r): print(' → {:30} {:30} {}'.format( r['item']['mpn'], r['item']['manufacturer']['name'], r['snippet'] )) for r in results[1]: show_result(r) while hits - limit > limit: start += limit hits -= limit results = self._e.parts_search(q=part_query, limit=limit, start=start) for r in results[1]: show_result(r) if hits-limit > 0: start += limit hits -= limit results = self._e.parts_search(q=part_query, limit=hits, start=start) for r in results[1]: show_result(r) return ReturnValues.OK
def parse_gcs_url(gsurl): """ Given a Google Cloud Storage URL (gs://<bucket>/<blob>), returns a tuple containing the corresponding bucket and blob. """ parsed_url = urlparse(gsurl) if not parsed_url.netloc: raise AirflowException('Please provide a bucket name') else: bucket = parsed_url.netloc blob = parsed_url.path.strip('/') return bucket, blob
Given a Google Cloud Storage URL (gs://<bucket>/<blob>), returns a tuple containing the corresponding bucket and blob.
Below is the the instruction that describes the task: ### Input: Given a Google Cloud Storage URL (gs://<bucket>/<blob>), returns a tuple containing the corresponding bucket and blob. ### Response: def parse_gcs_url(gsurl): """ Given a Google Cloud Storage URL (gs://<bucket>/<blob>), returns a tuple containing the corresponding bucket and blob. """ parsed_url = urlparse(gsurl) if not parsed_url.netloc: raise AirflowException('Please provide a bucket name') else: bucket = parsed_url.netloc blob = parsed_url.path.strip('/') return bucket, blob
def read_data(self, **kwargs): ''' Read the datafile specified in Sample.datafile and return the resulting object. Does NOT assign the data to self.data It's advised not to use this method, but instead to access the data through the FCMeasurement.data attribute. ''' meta, data = parse_fcs(self.datafile, **kwargs) return data
Read the datafile specified in Sample.datafile and return the resulting object. Does NOT assign the data to self.data It's advised not to use this method, but instead to access the data through the FCMeasurement.data attribute.
Below is the the instruction that describes the task: ### Input: Read the datafile specified in Sample.datafile and return the resulting object. Does NOT assign the data to self.data It's advised not to use this method, but instead to access the data through the FCMeasurement.data attribute. ### Response: def read_data(self, **kwargs): ''' Read the datafile specified in Sample.datafile and return the resulting object. Does NOT assign the data to self.data It's advised not to use this method, but instead to access the data through the FCMeasurement.data attribute. ''' meta, data = parse_fcs(self.datafile, **kwargs) return data
def _allocate_channel(self): """ Allocate a new AMQP channel. Raises: NoFreeChannels: If this connection has reached its maximum number of channels. """ try: channel = yield self.channel() except pika.exceptions.NoFreeChannels: raise NoFreeChannels() _std_log.debug("Created AMQP channel id %d", channel.channel_number) if self._confirms: yield channel.confirm_delivery() defer.returnValue(channel)
Allocate a new AMQP channel. Raises: NoFreeChannels: If this connection has reached its maximum number of channels.
Below is the the instruction that describes the task: ### Input: Allocate a new AMQP channel. Raises: NoFreeChannels: If this connection has reached its maximum number of channels. ### Response: def _allocate_channel(self): """ Allocate a new AMQP channel. Raises: NoFreeChannels: If this connection has reached its maximum number of channels. """ try: channel = yield self.channel() except pika.exceptions.NoFreeChannels: raise NoFreeChannels() _std_log.debug("Created AMQP channel id %d", channel.channel_number) if self._confirms: yield channel.confirm_delivery() defer.returnValue(channel)
def clear_history(vcs): """Clear (committed) test run history from this project. Args: vcs (easyci.vcs.base.Vcs) """ evidence_path = _get_committed_history_path(vcs) if os.path.exists(evidence_path): os.remove(evidence_path)
Clear (committed) test run history from this project. Args: vcs (easyci.vcs.base.Vcs)
Below is the the instruction that describes the task: ### Input: Clear (committed) test run history from this project. Args: vcs (easyci.vcs.base.Vcs) ### Response: def clear_history(vcs): """Clear (committed) test run history from this project. Args: vcs (easyci.vcs.base.Vcs) """ evidence_path = _get_committed_history_path(vcs) if os.path.exists(evidence_path): os.remove(evidence_path)
def __write_data(self, idx): """ Write out the measurement tables found in paleoData and chronData :return: """ pair = self.noaa_data_sorted["Data"][idx] # Run once for each pair (paleo+chron) of tables that was gathered earlier. # for idx, pair in enumerate(self.noaa_data_sorted["Data"]): lst_pc = ["chron", "paleo"] # loop once for paleo, once for chron for pc in lst_pc: # safeguard in case the table is an empty set. table = pair[pc] if pc == "paleo": self.__write_variables_1(table) self.__write_divider() self.__write_columns(pc, table) elif pc == "chron": # self.__write_variables_1(table) self.__write_columns(pc, table) self.__write_divider(nl=False) return
Write out the measurement tables found in paleoData and chronData :return:
Below is the the instruction that describes the task: ### Input: Write out the measurement tables found in paleoData and chronData :return: ### Response: def __write_data(self, idx): """ Write out the measurement tables found in paleoData and chronData :return: """ pair = self.noaa_data_sorted["Data"][idx] # Run once for each pair (paleo+chron) of tables that was gathered earlier. # for idx, pair in enumerate(self.noaa_data_sorted["Data"]): lst_pc = ["chron", "paleo"] # loop once for paleo, once for chron for pc in lst_pc: # safeguard in case the table is an empty set. table = pair[pc] if pc == "paleo": self.__write_variables_1(table) self.__write_divider() self.__write_columns(pc, table) elif pc == "chron": # self.__write_variables_1(table) self.__write_columns(pc, table) self.__write_divider(nl=False) return
def parse_port(port_obj, owner): '''Create a port object of the correct type. The correct port object type is chosen based on the port.port_type property of port_obj. @param port_obj The CORBA PortService object to wrap. @param owner The owner of this port. Should be a Component object or None. @return The created port object. ''' profile = port_obj.get_port_profile() props = utils.nvlist_to_dict(profile.properties) if props['port.port_type'] == 'DataInPort': return DataInPort(port_obj, owner) elif props['port.port_type'] == 'DataOutPort': return DataOutPort(port_obj, owner) elif props['port.port_type'] == 'CorbaPort': return CorbaPort(port_obj, owner) else: return Port(port_obj, owner)
Create a port object of the correct type. The correct port object type is chosen based on the port.port_type property of port_obj. @param port_obj The CORBA PortService object to wrap. @param owner The owner of this port. Should be a Component object or None. @return The created port object.
Below is the the instruction that describes the task: ### Input: Create a port object of the correct type. The correct port object type is chosen based on the port.port_type property of port_obj. @param port_obj The CORBA PortService object to wrap. @param owner The owner of this port. Should be a Component object or None. @return The created port object. ### Response: def parse_port(port_obj, owner): '''Create a port object of the correct type. The correct port object type is chosen based on the port.port_type property of port_obj. @param port_obj The CORBA PortService object to wrap. @param owner The owner of this port. Should be a Component object or None. @return The created port object. ''' profile = port_obj.get_port_profile() props = utils.nvlist_to_dict(profile.properties) if props['port.port_type'] == 'DataInPort': return DataInPort(port_obj, owner) elif props['port.port_type'] == 'DataOutPort': return DataOutPort(port_obj, owner) elif props['port.port_type'] == 'CorbaPort': return CorbaPort(port_obj, owner) else: return Port(port_obj, owner)
def get_bundle_for_cn(cn, relation_name=None): """Extract certificates for the given cn. :param cn: str Canonical Name on certificate. :param relation_name: str Relation to check for certificates down. :returns: Dictionary of certificate data, :rtype: dict. """ entries = get_requests_for_local_unit(relation_name) cert_bundle = {} for entry in entries: for _cn, bundle in entry['certs'].items(): if _cn == cn: cert_bundle = { 'cert': bundle['cert'], 'key': bundle['key'], 'chain': entry['chain'], 'ca': entry['ca']} break if cert_bundle: break return cert_bundle
Extract certificates for the given cn. :param cn: str Canonical Name on certificate. :param relation_name: str Relation to check for certificates down. :returns: Dictionary of certificate data, :rtype: dict.
Below is the the instruction that describes the task: ### Input: Extract certificates for the given cn. :param cn: str Canonical Name on certificate. :param relation_name: str Relation to check for certificates down. :returns: Dictionary of certificate data, :rtype: dict. ### Response: def get_bundle_for_cn(cn, relation_name=None): """Extract certificates for the given cn. :param cn: str Canonical Name on certificate. :param relation_name: str Relation to check for certificates down. :returns: Dictionary of certificate data, :rtype: dict. """ entries = get_requests_for_local_unit(relation_name) cert_bundle = {} for entry in entries: for _cn, bundle in entry['certs'].items(): if _cn == cn: cert_bundle = { 'cert': bundle['cert'], 'key': bundle['key'], 'chain': entry['chain'], 'ca': entry['ca']} break if cert_bundle: break return cert_bundle
def check_hints(self, ds): ''' Checks for potentially mislabeled metadata and makes suggestions for how to correct :param netCDF4.Dataset ds: An open netCDF dataset :rtype: list :return: List of results ''' ret_val = [] ret_val.extend(self._check_hint_bounds(ds)) return ret_val
Checks for potentially mislabeled metadata and makes suggestions for how to correct :param netCDF4.Dataset ds: An open netCDF dataset :rtype: list :return: List of results
Below is the the instruction that describes the task: ### Input: Checks for potentially mislabeled metadata and makes suggestions for how to correct :param netCDF4.Dataset ds: An open netCDF dataset :rtype: list :return: List of results ### Response: def check_hints(self, ds): ''' Checks for potentially mislabeled metadata and makes suggestions for how to correct :param netCDF4.Dataset ds: An open netCDF dataset :rtype: list :return: List of results ''' ret_val = [] ret_val.extend(self._check_hint_bounds(ds)) return ret_val
def preparse(output_format): """ Do any special processing of a template, and return the result. """ try: return templating.preparse(output_format, lambda path: os.path.join(config.config_dir, "templates", path)) except ImportError as exc: if "tempita" in str(exc): raise error.UserError("To be able to use Tempita templates, install the 'tempita' package (%s)\n" " Possibly USING THE FOLLOWING COMMAND:\n" " %s/easy_install tempita" % (exc, os.path.dirname(sys.executable))) raise except IOError as exc: raise error.LoggableError("Cannot read template: {}".format(exc))
Do any special processing of a template, and return the result.
Below is the the instruction that describes the task: ### Input: Do any special processing of a template, and return the result. ### Response: def preparse(output_format): """ Do any special processing of a template, and return the result. """ try: return templating.preparse(output_format, lambda path: os.path.join(config.config_dir, "templates", path)) except ImportError as exc: if "tempita" in str(exc): raise error.UserError("To be able to use Tempita templates, install the 'tempita' package (%s)\n" " Possibly USING THE FOLLOWING COMMAND:\n" " %s/easy_install tempita" % (exc, os.path.dirname(sys.executable))) raise except IOError as exc: raise error.LoggableError("Cannot read template: {}".format(exc))
def gen(sc, asset, expire): ''' Database population function. What we are doing here is trying to interpret the output of plugin ID 20811 and use that information to help populate the database with individualized entries of the software that is installed on the host. This information will later be used to build the report. ''' # The following regex patters are used to pull out the needed fields from # Plugin ID 20811 redate = re.compile(r'\[installed on (\d{4})/(\d{1,2})/(\d{1,2})\]') reinvdate = re.compile(r'\[installed on (\d{1,2})/(\d{1,2})/(\d{4})\]') rever = re.compile(r'\[version (.*?)\]') resw = re.compile(r'^([\w\s\.\(\-\)\+]*)') s = Session() ts = datetime.datetime.now() for vuln in sc.analysis(('pluginID','=','20811,22869'), ('asset', '=', {'id': str(asset)}), tool='vulndetails'): # First we need to get the host information... nh = False host = s.query(Host).filter_by(ip=vuln['ip']).first() if not host: host = Host() nh = True hdata = sc.analysis(('ip', '=', vuln['ip']),tool='sumip')[0] host.ip = vuln['ip'] host.name = vuln['netbiosName'] host.cpe = hdata['osCPE'] host.dns = hdata['dnsName'] host.asset_id = asset if nh: s.add(host) else: s.merge(host) s.commit() sys.stdout.write('%4d\t%-16s\t%-40s' % (host.id, host.ip, host.dns)) sys.stdout.flush() if vuln['pluginID'] == '22869': if 'CentOS Linux system' in vuln['pluginText'] or 'Red Hat Linux system' in vuln['pluginText']: software = re.findall(' ([a-zA-Z0-9\.\-]*)\|',vuln['pluginText']) for item in software: entry = Entry() entry.name = item entry.timestamp = ts entry.host_id = host.id s.add(entry) s.commit() elif 'SunOS 5.10' in vuln['pluginText']: software = re.findall('Patch: ([^ ]*)', vuln['pluginText']) for item in software: entry = Entry() entry.name = item entry.timestamp = ts entry.host_id = host.id s.add(entry) s.commit() elif 'Solaris 11 system' in vuln['pluginText']: software = re.findall('([\w\/]+)\W+([0-9\.\-]+).*\n',vuln['pluginText']) for item in software: entry = Entry() entry.name = item[0] entry.version = item[1] entry.timestamp = ts entry.host_id = host.id s.add(entry) s.commit() elif 'Mac OS X system' in vuln['pluginText']: software = re.findall(' ([a-zA-Z0-9\.\-\_]*\.pkg)\n',vuln['pluginText']) for item in software: entry = Entry() entry.name = item entry.timestamp = ts entry.host_id = host.id s.add(entry) s.commit() else: sys.stdout.write('\t[NO FORMATTER]') sys.stdout.flush() if vuln['pluginID'] == '20811': software = False patches = False sw = None nh = False s.commit() for line in vuln['pluginText'].split('\n'): if '</plugin_output>' in line: continue if line == u'The following software are installed on the remote host :': software = True patches = False continue if line == u'The following updates are installed :': patches = True continue if software and line != '': names = resw.findall(line) vers = rever.findall(line) dates = redate.findall(line) new = Entry() if len(names) > 0: new.name = names[0].strip() if len(vers) > 0: new.version = vers[0] try: if len(dates) > 0: date = datetime.date(year=int(dates[0][0]), month=int(dates[0][1]), day=int(dates[0][2])) new.date = date else: dates = reinvdate.findall(line) if len(dates) > 0: date = datetime.date(year=int(dates[0][2]), month=int(dates[0][0]), day=int(dates[0][1])) new.date = date except: pass if patches: if line[:2] != ' ': sw = line.strip(':').strip() continue else: new.name = '%s (%s)' % (new.name, sw) new.timestamp = ts new.host_id = host.id s.add(new) s.commit() sys.stdout.write('\tdone\n') sys.stdout.flush() s.commit() # Now to expire the old data out... exp = datetime.datetime.now() - datetime.timedelta(days=expire) print exp # First to delete the aged out entries for entry in s.query(Entry).filter(Entry.timestamp < exp).all(): s.delete(entry) s.commit() # Next to delete any hosts that we arent pulling info for anymore... for host in s.query(Host).all(): if len(host.entries) == 0: s.delete(host) s.commit() s.close()
Database population function. What we are doing here is trying to interpret the output of plugin ID 20811 and use that information to help populate the database with individualized entries of the software that is installed on the host. This information will later be used to build the report.
Below is the the instruction that describes the task: ### Input: Database population function. What we are doing here is trying to interpret the output of plugin ID 20811 and use that information to help populate the database with individualized entries of the software that is installed on the host. This information will later be used to build the report. ### Response: def gen(sc, asset, expire): ''' Database population function. What we are doing here is trying to interpret the output of plugin ID 20811 and use that information to help populate the database with individualized entries of the software that is installed on the host. This information will later be used to build the report. ''' # The following regex patters are used to pull out the needed fields from # Plugin ID 20811 redate = re.compile(r'\[installed on (\d{4})/(\d{1,2})/(\d{1,2})\]') reinvdate = re.compile(r'\[installed on (\d{1,2})/(\d{1,2})/(\d{4})\]') rever = re.compile(r'\[version (.*?)\]') resw = re.compile(r'^([\w\s\.\(\-\)\+]*)') s = Session() ts = datetime.datetime.now() for vuln in sc.analysis(('pluginID','=','20811,22869'), ('asset', '=', {'id': str(asset)}), tool='vulndetails'): # First we need to get the host information... nh = False host = s.query(Host).filter_by(ip=vuln['ip']).first() if not host: host = Host() nh = True hdata = sc.analysis(('ip', '=', vuln['ip']),tool='sumip')[0] host.ip = vuln['ip'] host.name = vuln['netbiosName'] host.cpe = hdata['osCPE'] host.dns = hdata['dnsName'] host.asset_id = asset if nh: s.add(host) else: s.merge(host) s.commit() sys.stdout.write('%4d\t%-16s\t%-40s' % (host.id, host.ip, host.dns)) sys.stdout.flush() if vuln['pluginID'] == '22869': if 'CentOS Linux system' in vuln['pluginText'] or 'Red Hat Linux system' in vuln['pluginText']: software = re.findall(' ([a-zA-Z0-9\.\-]*)\|',vuln['pluginText']) for item in software: entry = Entry() entry.name = item entry.timestamp = ts entry.host_id = host.id s.add(entry) s.commit() elif 'SunOS 5.10' in vuln['pluginText']: software = re.findall('Patch: ([^ ]*)', vuln['pluginText']) for item in software: entry = Entry() entry.name = item entry.timestamp = ts entry.host_id = host.id s.add(entry) s.commit() elif 'Solaris 11 system' in vuln['pluginText']: software = re.findall('([\w\/]+)\W+([0-9\.\-]+).*\n',vuln['pluginText']) for item in software: entry = Entry() entry.name = item[0] entry.version = item[1] entry.timestamp = ts entry.host_id = host.id s.add(entry) s.commit() elif 'Mac OS X system' in vuln['pluginText']: software = re.findall(' ([a-zA-Z0-9\.\-\_]*\.pkg)\n',vuln['pluginText']) for item in software: entry = Entry() entry.name = item entry.timestamp = ts entry.host_id = host.id s.add(entry) s.commit() else: sys.stdout.write('\t[NO FORMATTER]') sys.stdout.flush() if vuln['pluginID'] == '20811': software = False patches = False sw = None nh = False s.commit() for line in vuln['pluginText'].split('\n'): if '</plugin_output>' in line: continue if line == u'The following software are installed on the remote host :': software = True patches = False continue if line == u'The following updates are installed :': patches = True continue if software and line != '': names = resw.findall(line) vers = rever.findall(line) dates = redate.findall(line) new = Entry() if len(names) > 0: new.name = names[0].strip() if len(vers) > 0: new.version = vers[0] try: if len(dates) > 0: date = datetime.date(year=int(dates[0][0]), month=int(dates[0][1]), day=int(dates[0][2])) new.date = date else: dates = reinvdate.findall(line) if len(dates) > 0: date = datetime.date(year=int(dates[0][2]), month=int(dates[0][0]), day=int(dates[0][1])) new.date = date except: pass if patches: if line[:2] != ' ': sw = line.strip(':').strip() continue else: new.name = '%s (%s)' % (new.name, sw) new.timestamp = ts new.host_id = host.id s.add(new) s.commit() sys.stdout.write('\tdone\n') sys.stdout.flush() s.commit() # Now to expire the old data out... exp = datetime.datetime.now() - datetime.timedelta(days=expire) print exp # First to delete the aged out entries for entry in s.query(Entry).filter(Entry.timestamp < exp).all(): s.delete(entry) s.commit() # Next to delete any hosts that we arent pulling info for anymore... for host in s.query(Host).all(): if len(host.entries) == 0: s.delete(host) s.commit() s.close()
def recognize( self, config, audio, retry=google.api_core.gapic_v1.method.DEFAULT, timeout=google.api_core.gapic_v1.method.DEFAULT, metadata=None, ): """ Performs synchronous speech recognition: receive results after all audio has been sent and processed. Example: >>> from google.cloud import speech_v1p1beta1 >>> from google.cloud.speech_v1p1beta1 import enums >>> >>> client = speech_v1p1beta1.SpeechClient() >>> >>> encoding = enums.RecognitionConfig.AudioEncoding.FLAC >>> sample_rate_hertz = 44100 >>> language_code = 'en-US' >>> config = {'encoding': encoding, 'sample_rate_hertz': sample_rate_hertz, 'language_code': language_code} >>> uri = 'gs://bucket_name/file_name.flac' >>> audio = {'uri': uri} >>> >>> response = client.recognize(config, audio) Args: config (Union[dict, ~google.cloud.speech_v1p1beta1.types.RecognitionConfig]): *Required* Provides information to the recognizer that specifies how to process the request. If a dict is provided, it must be of the same form as the protobuf message :class:`~google.cloud.speech_v1p1beta1.types.RecognitionConfig` audio (Union[dict, ~google.cloud.speech_v1p1beta1.types.RecognitionAudio]): *Required* The audio data to be recognized. If a dict is provided, it must be of the same form as the protobuf message :class:`~google.cloud.speech_v1p1beta1.types.RecognitionAudio` retry (Optional[google.api_core.retry.Retry]): A retry object used to retry requests. If ``None`` is specified, requests will not be retried. timeout (Optional[float]): The amount of time, in seconds, to wait for the request to complete. Note that if ``retry`` is specified, the timeout applies to each individual attempt. metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata that is provided to the method. Returns: A :class:`~google.cloud.speech_v1p1beta1.types.RecognizeResponse` instance. Raises: google.api_core.exceptions.GoogleAPICallError: If the request failed for any reason. google.api_core.exceptions.RetryError: If the request failed due to a retryable error and retry attempts failed. ValueError: If the parameters are invalid. """ # Wrap the transport method to add retry and timeout logic. if "recognize" not in self._inner_api_calls: self._inner_api_calls[ "recognize" ] = google.api_core.gapic_v1.method.wrap_method( self.transport.recognize, default_retry=self._method_configs["Recognize"].retry, default_timeout=self._method_configs["Recognize"].timeout, client_info=self._client_info, ) request = cloud_speech_pb2.RecognizeRequest(config=config, audio=audio) return self._inner_api_calls["recognize"]( request, retry=retry, timeout=timeout, metadata=metadata )
Performs synchronous speech recognition: receive results after all audio has been sent and processed. Example: >>> from google.cloud import speech_v1p1beta1 >>> from google.cloud.speech_v1p1beta1 import enums >>> >>> client = speech_v1p1beta1.SpeechClient() >>> >>> encoding = enums.RecognitionConfig.AudioEncoding.FLAC >>> sample_rate_hertz = 44100 >>> language_code = 'en-US' >>> config = {'encoding': encoding, 'sample_rate_hertz': sample_rate_hertz, 'language_code': language_code} >>> uri = 'gs://bucket_name/file_name.flac' >>> audio = {'uri': uri} >>> >>> response = client.recognize(config, audio) Args: config (Union[dict, ~google.cloud.speech_v1p1beta1.types.RecognitionConfig]): *Required* Provides information to the recognizer that specifies how to process the request. If a dict is provided, it must be of the same form as the protobuf message :class:`~google.cloud.speech_v1p1beta1.types.RecognitionConfig` audio (Union[dict, ~google.cloud.speech_v1p1beta1.types.RecognitionAudio]): *Required* The audio data to be recognized. If a dict is provided, it must be of the same form as the protobuf message :class:`~google.cloud.speech_v1p1beta1.types.RecognitionAudio` retry (Optional[google.api_core.retry.Retry]): A retry object used to retry requests. If ``None`` is specified, requests will not be retried. timeout (Optional[float]): The amount of time, in seconds, to wait for the request to complete. Note that if ``retry`` is specified, the timeout applies to each individual attempt. metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata that is provided to the method. Returns: A :class:`~google.cloud.speech_v1p1beta1.types.RecognizeResponse` instance. Raises: google.api_core.exceptions.GoogleAPICallError: If the request failed for any reason. google.api_core.exceptions.RetryError: If the request failed due to a retryable error and retry attempts failed. ValueError: If the parameters are invalid.
Below is the the instruction that describes the task: ### Input: Performs synchronous speech recognition: receive results after all audio has been sent and processed. Example: >>> from google.cloud import speech_v1p1beta1 >>> from google.cloud.speech_v1p1beta1 import enums >>> >>> client = speech_v1p1beta1.SpeechClient() >>> >>> encoding = enums.RecognitionConfig.AudioEncoding.FLAC >>> sample_rate_hertz = 44100 >>> language_code = 'en-US' >>> config = {'encoding': encoding, 'sample_rate_hertz': sample_rate_hertz, 'language_code': language_code} >>> uri = 'gs://bucket_name/file_name.flac' >>> audio = {'uri': uri} >>> >>> response = client.recognize(config, audio) Args: config (Union[dict, ~google.cloud.speech_v1p1beta1.types.RecognitionConfig]): *Required* Provides information to the recognizer that specifies how to process the request. If a dict is provided, it must be of the same form as the protobuf message :class:`~google.cloud.speech_v1p1beta1.types.RecognitionConfig` audio (Union[dict, ~google.cloud.speech_v1p1beta1.types.RecognitionAudio]): *Required* The audio data to be recognized. If a dict is provided, it must be of the same form as the protobuf message :class:`~google.cloud.speech_v1p1beta1.types.RecognitionAudio` retry (Optional[google.api_core.retry.Retry]): A retry object used to retry requests. If ``None`` is specified, requests will not be retried. timeout (Optional[float]): The amount of time, in seconds, to wait for the request to complete. Note that if ``retry`` is specified, the timeout applies to each individual attempt. metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata that is provided to the method. Returns: A :class:`~google.cloud.speech_v1p1beta1.types.RecognizeResponse` instance. Raises: google.api_core.exceptions.GoogleAPICallError: If the request failed for any reason. google.api_core.exceptions.RetryError: If the request failed due to a retryable error and retry attempts failed. ValueError: If the parameters are invalid. ### Response: def recognize( self, config, audio, retry=google.api_core.gapic_v1.method.DEFAULT, timeout=google.api_core.gapic_v1.method.DEFAULT, metadata=None, ): """ Performs synchronous speech recognition: receive results after all audio has been sent and processed. Example: >>> from google.cloud import speech_v1p1beta1 >>> from google.cloud.speech_v1p1beta1 import enums >>> >>> client = speech_v1p1beta1.SpeechClient() >>> >>> encoding = enums.RecognitionConfig.AudioEncoding.FLAC >>> sample_rate_hertz = 44100 >>> language_code = 'en-US' >>> config = {'encoding': encoding, 'sample_rate_hertz': sample_rate_hertz, 'language_code': language_code} >>> uri = 'gs://bucket_name/file_name.flac' >>> audio = {'uri': uri} >>> >>> response = client.recognize(config, audio) Args: config (Union[dict, ~google.cloud.speech_v1p1beta1.types.RecognitionConfig]): *Required* Provides information to the recognizer that specifies how to process the request. If a dict is provided, it must be of the same form as the protobuf message :class:`~google.cloud.speech_v1p1beta1.types.RecognitionConfig` audio (Union[dict, ~google.cloud.speech_v1p1beta1.types.RecognitionAudio]): *Required* The audio data to be recognized. If a dict is provided, it must be of the same form as the protobuf message :class:`~google.cloud.speech_v1p1beta1.types.RecognitionAudio` retry (Optional[google.api_core.retry.Retry]): A retry object used to retry requests. If ``None`` is specified, requests will not be retried. timeout (Optional[float]): The amount of time, in seconds, to wait for the request to complete. Note that if ``retry`` is specified, the timeout applies to each individual attempt. metadata (Optional[Sequence[Tuple[str, str]]]): Additional metadata that is provided to the method. Returns: A :class:`~google.cloud.speech_v1p1beta1.types.RecognizeResponse` instance. Raises: google.api_core.exceptions.GoogleAPICallError: If the request failed for any reason. google.api_core.exceptions.RetryError: If the request failed due to a retryable error and retry attempts failed. ValueError: If the parameters are invalid. """ # Wrap the transport method to add retry and timeout logic. if "recognize" not in self._inner_api_calls: self._inner_api_calls[ "recognize" ] = google.api_core.gapic_v1.method.wrap_method( self.transport.recognize, default_retry=self._method_configs["Recognize"].retry, default_timeout=self._method_configs["Recognize"].timeout, client_info=self._client_info, ) request = cloud_speech_pb2.RecognizeRequest(config=config, audio=audio) return self._inner_api_calls["recognize"]( request, retry=retry, timeout=timeout, metadata=metadata )
def get_options(self, section='default', opt_keys=None, vars=None): """ Get all options for a section. If ``opt_keys`` is given return only options with those keys. """ vars = vars if vars else self.default_vars conf = self.parser opts = {} if opt_keys is None: if conf is None: opt_keys = {} else: if not self.robust or conf.has_section(section): opt_keys = conf.options(section) else: opt_keys = {} else: logger.debug('conf: %s' % conf) copts = conf.options(section) if conf else {} opt_keys = set(opt_keys).intersection(set(copts)) for option in opt_keys: logger.debug(f'option: {option}, vars: {vars}') opts[option] = conf.get(section, option, vars=vars) return opts
Get all options for a section. If ``opt_keys`` is given return only options with those keys.
Below is the the instruction that describes the task: ### Input: Get all options for a section. If ``opt_keys`` is given return only options with those keys. ### Response: def get_options(self, section='default', opt_keys=None, vars=None): """ Get all options for a section. If ``opt_keys`` is given return only options with those keys. """ vars = vars if vars else self.default_vars conf = self.parser opts = {} if opt_keys is None: if conf is None: opt_keys = {} else: if not self.robust or conf.has_section(section): opt_keys = conf.options(section) else: opt_keys = {} else: logger.debug('conf: %s' % conf) copts = conf.options(section) if conf else {} opt_keys = set(opt_keys).intersection(set(copts)) for option in opt_keys: logger.debug(f'option: {option}, vars: {vars}') opts[option] = conf.get(section, option, vars=vars) return opts
def set_executing(on: bool): """ Toggle whether or not the current thread is executing a step file. This will only apply when the current thread is a CauldronThread. This function has no effect when run on a Main thread. :param on: Whether or not the thread should be annotated as executing a step file. """ my_thread = threading.current_thread() if isinstance(my_thread, threads.CauldronThread): my_thread.is_executing = on
Toggle whether or not the current thread is executing a step file. This will only apply when the current thread is a CauldronThread. This function has no effect when run on a Main thread. :param on: Whether or not the thread should be annotated as executing a step file.
Below is the the instruction that describes the task: ### Input: Toggle whether or not the current thread is executing a step file. This will only apply when the current thread is a CauldronThread. This function has no effect when run on a Main thread. :param on: Whether or not the thread should be annotated as executing a step file. ### Response: def set_executing(on: bool): """ Toggle whether or not the current thread is executing a step file. This will only apply when the current thread is a CauldronThread. This function has no effect when run on a Main thread. :param on: Whether or not the thread should be annotated as executing a step file. """ my_thread = threading.current_thread() if isinstance(my_thread, threads.CauldronThread): my_thread.is_executing = on
def redshift(distance, **kwargs): r"""Returns the redshift associated with the given luminosity distance. If the requested cosmology is one of the pre-defined ones in :py:attr:`astropy.cosmology.parameters.available`, :py:class:`DistToZ` is used to provide a fast interpolation. This takes a few seconds to setup on the first call. Parameters ---------- distance : float The luminosity distance, in Mpc. \**kwargs : All other keyword args are passed to :py:func:`get_cosmology` to select a cosmology. If none provided, will use :py:attr:`DEFAULT_COSMOLOGY`. Returns ------- float : The redshift corresponding to the given distance. """ cosmology = get_cosmology(**kwargs) try: z = _d2zs[cosmology.name](distance) except KeyError: # not a standard cosmology, call the redshift function z = _redshift(distance, cosmology=cosmology) return z
r"""Returns the redshift associated with the given luminosity distance. If the requested cosmology is one of the pre-defined ones in :py:attr:`astropy.cosmology.parameters.available`, :py:class:`DistToZ` is used to provide a fast interpolation. This takes a few seconds to setup on the first call. Parameters ---------- distance : float The luminosity distance, in Mpc. \**kwargs : All other keyword args are passed to :py:func:`get_cosmology` to select a cosmology. If none provided, will use :py:attr:`DEFAULT_COSMOLOGY`. Returns ------- float : The redshift corresponding to the given distance.
Below is the the instruction that describes the task: ### Input: r"""Returns the redshift associated with the given luminosity distance. If the requested cosmology is one of the pre-defined ones in :py:attr:`astropy.cosmology.parameters.available`, :py:class:`DistToZ` is used to provide a fast interpolation. This takes a few seconds to setup on the first call. Parameters ---------- distance : float The luminosity distance, in Mpc. \**kwargs : All other keyword args are passed to :py:func:`get_cosmology` to select a cosmology. If none provided, will use :py:attr:`DEFAULT_COSMOLOGY`. Returns ------- float : The redshift corresponding to the given distance. ### Response: def redshift(distance, **kwargs): r"""Returns the redshift associated with the given luminosity distance. If the requested cosmology is one of the pre-defined ones in :py:attr:`astropy.cosmology.parameters.available`, :py:class:`DistToZ` is used to provide a fast interpolation. This takes a few seconds to setup on the first call. Parameters ---------- distance : float The luminosity distance, in Mpc. \**kwargs : All other keyword args are passed to :py:func:`get_cosmology` to select a cosmology. If none provided, will use :py:attr:`DEFAULT_COSMOLOGY`. Returns ------- float : The redshift corresponding to the given distance. """ cosmology = get_cosmology(**kwargs) try: z = _d2zs[cosmology.name](distance) except KeyError: # not a standard cosmology, call the redshift function z = _redshift(distance, cosmology=cosmology) return z
def ListMappedNetworkDrives(): ''' On Windows, returns a list of mapped network drives :return: tuple(string, string, bool) For each mapped netword drive, return 3 values tuple: - the local drive - the remote path- - True if the mapping is enabled (warning: not reliable) ''' if sys.platform != 'win32': raise NotImplementedError drives_list = [] netuse = _CallWindowsNetCommand(['use']) for line in netuse.split(EOL_STYLE_WINDOWS): match = re.match("(\w*)\s+(\w:)\s+(.+)", line.rstrip()) if match: drives_list.append((match.group(2), match.group(3), match.group(1) == 'OK')) return drives_list
On Windows, returns a list of mapped network drives :return: tuple(string, string, bool) For each mapped netword drive, return 3 values tuple: - the local drive - the remote path- - True if the mapping is enabled (warning: not reliable)
Below is the the instruction that describes the task: ### Input: On Windows, returns a list of mapped network drives :return: tuple(string, string, bool) For each mapped netword drive, return 3 values tuple: - the local drive - the remote path- - True if the mapping is enabled (warning: not reliable) ### Response: def ListMappedNetworkDrives(): ''' On Windows, returns a list of mapped network drives :return: tuple(string, string, bool) For each mapped netword drive, return 3 values tuple: - the local drive - the remote path- - True if the mapping is enabled (warning: not reliable) ''' if sys.platform != 'win32': raise NotImplementedError drives_list = [] netuse = _CallWindowsNetCommand(['use']) for line in netuse.split(EOL_STYLE_WINDOWS): match = re.match("(\w*)\s+(\w:)\s+(.+)", line.rstrip()) if match: drives_list.append((match.group(2), match.group(3), match.group(1) == 'OK')) return drives_list
def birthdays_subcommand(vcard_list, parsable): """Print birthday contact table. :param vcard_list: the vcards to search for matching entries which should be printed :type vcard_list: list of carddav_object.CarddavObject :param parsable: machine readable output: columns devided by tabulator (\t) :type parsable: bool :returns: None :rtype: None """ # filter out contacts without a birthday date vcard_list = [ vcard for vcard in vcard_list if vcard.get_birthday() is not None] # sort by date (month and day) # The sort function should work for strings and datetime objects. All # strings will besorted before any datetime objects. vcard_list.sort( key=lambda x: (x.get_birthday().month, x.get_birthday().day) if isinstance(x.get_birthday(), datetime.datetime) else (0, 0, x.get_birthday())) # add to string list birthday_list = [] for vcard in vcard_list: date = vcard.get_birthday() if parsable: if config.display_by_name() == "first_name": birthday_list.append("%04d.%02d.%02d\t%s" % (date.year, date.month, date.day, vcard.get_first_name_last_name())) else: birthday_list.append("%04d.%02d.%02d\t%s" % (date.year, date.month, date.day, vcard.get_last_name_first_name())) else: if config.display_by_name() == "first_name": birthday_list.append("%s\t%s" % (vcard.get_first_name_last_name(), vcard.get_formatted_birthday())) else: birthday_list.append("%s\t%s" % (vcard.get_last_name_first_name(), vcard.get_formatted_birthday())) if birthday_list: if parsable: print('\n'.join(birthday_list)) else: list_birthdays(birthday_list) else: if not parsable: print("Found no birthdays") sys.exit(1)
Print birthday contact table. :param vcard_list: the vcards to search for matching entries which should be printed :type vcard_list: list of carddav_object.CarddavObject :param parsable: machine readable output: columns devided by tabulator (\t) :type parsable: bool :returns: None :rtype: None
Below is the the instruction that describes the task: ### Input: Print birthday contact table. :param vcard_list: the vcards to search for matching entries which should be printed :type vcard_list: list of carddav_object.CarddavObject :param parsable: machine readable output: columns devided by tabulator (\t) :type parsable: bool :returns: None :rtype: None ### Response: def birthdays_subcommand(vcard_list, parsable): """Print birthday contact table. :param vcard_list: the vcards to search for matching entries which should be printed :type vcard_list: list of carddav_object.CarddavObject :param parsable: machine readable output: columns devided by tabulator (\t) :type parsable: bool :returns: None :rtype: None """ # filter out contacts without a birthday date vcard_list = [ vcard for vcard in vcard_list if vcard.get_birthday() is not None] # sort by date (month and day) # The sort function should work for strings and datetime objects. All # strings will besorted before any datetime objects. vcard_list.sort( key=lambda x: (x.get_birthday().month, x.get_birthday().day) if isinstance(x.get_birthday(), datetime.datetime) else (0, 0, x.get_birthday())) # add to string list birthday_list = [] for vcard in vcard_list: date = vcard.get_birthday() if parsable: if config.display_by_name() == "first_name": birthday_list.append("%04d.%02d.%02d\t%s" % (date.year, date.month, date.day, vcard.get_first_name_last_name())) else: birthday_list.append("%04d.%02d.%02d\t%s" % (date.year, date.month, date.day, vcard.get_last_name_first_name())) else: if config.display_by_name() == "first_name": birthday_list.append("%s\t%s" % (vcard.get_first_name_last_name(), vcard.get_formatted_birthday())) else: birthday_list.append("%s\t%s" % (vcard.get_last_name_first_name(), vcard.get_formatted_birthday())) if birthday_list: if parsable: print('\n'.join(birthday_list)) else: list_birthdays(birthday_list) else: if not parsable: print("Found no birthdays") sys.exit(1)
def up(self): """Moves the layer up in the stacking order. """ i = self.index() if i != None: del self.canvas.layers[i] i = min(len(self.canvas.layers), i+1) self.canvas.layers.insert(i, self)
Moves the layer up in the stacking order.
Below is the the instruction that describes the task: ### Input: Moves the layer up in the stacking order. ### Response: def up(self): """Moves the layer up in the stacking order. """ i = self.index() if i != None: del self.canvas.layers[i] i = min(len(self.canvas.layers), i+1) self.canvas.layers.insert(i, self)
def _get_license_description(license_code): """ Gets the body for a license based on a license code """ req = requests.get("{base_url}/licenses/{license_code}".format( base_url=BASE_URL, license_code=license_code), headers=_HEADERS) if req.status_code == requests.codes.ok: s = req.json()["body"] search_curly = re.search(r'\{(.*)\}', s) search_square = re.search(r'\[(.*)\]', s) license = "" replace_string = '{year} {name}'.format(year=date.today().year, name=_get_config_name()) if search_curly: license = re.sub(r'\{(.+)\}', replace_string, s) elif search_square: license = re.sub(r'\[(.+)\]', replace_string, s) else: license = s return license else: print(Fore.RED + 'No such license. Please check again.'), print(Style.RESET_ALL), sys.exit()
Gets the body for a license based on a license code
Below is the the instruction that describes the task: ### Input: Gets the body for a license based on a license code ### Response: def _get_license_description(license_code): """ Gets the body for a license based on a license code """ req = requests.get("{base_url}/licenses/{license_code}".format( base_url=BASE_URL, license_code=license_code), headers=_HEADERS) if req.status_code == requests.codes.ok: s = req.json()["body"] search_curly = re.search(r'\{(.*)\}', s) search_square = re.search(r'\[(.*)\]', s) license = "" replace_string = '{year} {name}'.format(year=date.today().year, name=_get_config_name()) if search_curly: license = re.sub(r'\{(.+)\}', replace_string, s) elif search_square: license = re.sub(r'\[(.+)\]', replace_string, s) else: license = s return license else: print(Fore.RED + 'No such license. Please check again.'), print(Style.RESET_ALL), sys.exit()
def safe_split_text(text: str, length: int = MAX_MESSAGE_LENGTH) -> typing.List[str]: """ Split long text :param text: :param length: :return: """ # TODO: More informative description temp_text = text parts = [] while temp_text: if len(temp_text) > length: try: split_pos = temp_text[:length].rindex(' ') except ValueError: split_pos = length if split_pos < length // 4 * 3: split_pos = length parts.append(temp_text[:split_pos]) temp_text = temp_text[split_pos:].lstrip() else: parts.append(temp_text) break return parts
Split long text :param text: :param length: :return:
Below is the the instruction that describes the task: ### Input: Split long text :param text: :param length: :return: ### Response: def safe_split_text(text: str, length: int = MAX_MESSAGE_LENGTH) -> typing.List[str]: """ Split long text :param text: :param length: :return: """ # TODO: More informative description temp_text = text parts = [] while temp_text: if len(temp_text) > length: try: split_pos = temp_text[:length].rindex(' ') except ValueError: split_pos = length if split_pos < length // 4 * 3: split_pos = length parts.append(temp_text[:split_pos]) temp_text = temp_text[split_pos:].lstrip() else: parts.append(temp_text) break return parts
def iter_get( self, name=None, group=None, index=None, raster=None, samples_only=False, raw=False, ): """ iterator over a channel This is usefull in case of large files with a small number of channels. If the *raster* keyword argument is not *None* the output is interpolated accordingly Parameters ---------- name : string name of channel group : int 0-based group index index : int 0-based channel index raster : float time raster in seconds samples_only : bool if *True* return only the channel samples as numpy array; if *False* return a *Signal* object raw : bool return channel samples without appling the conversion rule; default `False` """ gp_nr, ch_nr = self._validate_channel_selection(name, group, index) grp = self.groups[gp_nr] data = self._load_data(grp) for fragment in data: yield self.get( group=gp_nr, index=ch_nr, raster=raster, samples_only=samples_only, data=fragment, raw=raw, )
iterator over a channel This is usefull in case of large files with a small number of channels. If the *raster* keyword argument is not *None* the output is interpolated accordingly Parameters ---------- name : string name of channel group : int 0-based group index index : int 0-based channel index raster : float time raster in seconds samples_only : bool if *True* return only the channel samples as numpy array; if *False* return a *Signal* object raw : bool return channel samples without appling the conversion rule; default `False`
Below is the the instruction that describes the task: ### Input: iterator over a channel This is usefull in case of large files with a small number of channels. If the *raster* keyword argument is not *None* the output is interpolated accordingly Parameters ---------- name : string name of channel group : int 0-based group index index : int 0-based channel index raster : float time raster in seconds samples_only : bool if *True* return only the channel samples as numpy array; if *False* return a *Signal* object raw : bool return channel samples without appling the conversion rule; default `False` ### Response: def iter_get( self, name=None, group=None, index=None, raster=None, samples_only=False, raw=False, ): """ iterator over a channel This is usefull in case of large files with a small number of channels. If the *raster* keyword argument is not *None* the output is interpolated accordingly Parameters ---------- name : string name of channel group : int 0-based group index index : int 0-based channel index raster : float time raster in seconds samples_only : bool if *True* return only the channel samples as numpy array; if *False* return a *Signal* object raw : bool return channel samples without appling the conversion rule; default `False` """ gp_nr, ch_nr = self._validate_channel_selection(name, group, index) grp = self.groups[gp_nr] data = self._load_data(grp) for fragment in data: yield self.get( group=gp_nr, index=ch_nr, raster=raster, samples_only=samples_only, data=fragment, raw=raw, )
def enabled(name): ''' Ensure an Apache conf is enabled. name Name of the Apache conf ''' ret = {'name': name, 'result': True, 'comment': '', 'changes': {}} is_enabled = __salt__['apache.check_conf_enabled'](name) if not is_enabled: if __opts__['test']: msg = 'Apache conf {0} is set to be enabled.'.format(name) ret['comment'] = msg ret['changes']['old'] = None ret['changes']['new'] = name ret['result'] = None return ret status = __salt__['apache.a2enconf'](name)['Status'] if isinstance(status, six.string_types) and 'enabled' in status: ret['result'] = True ret['changes']['old'] = None ret['changes']['new'] = name else: ret['result'] = False ret['comment'] = 'Failed to enable {0} Apache conf'.format(name) if isinstance(status, six.string_types): ret['comment'] = ret['comment'] + ' ({0})'.format(status) return ret else: ret['comment'] = '{0} already enabled.'.format(name) return ret
Ensure an Apache conf is enabled. name Name of the Apache conf
Below is the the instruction that describes the task: ### Input: Ensure an Apache conf is enabled. name Name of the Apache conf ### Response: def enabled(name): ''' Ensure an Apache conf is enabled. name Name of the Apache conf ''' ret = {'name': name, 'result': True, 'comment': '', 'changes': {}} is_enabled = __salt__['apache.check_conf_enabled'](name) if not is_enabled: if __opts__['test']: msg = 'Apache conf {0} is set to be enabled.'.format(name) ret['comment'] = msg ret['changes']['old'] = None ret['changes']['new'] = name ret['result'] = None return ret status = __salt__['apache.a2enconf'](name)['Status'] if isinstance(status, six.string_types) and 'enabled' in status: ret['result'] = True ret['changes']['old'] = None ret['changes']['new'] = name else: ret['result'] = False ret['comment'] = 'Failed to enable {0} Apache conf'.format(name) if isinstance(status, six.string_types): ret['comment'] = ret['comment'] + ' ({0})'.format(status) return ret else: ret['comment'] = '{0} already enabled.'.format(name) return ret
def select_graphic_rendition(self, *attrs): """Set display attributes. :param list attrs: a list of display attributes to set. """ replace = {} # Fast path for resetting all attributes. if not attrs or attrs == (0, ): self.cursor.attrs = self.default_char return else: attrs = list(reversed(attrs)) while attrs: attr = attrs.pop() if attr == 0: # Reset all attributes. replace.update(self.default_char._asdict()) elif attr in g.FG_ANSI: replace["fg"] = g.FG_ANSI[attr] elif attr in g.BG: replace["bg"] = g.BG_ANSI[attr] elif attr in g.TEXT: attr = g.TEXT[attr] replace[attr[1:]] = attr.startswith("+") elif attr in g.FG_AIXTERM: replace.update(fg=g.FG_AIXTERM[attr], bold=True) elif attr in g.BG_AIXTERM: replace.update(bg=g.BG_AIXTERM[attr], bold=True) elif attr in (g.FG_256, g.BG_256): key = "fg" if attr == g.FG_256 else "bg" try: n = attrs.pop() if n == 5: # 256. m = attrs.pop() replace[key] = g.FG_BG_256[m] elif n == 2: # 24bit. # This is somewhat non-standard but is nonetheless # supported in quite a few terminals. See discussion # here https://gist.github.com/XVilka/8346728. replace[key] = "{0:02x}{1:02x}{2:02x}".format( attrs.pop(), attrs.pop(), attrs.pop()) except IndexError: pass self.cursor.attrs = self.cursor.attrs._replace(**replace)
Set display attributes. :param list attrs: a list of display attributes to set.
Below is the the instruction that describes the task: ### Input: Set display attributes. :param list attrs: a list of display attributes to set. ### Response: def select_graphic_rendition(self, *attrs): """Set display attributes. :param list attrs: a list of display attributes to set. """ replace = {} # Fast path for resetting all attributes. if not attrs or attrs == (0, ): self.cursor.attrs = self.default_char return else: attrs = list(reversed(attrs)) while attrs: attr = attrs.pop() if attr == 0: # Reset all attributes. replace.update(self.default_char._asdict()) elif attr in g.FG_ANSI: replace["fg"] = g.FG_ANSI[attr] elif attr in g.BG: replace["bg"] = g.BG_ANSI[attr] elif attr in g.TEXT: attr = g.TEXT[attr] replace[attr[1:]] = attr.startswith("+") elif attr in g.FG_AIXTERM: replace.update(fg=g.FG_AIXTERM[attr], bold=True) elif attr in g.BG_AIXTERM: replace.update(bg=g.BG_AIXTERM[attr], bold=True) elif attr in (g.FG_256, g.BG_256): key = "fg" if attr == g.FG_256 else "bg" try: n = attrs.pop() if n == 5: # 256. m = attrs.pop() replace[key] = g.FG_BG_256[m] elif n == 2: # 24bit. # This is somewhat non-standard but is nonetheless # supported in quite a few terminals. See discussion # here https://gist.github.com/XVilka/8346728. replace[key] = "{0:02x}{1:02x}{2:02x}".format( attrs.pop(), attrs.pop(), attrs.pop()) except IndexError: pass self.cursor.attrs = self.cursor.attrs._replace(**replace)
def relu(inplace:bool=False, leaky:float=None): "Return a relu activation, maybe `leaky` and `inplace`." return nn.LeakyReLU(inplace=inplace, negative_slope=leaky) if leaky is not None else nn.ReLU(inplace=inplace)
Return a relu activation, maybe `leaky` and `inplace`.
Below is the the instruction that describes the task: ### Input: Return a relu activation, maybe `leaky` and `inplace`. ### Response: def relu(inplace:bool=False, leaky:float=None): "Return a relu activation, maybe `leaky` and `inplace`." return nn.LeakyReLU(inplace=inplace, negative_slope=leaky) if leaky is not None else nn.ReLU(inplace=inplace)
def resume_reading(self): """ Called by the client protocol to resume the receiving end. The protocol's ``frame_received()`` method will be called once again if some data is available for reading. """ # Clear the read pause status self._recv_paused = False # Call resume_reading() on the transport self._transport.resume_reading() # If there's data in the receive buffer, pass it on to the # client protocol if self._recv_buf: self.data_received(b'')
Called by the client protocol to resume the receiving end. The protocol's ``frame_received()`` method will be called once again if some data is available for reading.
Below is the the instruction that describes the task: ### Input: Called by the client protocol to resume the receiving end. The protocol's ``frame_received()`` method will be called once again if some data is available for reading. ### Response: def resume_reading(self): """ Called by the client protocol to resume the receiving end. The protocol's ``frame_received()`` method will be called once again if some data is available for reading. """ # Clear the read pause status self._recv_paused = False # Call resume_reading() on the transport self._transport.resume_reading() # If there's data in the receive buffer, pass it on to the # client protocol if self._recv_buf: self.data_received(b'')
def write_byte_data(self, address, register, value): """ SMBus Read Byte: i2c_smbus_read_byte_data() ============================================ This reads a single byte from a device, from a designated register. The register is specified through the Comm byte. S Addr Wr [A] Comm [A] S Addr Rd [A] [Data] NA P Functionality flag: I2C_FUNC_SMBUS_READ_BYTE_DATA """ return self.smbus.write_byte_data(address, register, value)
SMBus Read Byte: i2c_smbus_read_byte_data() ============================================ This reads a single byte from a device, from a designated register. The register is specified through the Comm byte. S Addr Wr [A] Comm [A] S Addr Rd [A] [Data] NA P Functionality flag: I2C_FUNC_SMBUS_READ_BYTE_DATA
Below is the the instruction that describes the task: ### Input: SMBus Read Byte: i2c_smbus_read_byte_data() ============================================ This reads a single byte from a device, from a designated register. The register is specified through the Comm byte. S Addr Wr [A] Comm [A] S Addr Rd [A] [Data] NA P Functionality flag: I2C_FUNC_SMBUS_READ_BYTE_DATA ### Response: def write_byte_data(self, address, register, value): """ SMBus Read Byte: i2c_smbus_read_byte_data() ============================================ This reads a single byte from a device, from a designated register. The register is specified through the Comm byte. S Addr Wr [A] Comm [A] S Addr Rd [A] [Data] NA P Functionality flag: I2C_FUNC_SMBUS_READ_BYTE_DATA """ return self.smbus.write_byte_data(address, register, value)
def read_scans(sdmfile, bdfdir=''): """ Use sdmpy to get all scans and info needed for rtpipe as dict """ sdm = getsdm(sdmfile, bdfdir=bdfdir) scandict = {} skippedscans = [] for scan in sdm.scans(): scannum = int(scan.idx) scandict[scannum] = {} intentstr = ' '.join(scan.intents) src = scan.source scandict[scannum]['source'] = src scandict[scannum]['intent'] = intentstr # bdf specific properties try: startmjd = scan.bdf.startTime nints = scan.bdf.numIntegration interval = scan.bdf.get_integration(0).interval endmjd = startmjd + (nints*interval)/(24*3600) bdfstr = scan.bdf.fname except AttributeError, IOError: skippedscans.append(scannum) else: scandict[scannum]['startmjd'] = startmjd scandict[scannum]['endmjd'] = endmjd scandict[scannum]['duration'] = endmjd-startmjd scandict[scannum]['nints'] = nints scandict[scannum]['bdfstr'] = bdfstr # clear reference to nonexistent BDFs (either bad or not in standard locations) if (not os.path.exists(scandict[scannum]['bdfstr'])) or ('X1' in bdfstr): scandict[scannum]['bdfstr'] = None logger.debug('Invalid bdf for %d of %s' % (scannum, sdmfile) ) if skippedscans: logger.warn('No BDF found for scans {0}'.format(skippedscans)) return scandict
Use sdmpy to get all scans and info needed for rtpipe as dict
Below is the the instruction that describes the task: ### Input: Use sdmpy to get all scans and info needed for rtpipe as dict ### Response: def read_scans(sdmfile, bdfdir=''): """ Use sdmpy to get all scans and info needed for rtpipe as dict """ sdm = getsdm(sdmfile, bdfdir=bdfdir) scandict = {} skippedscans = [] for scan in sdm.scans(): scannum = int(scan.idx) scandict[scannum] = {} intentstr = ' '.join(scan.intents) src = scan.source scandict[scannum]['source'] = src scandict[scannum]['intent'] = intentstr # bdf specific properties try: startmjd = scan.bdf.startTime nints = scan.bdf.numIntegration interval = scan.bdf.get_integration(0).interval endmjd = startmjd + (nints*interval)/(24*3600) bdfstr = scan.bdf.fname except AttributeError, IOError: skippedscans.append(scannum) else: scandict[scannum]['startmjd'] = startmjd scandict[scannum]['endmjd'] = endmjd scandict[scannum]['duration'] = endmjd-startmjd scandict[scannum]['nints'] = nints scandict[scannum]['bdfstr'] = bdfstr # clear reference to nonexistent BDFs (either bad or not in standard locations) if (not os.path.exists(scandict[scannum]['bdfstr'])) or ('X1' in bdfstr): scandict[scannum]['bdfstr'] = None logger.debug('Invalid bdf for %d of %s' % (scannum, sdmfile) ) if skippedscans: logger.warn('No BDF found for scans {0}'.format(skippedscans)) return scandict
def figure( key=None, width=400, height=500, lighting=True, controls=True, controls_vr=False, controls_light=False, debug=False, **kwargs ): """Create a new figure if no key is given, or return the figure associated with key. :param key: Python object that identifies this figure :param int width: pixel width of WebGL canvas :param int height: .. height .. :param bool lighting: use lighting or not :param bool controls: show controls or not :param bool controls_vr: show controls for VR or not :param bool debug: show debug buttons or not :return: :any:`Figure` """ if key is not None and key in current.figures: current.figure = current.figures[key] current.container = current.containers[key] elif isinstance(key, ipv.Figure) and key in current.figures.values(): key_index = list(current.figures.values()).index(key) key = list(current.figures.keys())[key_index] current.figure = current.figures[key] current.container = current.containers[key] else: current.figure = ipv.Figure(width=width, height=height, **kwargs) current.container = ipywidgets.VBox() current.container.children = [current.figure] if key is None: key = uuid.uuid4().hex current.figures[key] = current.figure current.containers[key] = current.container if controls: # stereo = ipywidgets.ToggleButton(value=current.figure.stereo, description='stereo', icon='eye') # l1 = ipywidgets.jslink((current.figure, 'stereo'), (stereo, 'value')) # current.container.children += (ipywidgets.HBox([stereo, ]),) pass # stereo and fullscreen are now include in the js code (per view) if controls_vr: eye_separation = ipywidgets.FloatSlider(value=current.figure.eye_separation, min=-10, max=10, icon='eye') ipywidgets.jslink((eye_separation, 'value'), (current.figure, 'eye_separation')) current.container.children += (eye_separation,) if controls_light: globals()['controls_light']() if debug: show = ipywidgets.ToggleButtons(options=["Volume", "Back", "Front", "Coordinate"]) current.container.children += (show,) # ipywidgets.jslink((current.figure, 'show'), (show, 'value')) traitlets.link((current.figure, 'show'), (show, 'value')) return current.figure
Create a new figure if no key is given, or return the figure associated with key. :param key: Python object that identifies this figure :param int width: pixel width of WebGL canvas :param int height: .. height .. :param bool lighting: use lighting or not :param bool controls: show controls or not :param bool controls_vr: show controls for VR or not :param bool debug: show debug buttons or not :return: :any:`Figure`
Below is the the instruction that describes the task: ### Input: Create a new figure if no key is given, or return the figure associated with key. :param key: Python object that identifies this figure :param int width: pixel width of WebGL canvas :param int height: .. height .. :param bool lighting: use lighting or not :param bool controls: show controls or not :param bool controls_vr: show controls for VR or not :param bool debug: show debug buttons or not :return: :any:`Figure` ### Response: def figure( key=None, width=400, height=500, lighting=True, controls=True, controls_vr=False, controls_light=False, debug=False, **kwargs ): """Create a new figure if no key is given, or return the figure associated with key. :param key: Python object that identifies this figure :param int width: pixel width of WebGL canvas :param int height: .. height .. :param bool lighting: use lighting or not :param bool controls: show controls or not :param bool controls_vr: show controls for VR or not :param bool debug: show debug buttons or not :return: :any:`Figure` """ if key is not None and key in current.figures: current.figure = current.figures[key] current.container = current.containers[key] elif isinstance(key, ipv.Figure) and key in current.figures.values(): key_index = list(current.figures.values()).index(key) key = list(current.figures.keys())[key_index] current.figure = current.figures[key] current.container = current.containers[key] else: current.figure = ipv.Figure(width=width, height=height, **kwargs) current.container = ipywidgets.VBox() current.container.children = [current.figure] if key is None: key = uuid.uuid4().hex current.figures[key] = current.figure current.containers[key] = current.container if controls: # stereo = ipywidgets.ToggleButton(value=current.figure.stereo, description='stereo', icon='eye') # l1 = ipywidgets.jslink((current.figure, 'stereo'), (stereo, 'value')) # current.container.children += (ipywidgets.HBox([stereo, ]),) pass # stereo and fullscreen are now include in the js code (per view) if controls_vr: eye_separation = ipywidgets.FloatSlider(value=current.figure.eye_separation, min=-10, max=10, icon='eye') ipywidgets.jslink((eye_separation, 'value'), (current.figure, 'eye_separation')) current.container.children += (eye_separation,) if controls_light: globals()['controls_light']() if debug: show = ipywidgets.ToggleButtons(options=["Volume", "Back", "Front", "Coordinate"]) current.container.children += (show,) # ipywidgets.jslink((current.figure, 'show'), (show, 'value')) traitlets.link((current.figure, 'show'), (show, 'value')) return current.figure
def execute(self, offset=0, **query): """ Executes a query. Additional query parameters can be passed as keyword arguments. Returns: The request parameters and the raw query response. """ _params = self._build_query(**query) self._page_offset = offset _params.update( offset=self._page_offset, limit=min(self._page_size, self._limit) ) logger.debug('executing query. from/limit: %6d/%d' % (_params['offset'], _params['limit'])) # If the request results in a SolveError (ie bad filter) set the error. try: self._response = self._client.post(self._data_url, _params) except SolveError as e: self._error = e raise logger.debug('query response took: %(took)d ms, total: %(total)d' % self._response) return _params, self._response
Executes a query. Additional query parameters can be passed as keyword arguments. Returns: The request parameters and the raw query response.
Below is the the instruction that describes the task: ### Input: Executes a query. Additional query parameters can be passed as keyword arguments. Returns: The request parameters and the raw query response. ### Response: def execute(self, offset=0, **query): """ Executes a query. Additional query parameters can be passed as keyword arguments. Returns: The request parameters and the raw query response. """ _params = self._build_query(**query) self._page_offset = offset _params.update( offset=self._page_offset, limit=min(self._page_size, self._limit) ) logger.debug('executing query. from/limit: %6d/%d' % (_params['offset'], _params['limit'])) # If the request results in a SolveError (ie bad filter) set the error. try: self._response = self._client.post(self._data_url, _params) except SolveError as e: self._error = e raise logger.debug('query response took: %(took)d ms, total: %(total)d' % self._response) return _params, self._response
def pokeStorable(self, storable, objname, obj, container, visited=None, _stack=None, **kwargs): """ Arguments: storable (StorableHandler): storable instance. objname (any): record reference. obj (any): object to be serialized. container (any): container. visited (dict): map of the previously serialized objects that are passed by references; keys are the objects' IDs. _stack (CallStack): stack of parent object names. Trailing keyword arguments are passed to the :class:`Storable` instance's :attr:`~Storable.poke`. """ #print((objname, storable.storable_type)) # debug storable.poke(self, objname, obj, container, visited=visited, _stack=_stack, **kwargs) try: record = self.getRecord(objname, container) except KeyError: # fake storable; silently skip if self.verbose: print("skipping `{}` (type: {})".format(objname, storable.storable_type)) if 1 < self.verbose: print(traceback.format_exc()) else: self.setRecordAttr('type', storable.storable_type, record) if storable.version is not None: self.setRecordAttr('version', from_version(storable.version), record)
Arguments: storable (StorableHandler): storable instance. objname (any): record reference. obj (any): object to be serialized. container (any): container. visited (dict): map of the previously serialized objects that are passed by references; keys are the objects' IDs. _stack (CallStack): stack of parent object names. Trailing keyword arguments are passed to the :class:`Storable` instance's :attr:`~Storable.poke`.
Below is the the instruction that describes the task: ### Input: Arguments: storable (StorableHandler): storable instance. objname (any): record reference. obj (any): object to be serialized. container (any): container. visited (dict): map of the previously serialized objects that are passed by references; keys are the objects' IDs. _stack (CallStack): stack of parent object names. Trailing keyword arguments are passed to the :class:`Storable` instance's :attr:`~Storable.poke`. ### Response: def pokeStorable(self, storable, objname, obj, container, visited=None, _stack=None, **kwargs): """ Arguments: storable (StorableHandler): storable instance. objname (any): record reference. obj (any): object to be serialized. container (any): container. visited (dict): map of the previously serialized objects that are passed by references; keys are the objects' IDs. _stack (CallStack): stack of parent object names. Trailing keyword arguments are passed to the :class:`Storable` instance's :attr:`~Storable.poke`. """ #print((objname, storable.storable_type)) # debug storable.poke(self, objname, obj, container, visited=visited, _stack=_stack, **kwargs) try: record = self.getRecord(objname, container) except KeyError: # fake storable; silently skip if self.verbose: print("skipping `{}` (type: {})".format(objname, storable.storable_type)) if 1 < self.verbose: print(traceback.format_exc()) else: self.setRecordAttr('type', storable.storable_type, record) if storable.version is not None: self.setRecordAttr('version', from_version(storable.version), record)
def SLIT_DIFFRACTION(x,g): """ Instrumental (slit) function. """ y = zeros(len(x)) index_zero = x==0 index_nonzero = ~index_zero dk_ = pi/g x_ = dk_*x[index_nonzero] w_ = sin(x_) r_ = w_**2/x_**2 y[index_zero] = 1 y[index_nonzero] = r_/g return y
Instrumental (slit) function.
Below is the the instruction that describes the task: ### Input: Instrumental (slit) function. ### Response: def SLIT_DIFFRACTION(x,g): """ Instrumental (slit) function. """ y = zeros(len(x)) index_zero = x==0 index_nonzero = ~index_zero dk_ = pi/g x_ = dk_*x[index_nonzero] w_ = sin(x_) r_ = w_**2/x_**2 y[index_zero] = 1 y[index_nonzero] = r_/g return y
def mounts(): ''' Return a list of current MooseFS mounts CLI Example: .. code-block:: bash salt '*' moosefs.mounts ''' cmd = 'mount' ret = {} out = __salt__['cmd.run_all'](cmd) output = out['stdout'].splitlines() for line in output: if not line: continue if 'fuse.mfs' in line: comps = line.split(' ') info1 = comps[0].split(':') info2 = info1[1].split('/') ret[comps[2]] = { 'remote': { 'master': info1[0], 'port': info2[0], 'subfolder': '/' + info2[1], }, 'local': comps[2], 'options': (comps[5].replace('(', '').replace(')', '') .split(',')), } return ret
Return a list of current MooseFS mounts CLI Example: .. code-block:: bash salt '*' moosefs.mounts
Below is the the instruction that describes the task: ### Input: Return a list of current MooseFS mounts CLI Example: .. code-block:: bash salt '*' moosefs.mounts ### Response: def mounts(): ''' Return a list of current MooseFS mounts CLI Example: .. code-block:: bash salt '*' moosefs.mounts ''' cmd = 'mount' ret = {} out = __salt__['cmd.run_all'](cmd) output = out['stdout'].splitlines() for line in output: if not line: continue if 'fuse.mfs' in line: comps = line.split(' ') info1 = comps[0].split(':') info2 = info1[1].split('/') ret[comps[2]] = { 'remote': { 'master': info1[0], 'port': info2[0], 'subfolder': '/' + info2[1], }, 'local': comps[2], 'options': (comps[5].replace('(', '').replace(')', '') .split(',')), } return ret
def between(self, time_): """ Compare if the parameter HH:MM is in the time range. """ hour = int(time_[0:2]) minute = int(time_[3:5]) return not ( hour < self.h1 or hour > self.h2 or (hour == self.h1 and minute < self.m1) or (hour == self.h2 and minute > self.m2) )
Compare if the parameter HH:MM is in the time range.
Below is the the instruction that describes the task: ### Input: Compare if the parameter HH:MM is in the time range. ### Response: def between(self, time_): """ Compare if the parameter HH:MM is in the time range. """ hour = int(time_[0:2]) minute = int(time_[3:5]) return not ( hour < self.h1 or hour > self.h2 or (hour == self.h1 and minute < self.m1) or (hour == self.h2 and minute > self.m2) )
def export_agg_losses_ebr(ekey, dstore): """ :param ekey: export key, i.e. a pair (datastore key, fmt) :param dstore: datastore object """ if 'ruptures' not in dstore: logging.warning('There are no ruptures in the datastore') return [] name, ext = export.keyfunc(ekey) agg_losses = dstore['losses_by_event'] has_rup_data = 'ruptures' in dstore extra_list = [('magnitude', F32), ('centroid_lon', F32), ('centroid_lat', F32), ('centroid_depth', F32)] if has_rup_data else [] oq = dstore['oqparam'] lti = oq.lti dtlist = ([('event_id', U64), ('rup_id', U32), ('year', U32)] + extra_list + oq.loss_dt_list()) elt_dt = numpy.dtype(dtlist) elt = numpy.zeros(len(agg_losses), elt_dt) writer = writers.CsvWriter(fmt=writers.FIVEDIGITS) events = dstore['events'].value events_by_rupid = collections.defaultdict(list) for event in events: rupid = event['eid'] // TWO32 events_by_rupid[rupid].append(event) year_of = year_dict(events['eid'], oq.investigation_time, oq.ses_seed) rup_data = {} event_by_eid = {} # eid -> event # populate rup_data and event_by_eid # TODO: avoid reading the events twice for rgetter in getters.gen_rupture_getters(dstore): ruptures = rgetter.get_ruptures() for ebr in ruptures: for event in events_by_rupid[ebr.serial]: event_by_eid[event['eid']] = event if has_rup_data: rup_data.update(get_rup_data(ruptures)) for r, row in enumerate(agg_losses): rec = elt[r] event = event_by_eid[row['eid']] rec['event_id'] = eid = event['eid'] rec['year'] = year_of[eid] if rup_data: rec['rup_id'] = rup_id = event['eid'] // TWO32 (rec['magnitude'], rec['centroid_lon'], rec['centroid_lat'], rec['centroid_depth']) = rup_data[rup_id] for lt, i in lti.items(): rec[lt] = row['loss'][i] elt.sort(order=['year', 'event_id']) dest = dstore.build_fname('elt', '', 'csv') writer.save(elt, dest) return writer.getsaved()
:param ekey: export key, i.e. a pair (datastore key, fmt) :param dstore: datastore object
Below is the the instruction that describes the task: ### Input: :param ekey: export key, i.e. a pair (datastore key, fmt) :param dstore: datastore object ### Response: def export_agg_losses_ebr(ekey, dstore): """ :param ekey: export key, i.e. a pair (datastore key, fmt) :param dstore: datastore object """ if 'ruptures' not in dstore: logging.warning('There are no ruptures in the datastore') return [] name, ext = export.keyfunc(ekey) agg_losses = dstore['losses_by_event'] has_rup_data = 'ruptures' in dstore extra_list = [('magnitude', F32), ('centroid_lon', F32), ('centroid_lat', F32), ('centroid_depth', F32)] if has_rup_data else [] oq = dstore['oqparam'] lti = oq.lti dtlist = ([('event_id', U64), ('rup_id', U32), ('year', U32)] + extra_list + oq.loss_dt_list()) elt_dt = numpy.dtype(dtlist) elt = numpy.zeros(len(agg_losses), elt_dt) writer = writers.CsvWriter(fmt=writers.FIVEDIGITS) events = dstore['events'].value events_by_rupid = collections.defaultdict(list) for event in events: rupid = event['eid'] // TWO32 events_by_rupid[rupid].append(event) year_of = year_dict(events['eid'], oq.investigation_time, oq.ses_seed) rup_data = {} event_by_eid = {} # eid -> event # populate rup_data and event_by_eid # TODO: avoid reading the events twice for rgetter in getters.gen_rupture_getters(dstore): ruptures = rgetter.get_ruptures() for ebr in ruptures: for event in events_by_rupid[ebr.serial]: event_by_eid[event['eid']] = event if has_rup_data: rup_data.update(get_rup_data(ruptures)) for r, row in enumerate(agg_losses): rec = elt[r] event = event_by_eid[row['eid']] rec['event_id'] = eid = event['eid'] rec['year'] = year_of[eid] if rup_data: rec['rup_id'] = rup_id = event['eid'] // TWO32 (rec['magnitude'], rec['centroid_lon'], rec['centroid_lat'], rec['centroid_depth']) = rup_data[rup_id] for lt, i in lti.items(): rec[lt] = row['loss'][i] elt.sort(order=['year', 'event_id']) dest = dstore.build_fname('elt', '', 'csv') writer.save(elt, dest) return writer.getsaved()
def close(self): """Stop monitoring and close connection.""" _LOGGER.debug("Closing...") self.closed = True if self.connected: self._writer.close()
Stop monitoring and close connection.
Below is the the instruction that describes the task: ### Input: Stop monitoring and close connection. ### Response: def close(self): """Stop monitoring and close connection.""" _LOGGER.debug("Closing...") self.closed = True if self.connected: self._writer.close()
def delete(self, url_path, data=None): """Delete an object from the JSS. In general, it is better to use a higher level interface for deleting objects, namely, using a JSSObject's delete method. Args: url_path: String API endpoint path to DEL, with ID (e.g. "/packages/id/<object ID>") Raises: JSSDeleteError if provided url_path has a >= 400 response. """ request_url = "%s%s" % (self._url, url_path) if data: response = self.session.delete(request_url, data=data) else: response = self.session.delete(request_url) if response.status_code == 200 and self.verbose: print "DEL %s: Success." % request_url elif response.status_code >= 400: error_handler(JSSDeleteError, response)
Delete an object from the JSS. In general, it is better to use a higher level interface for deleting objects, namely, using a JSSObject's delete method. Args: url_path: String API endpoint path to DEL, with ID (e.g. "/packages/id/<object ID>") Raises: JSSDeleteError if provided url_path has a >= 400 response.
Below is the the instruction that describes the task: ### Input: Delete an object from the JSS. In general, it is better to use a higher level interface for deleting objects, namely, using a JSSObject's delete method. Args: url_path: String API endpoint path to DEL, with ID (e.g. "/packages/id/<object ID>") Raises: JSSDeleteError if provided url_path has a >= 400 response. ### Response: def delete(self, url_path, data=None): """Delete an object from the JSS. In general, it is better to use a higher level interface for deleting objects, namely, using a JSSObject's delete method. Args: url_path: String API endpoint path to DEL, with ID (e.g. "/packages/id/<object ID>") Raises: JSSDeleteError if provided url_path has a >= 400 response. """ request_url = "%s%s" % (self._url, url_path) if data: response = self.session.delete(request_url, data=data) else: response = self.session.delete(request_url) if response.status_code == 200 and self.verbose: print "DEL %s: Success." % request_url elif response.status_code >= 400: error_handler(JSSDeleteError, response)
def _normalize_json_search_response(self, json): """ Normalizes a JSON search response so that PB and HTTP have the same return value """ result = {} if 'facet_counts' in json: result['facet_counts'] = json[u'facet_counts'] if 'grouped' in json: result['grouped'] = json[u'grouped'] if 'stats' in json: result['stats'] = json[u'stats'] if u'response' in json: result['num_found'] = json[u'response'][u'numFound'] result['max_score'] = float(json[u'response'][u'maxScore']) docs = [] for doc in json[u'response'][u'docs']: resdoc = {} if u'_yz_rk' in doc: # Is this a Riak 2.0 result? resdoc = doc else: # Riak Search 1.0 Legacy assumptions about format resdoc[u'id'] = doc[u'id'] if u'fields' in doc: for k, v in six.iteritems(doc[u'fields']): resdoc[k] = v docs.append(resdoc) result['docs'] = docs return result
Normalizes a JSON search response so that PB and HTTP have the same return value
Below is the the instruction that describes the task: ### Input: Normalizes a JSON search response so that PB and HTTP have the same return value ### Response: def _normalize_json_search_response(self, json): """ Normalizes a JSON search response so that PB and HTTP have the same return value """ result = {} if 'facet_counts' in json: result['facet_counts'] = json[u'facet_counts'] if 'grouped' in json: result['grouped'] = json[u'grouped'] if 'stats' in json: result['stats'] = json[u'stats'] if u'response' in json: result['num_found'] = json[u'response'][u'numFound'] result['max_score'] = float(json[u'response'][u'maxScore']) docs = [] for doc in json[u'response'][u'docs']: resdoc = {} if u'_yz_rk' in doc: # Is this a Riak 2.0 result? resdoc = doc else: # Riak Search 1.0 Legacy assumptions about format resdoc[u'id'] = doc[u'id'] if u'fields' in doc: for k, v in six.iteritems(doc[u'fields']): resdoc[k] = v docs.append(resdoc) result['docs'] = docs return result
def convert_to_group_ids(groups, vpc_id=None, vpc_name=None, region=None, key=None, keyid=None, profile=None): ''' Given a list of security groups and a vpc_id, convert_to_group_ids will convert all list items in the given list to security group ids. CLI example:: salt myminion boto_secgroup.convert_to_group_ids mysecgroup vpc-89yhh7h ''' log.debug('security group contents %s pre-conversion', groups) group_ids = [] for group in groups: group_id = get_group_id(name=group, vpc_id=vpc_id, vpc_name=vpc_name, region=region, key=key, keyid=keyid, profile=profile) if not group_id: # Security groups are a big deal - need to fail if any can't be resolved... raise CommandExecutionError('Could not resolve Security Group name ' '{0} to a Group ID'.format(group)) else: group_ids.append(six.text_type(group_id)) log.debug('security group contents %s post-conversion', group_ids) return group_ids
Given a list of security groups and a vpc_id, convert_to_group_ids will convert all list items in the given list to security group ids. CLI example:: salt myminion boto_secgroup.convert_to_group_ids mysecgroup vpc-89yhh7h
Below is the the instruction that describes the task: ### Input: Given a list of security groups and a vpc_id, convert_to_group_ids will convert all list items in the given list to security group ids. CLI example:: salt myminion boto_secgroup.convert_to_group_ids mysecgroup vpc-89yhh7h ### Response: def convert_to_group_ids(groups, vpc_id=None, vpc_name=None, region=None, key=None, keyid=None, profile=None): ''' Given a list of security groups and a vpc_id, convert_to_group_ids will convert all list items in the given list to security group ids. CLI example:: salt myminion boto_secgroup.convert_to_group_ids mysecgroup vpc-89yhh7h ''' log.debug('security group contents %s pre-conversion', groups) group_ids = [] for group in groups: group_id = get_group_id(name=group, vpc_id=vpc_id, vpc_name=vpc_name, region=region, key=key, keyid=keyid, profile=profile) if not group_id: # Security groups are a big deal - need to fail if any can't be resolved... raise CommandExecutionError('Could not resolve Security Group name ' '{0} to a Group ID'.format(group)) else: group_ids.append(six.text_type(group_id)) log.debug('security group contents %s post-conversion', group_ids) return group_ids
def updateState(self, slicedArray, rtiInfo, separateFields): """ Sets the slicedArray and rtiInfo and other members. This will reset the model. Will be called from the tableInspector._drawContents. """ self.beginResetModel() try: # The sliced array can be a masked array or a (regular) numpy array. # The table works fine with masked arrays, no need to replace the masked values. self._slicedArray = slicedArray if slicedArray is None: self._nRows = 0 self._nCols = 0 self._fieldNames = [] else: self._nRows, self._nCols = self._slicedArray.shape if self._slicedArray.data.dtype.names: self._fieldNames = self._slicedArray.data.dtype.names else: self._fieldNames = [] self._rtiInfo = rtiInfo self._separateFields = separateFields # Don't put numbers in the header if the record is of structured type, fields are # placed in separate cells and the fake dimension is selected (combo index 0) if self._separateFields and self._fieldNames: if self._rtiInfo['x-dim'] == FAKE_DIM_NAME: self._separateFieldOrientation = Qt.Horizontal self._numbersInHeader = False elif self._rtiInfo['y-dim'] == FAKE_DIM_NAME: self._separateFieldOrientation = Qt.Vertical self._numbersInHeader = False else: self._separateFieldOrientation = Qt.Horizontal self._numbersInHeader = True else: self._separateFieldOrientation = None self._numbersInHeader = True finally: self.endResetModel()
Sets the slicedArray and rtiInfo and other members. This will reset the model. Will be called from the tableInspector._drawContents.
Below is the the instruction that describes the task: ### Input: Sets the slicedArray and rtiInfo and other members. This will reset the model. Will be called from the tableInspector._drawContents. ### Response: def updateState(self, slicedArray, rtiInfo, separateFields): """ Sets the slicedArray and rtiInfo and other members. This will reset the model. Will be called from the tableInspector._drawContents. """ self.beginResetModel() try: # The sliced array can be a masked array or a (regular) numpy array. # The table works fine with masked arrays, no need to replace the masked values. self._slicedArray = slicedArray if slicedArray is None: self._nRows = 0 self._nCols = 0 self._fieldNames = [] else: self._nRows, self._nCols = self._slicedArray.shape if self._slicedArray.data.dtype.names: self._fieldNames = self._slicedArray.data.dtype.names else: self._fieldNames = [] self._rtiInfo = rtiInfo self._separateFields = separateFields # Don't put numbers in the header if the record is of structured type, fields are # placed in separate cells and the fake dimension is selected (combo index 0) if self._separateFields and self._fieldNames: if self._rtiInfo['x-dim'] == FAKE_DIM_NAME: self._separateFieldOrientation = Qt.Horizontal self._numbersInHeader = False elif self._rtiInfo['y-dim'] == FAKE_DIM_NAME: self._separateFieldOrientation = Qt.Vertical self._numbersInHeader = False else: self._separateFieldOrientation = Qt.Horizontal self._numbersInHeader = True else: self._separateFieldOrientation = None self._numbersInHeader = True finally: self.endResetModel()
def turbulent_Sieder_Tate(Re, Pr, mu=None, mu_w=None): r'''Calculates internal convection Nusselt number for turbulent flows in pipe according to [1]_ and supposedly [2]_. .. math:: Nu = 0.027Re^{4/5}Pr^{1/3}\left(\frac{\mu}{\mu_s}\right)^{0.14} Parameters ---------- Re : float Reynolds number, [-] Pr : float Prandtl number, [-] mu : float Viscosity of fluid, [Pa*s] mu_w : float Viscosity of fluid at wall temperature, [Pa*s] Returns ------- Nu : float Nusselt number, [-] Notes ----- A linear coefficient of 0.023 is often listed with this equation. The source of the discrepancy is not known. The equation is not present in the original paper, but is nevertheless the source usually cited for it. Examples -------- >>> turbulent_Sieder_Tate(Re=1E5, Pr=1.2) 286.9178136793052 >>> turbulent_Sieder_Tate(Re=1E5, Pr=1.2, mu=0.01, mu_w=0.067) 219.84016455766044 References ---------- .. [1] Rohsenow, Warren and James Hartnett and Young Cho. Handbook of Heat Transfer, 3E. New York: McGraw-Hill, 1998. .. [2] Sieder, E. N., and G. E. Tate. "Heat Transfer and Pressure Drop of Liquids in Tubes." Industrial & Engineering Chemistry 28, no. 12 (December 1, 1936): 1429-35. doi:10.1021/ie50324a027. ''' Nu = 0.027*Re**0.8*Pr**(1/3.) if mu_w and mu: Nu *= (mu/mu_w)**0.14 return Nu
r'''Calculates internal convection Nusselt number for turbulent flows in pipe according to [1]_ and supposedly [2]_. .. math:: Nu = 0.027Re^{4/5}Pr^{1/3}\left(\frac{\mu}{\mu_s}\right)^{0.14} Parameters ---------- Re : float Reynolds number, [-] Pr : float Prandtl number, [-] mu : float Viscosity of fluid, [Pa*s] mu_w : float Viscosity of fluid at wall temperature, [Pa*s] Returns ------- Nu : float Nusselt number, [-] Notes ----- A linear coefficient of 0.023 is often listed with this equation. The source of the discrepancy is not known. The equation is not present in the original paper, but is nevertheless the source usually cited for it. Examples -------- >>> turbulent_Sieder_Tate(Re=1E5, Pr=1.2) 286.9178136793052 >>> turbulent_Sieder_Tate(Re=1E5, Pr=1.2, mu=0.01, mu_w=0.067) 219.84016455766044 References ---------- .. [1] Rohsenow, Warren and James Hartnett and Young Cho. Handbook of Heat Transfer, 3E. New York: McGraw-Hill, 1998. .. [2] Sieder, E. N., and G. E. Tate. "Heat Transfer and Pressure Drop of Liquids in Tubes." Industrial & Engineering Chemistry 28, no. 12 (December 1, 1936): 1429-35. doi:10.1021/ie50324a027.
Below is the the instruction that describes the task: ### Input: r'''Calculates internal convection Nusselt number for turbulent flows in pipe according to [1]_ and supposedly [2]_. .. math:: Nu = 0.027Re^{4/5}Pr^{1/3}\left(\frac{\mu}{\mu_s}\right)^{0.14} Parameters ---------- Re : float Reynolds number, [-] Pr : float Prandtl number, [-] mu : float Viscosity of fluid, [Pa*s] mu_w : float Viscosity of fluid at wall temperature, [Pa*s] Returns ------- Nu : float Nusselt number, [-] Notes ----- A linear coefficient of 0.023 is often listed with this equation. The source of the discrepancy is not known. The equation is not present in the original paper, but is nevertheless the source usually cited for it. Examples -------- >>> turbulent_Sieder_Tate(Re=1E5, Pr=1.2) 286.9178136793052 >>> turbulent_Sieder_Tate(Re=1E5, Pr=1.2, mu=0.01, mu_w=0.067) 219.84016455766044 References ---------- .. [1] Rohsenow, Warren and James Hartnett and Young Cho. Handbook of Heat Transfer, 3E. New York: McGraw-Hill, 1998. .. [2] Sieder, E. N., and G. E. Tate. "Heat Transfer and Pressure Drop of Liquids in Tubes." Industrial & Engineering Chemistry 28, no. 12 (December 1, 1936): 1429-35. doi:10.1021/ie50324a027. ### Response: def turbulent_Sieder_Tate(Re, Pr, mu=None, mu_w=None): r'''Calculates internal convection Nusselt number for turbulent flows in pipe according to [1]_ and supposedly [2]_. .. math:: Nu = 0.027Re^{4/5}Pr^{1/3}\left(\frac{\mu}{\mu_s}\right)^{0.14} Parameters ---------- Re : float Reynolds number, [-] Pr : float Prandtl number, [-] mu : float Viscosity of fluid, [Pa*s] mu_w : float Viscosity of fluid at wall temperature, [Pa*s] Returns ------- Nu : float Nusselt number, [-] Notes ----- A linear coefficient of 0.023 is often listed with this equation. The source of the discrepancy is not known. The equation is not present in the original paper, but is nevertheless the source usually cited for it. Examples -------- >>> turbulent_Sieder_Tate(Re=1E5, Pr=1.2) 286.9178136793052 >>> turbulent_Sieder_Tate(Re=1E5, Pr=1.2, mu=0.01, mu_w=0.067) 219.84016455766044 References ---------- .. [1] Rohsenow, Warren and James Hartnett and Young Cho. Handbook of Heat Transfer, 3E. New York: McGraw-Hill, 1998. .. [2] Sieder, E. N., and G. E. Tate. "Heat Transfer and Pressure Drop of Liquids in Tubes." Industrial & Engineering Chemistry 28, no. 12 (December 1, 1936): 1429-35. doi:10.1021/ie50324a027. ''' Nu = 0.027*Re**0.8*Pr**(1/3.) if mu_w and mu: Nu *= (mu/mu_w)**0.14 return Nu
def infect(cls, graph, key, default_scope=None): """ Forcibly convert an entry-point based factory to a ScopedFactory. Must be invoked before resolving the entry point. :raises AlreadyBoundError: for non entry-points; these should be declared with @scoped_binding """ func = graph.factory_for(key) if isinstance(func, cls): func = func.func factory = cls(key, func, default_scope) graph._registry.factories[key] = factory return factory
Forcibly convert an entry-point based factory to a ScopedFactory. Must be invoked before resolving the entry point. :raises AlreadyBoundError: for non entry-points; these should be declared with @scoped_binding
Below is the the instruction that describes the task: ### Input: Forcibly convert an entry-point based factory to a ScopedFactory. Must be invoked before resolving the entry point. :raises AlreadyBoundError: for non entry-points; these should be declared with @scoped_binding ### Response: def infect(cls, graph, key, default_scope=None): """ Forcibly convert an entry-point based factory to a ScopedFactory. Must be invoked before resolving the entry point. :raises AlreadyBoundError: for non entry-points; these should be declared with @scoped_binding """ func = graph.factory_for(key) if isinstance(func, cls): func = func.func factory = cls(key, func, default_scope) graph._registry.factories[key] = factory return factory
def pair_tree_creator(meta_id): """Splits string into a pairtree path.""" chunks = [] for x in range(0, len(meta_id)): if x % 2: continue if (len(meta_id) - 1) == x: chunk = meta_id[x] else: chunk = meta_id[x: x + 2] chunks.append(chunk) return os.sep + os.sep.join(chunks) + os.sep
Splits string into a pairtree path.
Below is the the instruction that describes the task: ### Input: Splits string into a pairtree path. ### Response: def pair_tree_creator(meta_id): """Splits string into a pairtree path.""" chunks = [] for x in range(0, len(meta_id)): if x % 2: continue if (len(meta_id) - 1) == x: chunk = meta_id[x] else: chunk = meta_id[x: x + 2] chunks.append(chunk) return os.sep + os.sep.join(chunks) + os.sep
def _create_job_details(self, key, job_config, logfile, status): """Create a `JobDetails` for a single job Parameters ---------- key : str Key used to identify this particular job job_config : dict Dictionary with arguements passed to this particular job logfile : str Name of the associated log file status : int Current status of the job Returns ------- job_details : `fermipy.jobs.JobDetails` Object with the details about a particular job. """ self.update_args(job_config) job_details = JobDetails(jobname=self.full_linkname, jobkey=key, appname=self.appname, logfile=logfile, job_config=job_config, timestamp=get_timestamp(), file_dict=copy.deepcopy(self.files), sub_file_dict=copy.deepcopy(self.sub_files), status=status) return job_details
Create a `JobDetails` for a single job Parameters ---------- key : str Key used to identify this particular job job_config : dict Dictionary with arguements passed to this particular job logfile : str Name of the associated log file status : int Current status of the job Returns ------- job_details : `fermipy.jobs.JobDetails` Object with the details about a particular job.
Below is the the instruction that describes the task: ### Input: Create a `JobDetails` for a single job Parameters ---------- key : str Key used to identify this particular job job_config : dict Dictionary with arguements passed to this particular job logfile : str Name of the associated log file status : int Current status of the job Returns ------- job_details : `fermipy.jobs.JobDetails` Object with the details about a particular job. ### Response: def _create_job_details(self, key, job_config, logfile, status): """Create a `JobDetails` for a single job Parameters ---------- key : str Key used to identify this particular job job_config : dict Dictionary with arguements passed to this particular job logfile : str Name of the associated log file status : int Current status of the job Returns ------- job_details : `fermipy.jobs.JobDetails` Object with the details about a particular job. """ self.update_args(job_config) job_details = JobDetails(jobname=self.full_linkname, jobkey=key, appname=self.appname, logfile=logfile, job_config=job_config, timestamp=get_timestamp(), file_dict=copy.deepcopy(self.files), sub_file_dict=copy.deepcopy(self.sub_files), status=status) return job_details
def _psd_mask(x): """Computes whether each square matrix in the input is positive semi-definite. Args: x: A floating-point `Tensor` of shape `[B1, ..., Bn, M, M]`. Returns: mask: A floating-point `Tensor` of shape `[B1, ... Bn]`. Each scalar is 1 if the corresponding matrix was PSD, otherwise 0. """ # Allegedly # https://scicomp.stackexchange.com/questions/12979/testing-if-a-matrix-is-positive-semi-definite # it is more efficient to test for positive semi-definiteness by # trying to compute the Cholesky decomposition -- the matrix is PSD # if you succeed and not PSD if you fail. However, TensorFlow's # Cholesky raises an exception if _any_ of the input matrices are # not PSD, from which I don't know how to extract _which ones_, so I # proceed by explicitly computing all the eigenvalues and checking # whether they are all positive or not. # # Also, as was discussed in the answer, it is somewhat dangerous to # treat SPD-ness as binary in floating-point arithmetic. Cholesky # factorization can complete and 'look' like everything is fine # (e.g., O(1) entries and a diagonal of all ones) but the matrix can # have an exponential condition number. eigenvalues, _ = tf.linalg.eigh(x) return tf.cast( tf.reduce_min(input_tensor=eigenvalues, axis=-1) >= 0, dtype=x.dtype)
Computes whether each square matrix in the input is positive semi-definite. Args: x: A floating-point `Tensor` of shape `[B1, ..., Bn, M, M]`. Returns: mask: A floating-point `Tensor` of shape `[B1, ... Bn]`. Each scalar is 1 if the corresponding matrix was PSD, otherwise 0.
Below is the the instruction that describes the task: ### Input: Computes whether each square matrix in the input is positive semi-definite. Args: x: A floating-point `Tensor` of shape `[B1, ..., Bn, M, M]`. Returns: mask: A floating-point `Tensor` of shape `[B1, ... Bn]`. Each scalar is 1 if the corresponding matrix was PSD, otherwise 0. ### Response: def _psd_mask(x): """Computes whether each square matrix in the input is positive semi-definite. Args: x: A floating-point `Tensor` of shape `[B1, ..., Bn, M, M]`. Returns: mask: A floating-point `Tensor` of shape `[B1, ... Bn]`. Each scalar is 1 if the corresponding matrix was PSD, otherwise 0. """ # Allegedly # https://scicomp.stackexchange.com/questions/12979/testing-if-a-matrix-is-positive-semi-definite # it is more efficient to test for positive semi-definiteness by # trying to compute the Cholesky decomposition -- the matrix is PSD # if you succeed and not PSD if you fail. However, TensorFlow's # Cholesky raises an exception if _any_ of the input matrices are # not PSD, from which I don't know how to extract _which ones_, so I # proceed by explicitly computing all the eigenvalues and checking # whether they are all positive or not. # # Also, as was discussed in the answer, it is somewhat dangerous to # treat SPD-ness as binary in floating-point arithmetic. Cholesky # factorization can complete and 'look' like everything is fine # (e.g., O(1) entries and a diagonal of all ones) but the matrix can # have an exponential condition number. eigenvalues, _ = tf.linalg.eigh(x) return tf.cast( tf.reduce_min(input_tensor=eigenvalues, axis=-1) >= 0, dtype=x.dtype)
def _update_handlers(self): """Update `_handler_map` after `handlers` have been modified.""" handler_map = defaultdict(list) for i, obj in enumerate(self.handlers): for dummy, handler in inspect.getmembers(obj, callable): if not hasattr(handler, "_pyxmpp_event_handled"): continue # pylint: disable-msg=W0212 event_class = handler._pyxmpp_event_handled handler_map[event_class].append( (i, handler) ) self._handler_map = handler_map
Update `_handler_map` after `handlers` have been modified.
Below is the the instruction that describes the task: ### Input: Update `_handler_map` after `handlers` have been modified. ### Response: def _update_handlers(self): """Update `_handler_map` after `handlers` have been modified.""" handler_map = defaultdict(list) for i, obj in enumerate(self.handlers): for dummy, handler in inspect.getmembers(obj, callable): if not hasattr(handler, "_pyxmpp_event_handled"): continue # pylint: disable-msg=W0212 event_class = handler._pyxmpp_event_handled handler_map[event_class].append( (i, handler) ) self._handler_map = handler_map
def ssh_sa_ssh_client_mac(self, **kwargs): """Auto Generated Code """ config = ET.Element("config") ssh_sa = ET.SubElement(config, "ssh-sa", xmlns="urn:brocade.com:mgmt:brocade-sec-services") ssh = ET.SubElement(ssh_sa, "ssh") client = ET.SubElement(ssh, "client") mac = ET.SubElement(client, "mac") mac.text = kwargs.pop('mac') callback = kwargs.pop('callback', self._callback) return callback(config)
Auto Generated Code
Below is the the instruction that describes the task: ### Input: Auto Generated Code ### Response: def ssh_sa_ssh_client_mac(self, **kwargs): """Auto Generated Code """ config = ET.Element("config") ssh_sa = ET.SubElement(config, "ssh-sa", xmlns="urn:brocade.com:mgmt:brocade-sec-services") ssh = ET.SubElement(ssh_sa, "ssh") client = ET.SubElement(ssh, "client") mac = ET.SubElement(client, "mac") mac.text = kwargs.pop('mac') callback = kwargs.pop('callback', self._callback) return callback(config)
def set_canvas_properties(self, canvas, x_title=None, y_title=None, x_lim=None, y_lim=None, x_labels=True, y_labels=True): """! @brief Set properties for specified canvas. @param[in] canvas (uint): Index of canvas whose properties should changed. @param[in] x_title (string): Title for X axis, if 'None', then nothing is displayed. @param[in] y_title (string): Title for Y axis, if 'None', then nothing is displayed. @param[in] x_lim (list): Defines borders of X axis like [from, to], for example [0, 3.14], if 'None' then borders are calculated automatically. @param[in] y_lim (list): Defines borders of Y axis like [from, to], if 'None' then borders are calculated automatically. @param[in] x_labels (bool): If True then labels of X axis are displayed. @param[in] y_labels (bool): If True then labels of Y axis are displayed. """ self.__canvases[canvas] = canvas_descr(x_title, y_title, x_lim, y_lim, x_labels, y_labels);
! @brief Set properties for specified canvas. @param[in] canvas (uint): Index of canvas whose properties should changed. @param[in] x_title (string): Title for X axis, if 'None', then nothing is displayed. @param[in] y_title (string): Title for Y axis, if 'None', then nothing is displayed. @param[in] x_lim (list): Defines borders of X axis like [from, to], for example [0, 3.14], if 'None' then borders are calculated automatically. @param[in] y_lim (list): Defines borders of Y axis like [from, to], if 'None' then borders are calculated automatically. @param[in] x_labels (bool): If True then labels of X axis are displayed. @param[in] y_labels (bool): If True then labels of Y axis are displayed.
Below is the the instruction that describes the task: ### Input: ! @brief Set properties for specified canvas. @param[in] canvas (uint): Index of canvas whose properties should changed. @param[in] x_title (string): Title for X axis, if 'None', then nothing is displayed. @param[in] y_title (string): Title for Y axis, if 'None', then nothing is displayed. @param[in] x_lim (list): Defines borders of X axis like [from, to], for example [0, 3.14], if 'None' then borders are calculated automatically. @param[in] y_lim (list): Defines borders of Y axis like [from, to], if 'None' then borders are calculated automatically. @param[in] x_labels (bool): If True then labels of X axis are displayed. @param[in] y_labels (bool): If True then labels of Y axis are displayed. ### Response: def set_canvas_properties(self, canvas, x_title=None, y_title=None, x_lim=None, y_lim=None, x_labels=True, y_labels=True): """! @brief Set properties for specified canvas. @param[in] canvas (uint): Index of canvas whose properties should changed. @param[in] x_title (string): Title for X axis, if 'None', then nothing is displayed. @param[in] y_title (string): Title for Y axis, if 'None', then nothing is displayed. @param[in] x_lim (list): Defines borders of X axis like [from, to], for example [0, 3.14], if 'None' then borders are calculated automatically. @param[in] y_lim (list): Defines borders of Y axis like [from, to], if 'None' then borders are calculated automatically. @param[in] x_labels (bool): If True then labels of X axis are displayed. @param[in] y_labels (bool): If True then labels of Y axis are displayed. """ self.__canvases[canvas] = canvas_descr(x_title, y_title, x_lim, y_lim, x_labels, y_labels);
def iso_name_converter(iso): ''' Converts the name of the given isotope (input), e.g., 'N-14' to 14N as used later to compare w/ grain database. ''' sp = iso.split('-') output = sp[1] + sp[0] return output.lower()
Converts the name of the given isotope (input), e.g., 'N-14' to 14N as used later to compare w/ grain database.
Below is the the instruction that describes the task: ### Input: Converts the name of the given isotope (input), e.g., 'N-14' to 14N as used later to compare w/ grain database. ### Response: def iso_name_converter(iso): ''' Converts the name of the given isotope (input), e.g., 'N-14' to 14N as used later to compare w/ grain database. ''' sp = iso.split('-') output = sp[1] + sp[0] return output.lower()