text
stringlengths
78
104k
score
float64
0
0.18
def _generate(self): u"""overrided in each modules.""" self._data['key'] = self.key self._data['value'] = self.value self._data['host'] = self.host self._data['clock'] = self.clock
0.00905
def apply_smoothing(self, smooth_fwhm): """Set self._smooth_fwhm and then smooths the data. See boyle.nifti.smooth.smooth_imgs. Returns ------- the smoothed data deepcopied. """ if smooth_fwhm <= 0: return old_smooth_fwhm = self._smooth_fwhm self._smooth_fwhm = smooth_fwhm try: data = self.get_data(smoothed=True, masked=True, safe_copy=True) except ValueError as ve: self._smooth_fwhm = old_smooth_fwhm raise else: self._smooth_fwhm = smooth_fwhm return data
0.004739
def parse_cfg(self): """ parses the given config file for experiments. """ self.cfgparser = ConfigParser() if not self.cfgparser.read(self.options.config): raise SystemExit('config file %s not found.'%self.options.config) # Change the current working directory to be relative to 'experiments.cfg' projectDir = os.path.dirname(self.options.config) projectDir = os.path.abspath(projectDir) os.chdir(projectDir)
0.01046
def _set_parent_port_detail(self, v, load=False): """ Setter method for parent_port_detail, mapped from YANG variable /ptp_state/parent_port_detail (container) If this variable is read-only (config: false) in the source YANG file, then _set_parent_port_detail is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_parent_port_detail() directly. """ if hasattr(v, "_utype"): v = v._utype(v) try: t = YANGDynClass(v,base=parent_port_detail.parent_port_detail, is_container='container', presence=False, yang_name="parent-port-detail", rest_name="parent-port-detail", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'tailf-common': {u'callpoint': u'ptp-parent-port-detail', u'cli-suppress-show-path': None}}, namespace='urn:brocade.com:mgmt:brocade-ptp-operational', defining_module='brocade-ptp-operational', yang_type='container', is_config=False) except (TypeError, ValueError): raise ValueError({ 'error-string': """parent_port_detail must be of a type compatible with container""", 'defined-type': "container", 'generated-type': """YANGDynClass(base=parent_port_detail.parent_port_detail, is_container='container', presence=False, yang_name="parent-port-detail", rest_name="parent-port-detail", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'tailf-common': {u'callpoint': u'ptp-parent-port-detail', u'cli-suppress-show-path': None}}, namespace='urn:brocade.com:mgmt:brocade-ptp-operational', defining_module='brocade-ptp-operational', yang_type='container', is_config=False)""", }) self.__parent_port_detail = t if hasattr(self, '_set'): self._set()
0.005426
def _setup_logging(cls, args): '''Set up the root logger if needed. The root logger is set the appropriate level so the file and WARC logs work correctly. ''' assert ( logging.CRITICAL > logging.ERROR > logging.WARNING > logging.INFO > logging.DEBUG > logging.NOTSET ) assert ( LOG_VERY_QUIET > LOG_QUIET > LOG_NO_VERBOSE > LOG_VERBOSE > LOG_DEBUG ) assert args.verbosity root_logger = logging.getLogger() current_level = root_logger.getEffectiveLevel() min_level = LOG_VERY_QUIET if args.verbosity == LOG_QUIET: min_level = logging.ERROR if args.verbosity in (LOG_NO_VERBOSE, LOG_VERBOSE) \ or args.warc_file \ or args.output_file or args.append_output: min_level = logging.INFO if args.verbosity == LOG_DEBUG: min_level = logging.DEBUG if current_level > min_level: root_logger.setLevel(min_level) root_logger.debug( 'Wpull needs the root logger level set to {0}.' .format(min_level) ) if current_level <= logging.INFO: logging.captureWarnings(True)
0.002177
def _check_action_feasibility(self): """ Check that for every state, reward is finite for some action, and for the case sa_pair is True, that for every state, there is some action available. """ # Check that for every state, reward is finite for some action R_max = self.s_wise_max(self.R) if (R_max == -np.inf).any(): # First state index such that all actions yield -inf s = np.where(R_max == -np.inf)[0][0] raise ValueError( 'for every state the reward must be finite for some action: ' 'violated for state {s}'.format(s=s) ) if self._sa_pair: # Check that for every state there is at least one action available diff = np.diff(self.a_indptr) if (diff == 0).any(): # First state index such that no action is available s = np.where(diff == 0)[0][0] raise ValueError( 'for every state at least one action must be available: ' 'violated for state {s}'.format(s=s) )
0.001729
def df_from_groups(groups, columns=None): """Create DataFrame of GroupBy object with columns for each product(grouped_value, column_label)""" if columns is None: columns = list(groups.get_group(groups.indices.keys()[0]).columns) df = pd.DataFrame() for col, group_label in product(columns, groups.indices.keys()): label = '{}_{}'.format(col, group_label) df[label] = pd.Series(groups.get_group(group_label)[col].values) return df
0.004228
def scope(self, key, *tags, default=None): """Only apply tags and default for top-level key, effectively scoping the tags.""" scope = self._scopes[key] tags = self._ensure_exclamation(tags) default = default if not default or default.startswith("!") else "!" + default if scope: scope[0] = scope[0] + tags scope[1] = default if default else scope[1] else: scope.append(tags) scope.append(default)
0.008114
def auth(alias=None, url=None, cfg="~/.xnat_auth"): ''' Read connection details from an xnat_auth XML file Example: >>> import yaxil >>> auth = yaxil.auth('xnatastic') >>> auth.url, auth.username, auth.password ('https://www.xnatastic.org/', 'username', '********') :param alias: XNAT alias :type alias: str :param url: XNAT URL :type url: str :param cfg: Configuration file :type cfg: str :returns: Named tuple of (url, username, password) :rtype: :mod:`yaxil.XnatAuth` ''' if not alias and not url: raise ValueError('you must provide an alias or url argument') if alias and url: raise ValueError('cannot provide both alias and url arguments') # check and parse config file cfg = os.path.expanduser(cfg) if not os.path.exists(cfg): raise AuthError("could not locate auth file %s" % cfg) tree = etree.parse(os.path.expanduser(cfg)) # search by alias or url res = None if alias: res = tree.findall("./%s" % alias) if url: res = tree.findall("./*/[url='%s']" % url) if not res: raise AuthError("failed to locate xnat credentials within %s" % cfg) elif len(res) > 1: raise AuthError("found too many sets of credentials within %s" % cfg) res = res.pop() # get url url = res.findall("url") if not url: raise AuthError("no url for %s in %s" % (alias, cfg)) elif len(url) > 1: raise AuthError("too many urls for %s in %s" % (alias, cfg)) # get username username = res.findall("username") if not username: raise AuthError("no username for %s in %s" % (alias, cfg)) elif len(username) > 1: raise AuthError("too many usernames for %s in %s" % (alias, cfg)) # get password password = res.findall("password") if not password: raise AuthError("no password for %s in %s" % (alias, cfg)) elif len(password) > 1: raise AuthError("too many passwords for %s in %s" % (alias, cfg)) return XnatAuth(url=url.pop().text, username=username.pop().text, password=password.pop().text)
0.001381
def check_local_install(ctx, version, ext, server="local"): """ Upload and install works? Uploads a distribution to PyPI, and then tests to see if I can download and install it. Returns: str: string summazing operation """ here = Path(ctx.releaser.here).resolve() dist_dir = here / 'dist' all_files = list(dist_dir.glob('*.{}'.format(ext))) the_file = all_files[0] for f in all_files[1:]: if f.stat().st_mtime > the_file.stat().st_mtime: the_file = f # this is the latest generated file of the given version environment = 'env-{}-{}-{}'.format(version, ext, server) if server == "local": pass else: # upload to server print("** Uploading to server **") cmd = 'twine upload {}'.format(the_file) # for PyPI, let twine pick the server if server != "pypi": cmd = cmd + ' -r {}'.format(server) result = invoke.run(cmd, warn=True) if result.failed: print(textwrap.fill("[{}ERROR{}] Something broke trying to upload " "your package. This will be the case if you " "have already uploaded it before. To upload " "again, use a different version number " "(or a different build by including a '+' " "suffix to your version number)." .format(ERROR_COLOR, RESET_COLOR), width=text.get_terminal_size().columns - 1, subsequent_indent=' '*8)) # print(result.stderr) # remove directory if it exists if (here / 'env' / environment).exists(): shutil.rmtree('env' + os.sep + environment) invoke.run('python -m venv env{}{}'.format(os.sep, environment)) other_dependencies(ctx, server, environment) if server == "local": result = invoke.run('env{0}{1}{0}Scripts{0}pip{2} install {3} --no-cache' .format(os.sep, environment, '.exe', the_file), hide=True) else: #print(" **Install from server**") result = invoke.run('env{0}{1}{0}Scripts{0}pip{2} install -i {3} ' '{4}=={5} --no-cache' .format(os.sep, environment, '.exe', server_url(server), ctx.releaser.module_name, version), hide=True) if result.failed: print('[{}ERROR{}] Something broke trying to install your package.' .format(ERROR_COLOR, RESET_COLOR)) print(result.stderr) sys.exit(1) print("** Test version of installed package **") result = invoke.run('env{0}{1}{0}Scripts{0}python{2} -c ' 'exec("""import {3}\\nprint({3}.__version__)""")' .format(os.sep, environment, '.exe', (ctx.releaser.module_name).strip())) test_version = result.stdout.strip() # print(test_version, type(test_version), type(expected_version)) if Version(test_version) == version: results = '{}{} install {} works!{}'.format(GOOD_COLOR, server, ext, RESET_COLOR) else: results = '{}{} install {} broken{}'.format(ERROR_COLOR, server, ext, RESET_COLOR) print(results) return results
0.00083
def relative_field(field, parent): """ RETURN field PATH WITH RESPECT TO parent """ if parent==".": return field field_path = split_field(field) parent_path = split_field(parent) common = 0 for f, p in _builtin_zip(field_path, parent_path): if f != p: break common += 1 if len(parent_path) == common: return join_field(field_path[common:]) else: dots = "." * (len(parent_path) - common) return dots + "." + join_field(field_path[common:])
0.003704
def new_cells(self, name=None, formula=None): """Create a cells in the space. Args: name: If omitted, the model is named automatically ``CellsN``, where ``N`` is an available number. func: The function to define the formula of the cells. Returns: The new cells. """ # Outside formulas only return self._impl.new_cells(name, formula).interface
0.004505
def _fix_dynamic_class_lookup(cls, pstfx): """Fix name lookup problem that prevents pickling of dynamically defined classes. Parameters ---------- cls : class Dynamically generated class to which fix is to be applied pstfx : string Postfix that can be used to identify dynamically generated classes that are equivalent by construction """ # Extended name for the class that will be added to the module namespace extnm = '_' + cls.__name__ + '_' + pstfx # Get the module in which the dynamic class is defined mdl = sys.modules[cls.__module__] # Allow lookup of the dynamically generated class within the module via # its extended name setattr(mdl, extnm, cls) # Change the dynamically generated class name to the extended name if hasattr(cls, '__qualname__'): cls.__qualname__ = extnm else: cls.__name__ = extnm
0.001094
def _matches_contigs(in_file, contigs, checked_file): """Check if the contigs in the input file match the defined contigs in the reference genome. """ tocheck_contigs = 2 if utils.file_exists(checked_file): with open(checked_file) as in_handle: return in_handle.read().strip() == "match" else: with utils.open_gzipsafe(in_file) as in_handle: to_check = set([]) for line in in_handle: if not line.startswith("#"): to_check.add(line.split()[0]) if len(to_check) >= tocheck_contigs: break with open(checked_file, "w") as out_handle: if any([c not in contigs for c in to_check]): out_handle.write("different") return False else: out_handle.write("match") return True
0.002217
def user_create(name, passwd, database=None, user=None, password=None, host=None, port=None): ''' Create a cluster admin or a database user. If a database is specified: it will create database user. If a database is not specified: it will create a cluster admin. name User name for the new user to create passwd Password for the new user to create database The database to create the user in user The user to connect as password The password of the user host The host to connect to port The port to connect to CLI Example: .. code-block:: bash salt '*' influxdb08.user_create <name> <passwd> salt '*' influxdb08.user_create <name> <passwd> <database> salt '*' influxdb08.user_create <name> <passwd> <database> <user> <password> <host> <port> ''' if user_exists(name, database, user, password, host, port): if database: log.info('User \'%s\' already exists for DB \'%s\'', name, database) else: log.info('Cluster admin \'%s\' already exists', name) return False client = _client(user=user, password=password, host=host, port=port) if not database: return client.add_cluster_admin(name, passwd) client.switch_database(database) return client.add_database_user(name, passwd)
0.002009
def find(self, item_id=None): "Recursively find a menu item by its id (useful for event handlers)" for it in self: found = it.find(item_id) if found: return found
0.008969
def consume(self, kind): """Consume one token and verify it is of the expected kind.""" next_token = self.stream.move() assert next_token.kind == kind
0.011494
def fileopenbox(msg=None, title=None, default='*', filetypes=None, multiple=False): """ A dialog to get a file name. **About the "default" argument** The "default" argument specifies a filepath that (normally) contains one or more wildcards. fileopenbox will display only files that match the default filepath. If omitted, defaults to "\*" (all files in the current directory). WINDOWS EXAMPLE:: ...default="c:/myjunk/*.py" will open in directory c:\\myjunk\\ and show all Python files. WINDOWS EXAMPLE:: ...default="c:/myjunk/test*.py" will open in directory c:\\myjunk\\ and show all Python files whose names begin with "test". Note that on Windows, fileopenbox automatically changes the path separator to the Windows path separator (backslash). **About the "filetypes" argument** If specified, it should contain a list of items, where each item is either: - a string containing a filemask # e.g. "\*.txt" - a list of strings, where all of the strings except the last one are filemasks (each beginning with "\*.", such as "\*.txt" for text files, "\*.py" for Python files, etc.). and the last string contains a filetype description EXAMPLE:: filetypes = ["*.css", ["*.htm", "*.html", "HTML files"] ] .. note:: If the filetypes list does not contain ("All files","*"), it will be added. If the filetypes list does not contain a filemask that includes the extension of the "default" argument, it will be added. For example, if default="\*abc.py" and no filetypes argument was specified, then "\*.py" will automatically be added to the filetypes argument. :param str msg: the msg to be displayed. :param str title: the window title :param str default: filepath with wildcards :param object filetypes: filemasks that a user can choose, e.g. "\*.txt" :param bool multiple: If true, more than one file can be selected :return: the name of a file, or None if user chose to cancel """ localRoot = Tk() localRoot.withdraw() initialbase, initialfile, initialdir, filetypes = fileboxSetup( default, filetypes) # ------------------------------------------------------------ # if initialfile contains no wildcards; we don't want an # initial file. It won't be used anyway. # Also: if initialbase is simply "*", we don't want an # initialfile; it is not doing any useful work. # ------------------------------------------------------------ if (initialfile.find("*") < 0) and (initialfile.find("?") < 0): initialfile = None elif initialbase == "*": initialfile = None func = ut.tk_FileDialog.askopenfilenames if multiple else ut.tk_FileDialog.askopenfilename ret_val = func(parent=localRoot, title=getFileDialogTitle(msg, title), initialdir=initialdir, initialfile=initialfile, filetypes=filetypes ) if multiple: f = [os.path.normpath(x) for x in localRoot.tk.splitlist(ret_val)] else: f = os.path.normpath(ret_val) localRoot.destroy() if not f: return None return f
0.004063
def compute_utility(self, board, move, player): "If X wins with this move, return 1; if O return -1; else return 0." if (self.k_in_row(board, move, player, (0, 1)) or self.k_in_row(board, move, player, (1, 0)) or self.k_in_row(board, move, player, (1, -1)) or self.k_in_row(board, move, player, (1, 1))): return if_(player == 'X', +1, -1) else: return 0
0.006865
def safeArgs(args): """Iterate over valid, finite values in an iterable. Skip any items that are None, NaN, or infinite. """ return (arg for arg in args if arg is not None and not math.isnan(arg) and not math.isinf(arg))
0.004016
def u_distance_correlation_sqr(x, y, **kwargs): """ u_distance_correlation_sqr(x, y, *, exponent=1) Computes the bias-corrected estimator for the squared distance correlation between two random vectors. Parameters ---------- x: array_like First random vector. The columns correspond with the individual random variables while the rows are individual instances of the random vector. y: array_like Second random vector. The columns correspond with the individual random variables while the rows are individual instances of the random vector. exponent: float Exponent of the Euclidean distance, in the range :math:`(0, 2)`. Equivalently, it is twice the Hurst parameter of fractional Brownian motion. Returns ------- numpy scalar Value of the bias-corrected estimator of the squared distance correlation. See Also -------- distance_correlation distance_correlation_sqr Notes ----- The algorithm uses the fast distance covariance algorithm proposed in :cite:`b-fast_distance_correlation` when possible. Examples -------- >>> import numpy as np >>> import dcor >>> a = np.array([[1, 2, 3, 4], ... [5, 6, 7, 8], ... [9, 10, 11, 12], ... [13, 14, 15, 16]]) >>> b = np.array([[1], [0], [0], [1]]) >>> dcor.u_distance_correlation_sqr(a, a) 1.0 >>> dcor.u_distance_correlation_sqr(a, b) -0.5 >>> dcor.u_distance_correlation_sqr(b, b) 1.0 >>> dcor.u_distance_correlation_sqr(a, b, exponent=0.5) ... # doctest: +ELLIPSIS -0.4050479... """ if _can_use_fast_algorithm(x, y, **kwargs): return _u_distance_correlation_sqr_fast(x, y) else: return _u_distance_correlation_sqr_naive(x, y, **kwargs)
0.000532
def execute(self, timeSeries): """Creates a new TimeSeries containing the smoothed and forcasted values. :return: TimeSeries object containing the smoothed TimeSeries, including the forecasted values. :rtype: TimeSeries :note: The first normalized value is chosen as the starting point. """ # determine the number of values to forecast, if necessary self._calculate_values_to_forecast(timeSeries) # extract the required parameters, performance improvement alpha = self._parameters["smoothingFactor"] valuesToForecast = self._parameters["valuesToForecast"] # initialize some variables resultList = [] estimator = None lastT = None # "It's always about performance!" append = resultList.append # smooth the existing TimeSeries data for idx in xrange(len(timeSeries)): # get the current to increase performance t = timeSeries[idx] # get the initial estimate if estimator is None: estimator = t[1] continue # add the first value to the resultList without any correction if 0 == len(resultList): append([t[0], estimator]) lastT = t continue # calculate the error made during the last estimation error = lastT[1] - estimator # calculate the new estimator, based on the last occured value, the error and the smoothingFactor estimator = estimator + alpha * error # save the current value for the next iteration lastT = t # add an entry to the result append([t[0], estimator]) # forecast additional values if requested if valuesToForecast > 0: currentTime = resultList[-1][0] normalizedTimeDiff = currentTime - resultList[-2][0] for idx in xrange(valuesToForecast): currentTime += normalizedTimeDiff # reuse everything error = lastT[1] - estimator estimator = estimator + alpha * error # add a forecasted value append([currentTime, estimator]) # set variables for next iteration lastT = resultList[-1] # return a TimeSeries, containing the result return TimeSeries.from_twodim_list(resultList)
0.004314
def set_objective(self, measured_metabolites): ''' Updates objective function for given measured metabolites. :param dict measured_metabolites: dict in which keys are metabolite names and values are float numbers represent fold changes in metabolites. ''' self.clean_objective() for k, v in measured_metabolites.items(): m = self.model.metabolites.get_by_id(k) total_stoichiometry = m.total_stoichiometry( self.without_transports) for r in m.producers(self.without_transports): update_rate = v * r.metabolites[m] / total_stoichiometry r.objective_coefficient += update_rate
0.006925
def pop(self, name: str, default: Any=_sentinel) -> Any: """Pop, get and remove the named attribute of this instance.""" if default is _sentinel: return self.__dict__.pop(name) else: return self.__dict__.pop(name, default)
0.014815
def p_scalar__doublequote(self, p): """ scalar : DOUBLEQUOTE_START SCALAR DOUBLEQUOTE_END """ scalar = re.sub('\n\s+', ' ', str(p[2])) p[0] = Str(scalar.replace('\\"', '"'))
0.013953
def smart_email_send(self, smart_email_id, to, consent_to_track, cc=None, bcc=None, attachments=None, data=None, add_recipients_to_list=None): """Sends the smart email.""" validate_consent_to_track(consent_to_track) body = { "To": to, "CC": cc, "BCC": bcc, "Attachments": attachments, "Data": data, "AddRecipientsToList": add_recipients_to_list, "ConsentToTrack": consent_to_track, } response = self._post("/transactional/smartEmail/%s/send" % smart_email_id, json.dumps(body)) return json_to_py(response)
0.004498
def manage(self): """ Manage the task to handle restarts, reconfiguration, etc. Returns True to request a shorter period before the next call, False if nothing special is needed. """ log = self._params.get('log', self._discard) if self._stopping: log.debug("Task '%s', stopping, retrying stop()", self._name) return self.stop() now = time.time() if self._started and self._limit: if now > self._limit: log.debug("Task '%s', time limit exceeded by %s, stopping", self._name, deltafmt(now - self._limit)) return self.stop() else: log.debug("Task '%s', time limit remaining %s", self._name, deltafmt(self._limit - now)) if self._legion.is_exiting(): log.debug("Not managing '%s', legion is exiting", self._name) return False log.debug("managing '%s'", self._name) return self._start()
0.004024
def setup(self, reason, grr_server_url, grr_username, grr_password, approvers=None, verify=True): """Initializes a GRR hunt result collector. Args: reason: justification for GRR access. grr_server_url: GRR server URL. grr_username: GRR username. grr_password: GRR password. approvers: list of GRR approval recipients. verify: boolean, whether to verify the GRR server's x509 certificate. """ grr_auth = (grr_username, grr_password) self.approvers = [] if approvers: self.approvers = [item.strip() for item in approvers.strip().split(',')] self.grr_api = grr_api.InitHttp(api_endpoint=grr_server_url, auth=grr_auth, verify=verify) self.output_path = tempfile.mkdtemp() self.reason = reason
0.003525
def get_result(self, indices_or_msg_ids=None, block=None): """Retrieve a result by msg_id or history index, wrapped in an AsyncResult object. If the client already has the results, no request to the Hub will be made. This is a convenient way to construct AsyncResult objects, which are wrappers that include metadata about execution, and allow for awaiting results that were not submitted by this Client. It can also be a convenient way to retrieve the metadata associated with blocking execution, since it always retrieves Examples -------- :: In [10]: r = client.apply() Parameters ---------- indices_or_msg_ids : integer history index, str msg_id, or list of either The indices or msg_ids of indices to be retrieved block : bool Whether to wait for the result to be done Returns ------- AsyncResult A single AsyncResult object will always be returned. AsyncHubResult A subclass of AsyncResult that retrieves results from the Hub """ block = self.block if block is None else block if indices_or_msg_ids is None: indices_or_msg_ids = -1 if not isinstance(indices_or_msg_ids, (list,tuple)): indices_or_msg_ids = [indices_or_msg_ids] theids = [] for id in indices_or_msg_ids: if isinstance(id, int): id = self.history[id] if not isinstance(id, basestring): raise TypeError("indices must be str or int, not %r"%id) theids.append(id) local_ids = filter(lambda msg_id: msg_id in self.history or msg_id in self.results, theids) remote_ids = filter(lambda msg_id: msg_id not in local_ids, theids) if remote_ids: ar = AsyncHubResult(self, msg_ids=theids) else: ar = AsyncResult(self, msg_ids=theids) if block: ar.wait() return ar
0.005319
def activate(self): """ Activate the scene. """ response = self.api_interface.set_device_state(self, None) self._update_state_from_response(response)
0.010309
def copy_previous_results(self): """Use the latest valid results_dir as the starting contents of the current results_dir. Should be called after the cache is checked, since previous_results are not useful if there is a cached artifact. """ # TODO(mateo): This should probably be managed by the task, which manages the rest of the # incremental support. if not self.previous_cache_key: return None previous_path = self._cache_manager._results_dir_path(self.previous_cache_key, stable=False) if os.path.isdir(previous_path): self.is_incremental = True safe_rmtree(self._current_results_dir) shutil.copytree(previous_path, self._current_results_dir) safe_mkdir(self._current_results_dir) relative_symlink(self._current_results_dir, self.results_dir) # Set the self._previous last, so that it is only True after the copy completed. self._previous_results_dir = previous_path
0.01056
def on_add_cols(self, event): """ Show simple dialog that allows user to add a new column name """ col_labels = self.grid.col_labels dia = pw.ChooseOne(self, yes="Add single columns", no="Add groups") result1 = dia.ShowModal() if result1 == wx.ID_CANCEL: return elif result1 == wx.ID_YES: items = sorted([col_name for col_name in self.dm.index if col_name not in col_labels]) dia = pw.HeaderDialog(self, 'columns to add', items1=list(items), groups=[]) dia.Centre() result2 = dia.ShowModal() else: groups = self.dm['group'].unique() dia = pw.HeaderDialog(self, 'groups to add', items1=list(groups), groups=True) dia.Centre() result2 = dia.ShowModal() new_headers = [] if result2 == 5100: new_headers = dia.text_list # if there is nothing to add, quit if not new_headers: return if result1 == wx.ID_YES: # add individual headers errors = self.add_new_grid_headers(new_headers) else: # add header groups errors = self.add_new_header_groups(new_headers) if errors: errors_str = ', '.join(errors) pw.simple_warning('You are already using the following headers: {}\nSo they will not be added'.format(errors_str)) # problem: if widgets above the grid are too wide, # the grid does not re-size when adding columns # awkward solution (causes flashing): if self.grid.GetWindowStyle() != wx.DOUBLE_BORDER: self.grid.SetWindowStyle(wx.DOUBLE_BORDER) self.main_sizer.Fit(self) self.grid.SetWindowStyle(wx.NO_BORDER) self.Centre() self.main_sizer.Fit(self) # self.grid.changes = set(range(self.grid.GetNumberRows())) dia.Destroy()
0.001982
def _fx_mapping(raw_rates): ''' Map raw output to clearer labels ''' return {pair[0].lower(): { 'timeStamp': pair[1], 'bid': float(pair[2] + pair[3]), 'ask': float(pair[4] + pair[5]), 'high': float(pair[6]), 'low': float(pair[7]) } for pair in map(lambda x: x.split(','), raw_rates)}
0.002985
def put_mapping(self, doc_type=None, mapping=None, indices=None, ignore_conflicts=None): """ Register specific mapping definition for a specific type against one or more indices. (See :ref:`es-guide-reference-api-admin-indices-put-mapping`) """ if not isinstance(mapping, dict): if mapping is None: mapping = {} if hasattr(mapping, "as_dict"): mapping = mapping.as_dict() if doc_type: path = self.conn._make_path(indices, doc_type, "_mapping") if doc_type not in mapping: mapping = {doc_type: mapping} else: path = self.conn._make_path(indices, (), "_mapping") parameters = {} if ignore_conflicts is not None: parameters['ignore_conflicts'] = ignore_conflicts return self.conn._send_request('PUT', path, mapping, params=parameters)
0.004274
def kill(self, typ=TaskExit, value=None, tb=None): """Terminates the current task by raising an exception into it. Whatever that task might be doing; be it waiting for I/O or another primitive, it sees an exception as soon as it yields control. By default, this exception is TaskExit, but a specific exception may be specified. """ if not self.is_alive(): return if not value: value = typ() if not self._running: # task hasn't started yet and therefore throw won't work def just_raise(): six.reraise(typ, value, tb) self.run = just_raise return evergreen.current.loop.call_soon(self.throw, typ, value, tb)
0.002584
def can_vote_on_poll(self, request): """Based on jmbo.models.can_vote.""" # can't vote if liking is closed if self.votes_closed: return False, 'closed' # can't vote if liking is disabled if not self.votes_enabled: return False, 'disabled' # anonymous users can't vote if anonymous votes are disabled if not request.user.is_authenticated() and not \ self.anonymous_votes: return False, 'auth_required' # return false if existing votes are found votes = Vote.objects.filter( object_id__in=[o.id for o in self.polloption_set.all()], token=request.secretballot_token ) if votes.exists(): return False, 'voted' else: return True, 'can_vote'
0.002395
def _update_sid_to_last_existing_pid_map(pid): """Set chain head PID to the last existing object in the chain to which ``pid`` belongs. If SID has been set for chain, it resolves to chain head PID. Intended to be called in MNStorage.delete() and other chain manipulation. Preconditions: - ``pid`` must exist and be verified to be a PID. d1_gmn.app.views.asserts.is_existing_object() """ last_pid = _find_head_or_latest_connected(pid) chain_model = _get_chain_by_pid(last_pid) if not chain_model: return chain_model.head_pid = d1_gmn.app.did.get_or_create_did(last_pid) chain_model.save()
0.003086
def conference_hangup(self, call_params): """REST Conference Hangup helper """ path = '/' + self.api_version + '/ConferenceHangup/' method = 'POST' return self.request(path, method, call_params)
0.008547
def apns_fetch_inactive_ids(): """ Queries the APNS server for id's that are no longer active since the last fetch """ with closing(_apns_create_socket_to_feedback()) as socket: inactive_ids = [] for _, registration_id in _apns_receive_feedback(socket): inactive_ids.append(codecs.encode(registration_id, 'hex_codec')) return inactive_ids
0.002525
async def delay(self, duration_s: int): """ Pause and sleep """ self.pause() await asyncio.sleep(duration_s) self.resume()
0.012346
def raise_for_execution_errors(nb, output_path): """Assigned parameters into the appropriate place in the input notebook Parameters ---------- nb : NotebookNode Executable notebook object output_path : str Path to write executed notebook """ error = None for cell in nb.cells: if cell.get("outputs") is None: continue for output in cell.outputs: if output.output_type == "error": error = PapermillExecutionError( exec_count=cell.execution_count, source=cell.source, ename=output.ename, evalue=output.evalue, traceback=output.traceback, ) break if error: # Write notebook back out with the Error Message at the top of the Notebook. error_msg = ERROR_MESSAGE_TEMPLATE % str(error.exec_count) error_msg_cell = nbformat.v4.new_code_cell( source="%%html\n" + error_msg, outputs=[ nbformat.v4.new_output(output_type="display_data", data={"text/html": error_msg}) ], metadata={"inputHidden": True, "hide_input": True}, ) nb.cells = [error_msg_cell] + nb.cells write_ipynb(nb, output_path) raise error
0.002216
def set(self, indexes, values=None): """ Given indexes will set a sub-set of the Series to the values provided. This method will direct to the below methods based on what types are passed in for the indexes. If the indexes contains values not in the Series then new rows or columns will be added. :param indexes: indexes value, list of indexes values, or a list of booleans. :param values: value or list of values to set. If a list then must be the same length as the indexes parameter. :return: nothing """ if isinstance(indexes, (list, blist)): self.set_rows(indexes, values) else: self.set_cell(indexes, values)
0.011096
def value(self): """Set a calculated value for this Expression. Used when writing formulas using XlsxWriter to give cells an initial value when the sheet is loaded without being calculated. """ try: if isinstance(self.__value, Expression): return self.__value.value return self.__value except AttributeError: return 0
0.004796
def xy_reading_order(e1, e2): """ A comparator to sort bboxes from left to right, top to bottom """ b1 = e1.bbox b2 = e2.bbox if round(b1[x0]) == round(b2[x0]): return float_cmp(b1[y0], b2[y0]) return float_cmp(b1[x0], b2[x0])
0.003817
def monthly_cooling_design_days_100(self): """A list of 12 objects representing monthly 10.0% cooling design days.""" if self.monthly_found is False or self._monthly_db_100 == [] \ or self._monthly_wb_100 == []: return [] else: db_conds = [DryBulbCondition(x, y) for x, y in zip( self._monthly_db_100, self._monthly_db_range_50)] hu_conds = [HumidityCondition( 'Wetbulb', x, self._stand_press_at_elev) for x in self._monthly_wb_100] ws_conds = self.monthly_wind_conditions sky_conds = self.monthly_clear_sky_conditions return [DesignDay( '10% Cooling Design Day for {}'.format(self._months[i]), 'SummerDesignDay', self._location, db_conds[i], hu_conds[i], ws_conds[i], sky_conds[i]) for i in xrange(12)]
0.005417
def build_image(self, conf, pushing=False): """Build this image""" with conf.make_context() as context: try: stream = BuildProgressStream(conf.harpoon.silent_build) with self.remove_replaced_images(conf) as info: cached = NormalBuilder().build(conf, context, stream) info['cached'] = cached except (KeyboardInterrupt, Exception) as error: exc_info = sys.exc_info() if stream.current_container: Runner().stage_build_intervention(conf, stream.current_container) if isinstance(error, KeyboardInterrupt): raise UserQuit() else: six.reraise(*exc_info) finally: if stream and stream.intermediate_images and conf.cleanup_intermediate_images: for image in stream.intermediate_images: log.info("Deleting intermediate image\timage=%s", image) try: conf.harpoon.docker_api.remove_image(image) except Exception as error: log.error("Failed to remove intermediate image\timage=%s\terror=%s", image, error) return cached
0.004521
def setTableType( self, tableType ): """ Sets the table type for this record box to the inputed table type. :param tableType | <orb.Table> """ self._tableType = tableType if tableType: self._tableTypeName = tableType.schema().name() else: self._tableTypeName = ''
0.018373
def encode(self, word, max_length=5, zero_pad=True): """Return the Roger Root code for a word. Parameters ---------- word : str The word to transform max_length : int The maximum length (default 5) of the code to return zero_pad : bool Pad the end of the return value with 0s to achieve a max_length string Returns ------- str The Roger Root code Examples -------- >>> roger_root('Christopher') '06401' >>> roger_root('Niall') '02500' >>> roger_root('Smith') '00310' >>> roger_root('Schmidt') '06310' """ # uppercase, normalize, decompose, and filter non-A-Z out word = unicode_normalize('NFKD', text_type(word.upper())) word = word.replace('ß', 'SS') word = ''.join(c for c in word if c in self._uc_set) code = '' pos = 0 # Do first digit(s) first for num in range(4, 0, -1): if word[:num] in self._init_patterns[num]: code = self._init_patterns[num][word[:num]] pos += num break # Then code subsequent digits while pos < len(word): for num in range(4, 0, -1): # pragma: no branch if word[pos : pos + num] in self._med_patterns[num]: code += self._med_patterns[num][word[pos : pos + num]] pos += num break code = self._delete_consecutive_repeats(code) code = code.replace('*', '') if zero_pad: code += '0' * max_length return code[:max_length]
0.00229
def make_request_parser(model_or_inst, excludes=None, only=None, for_populate=False): """Pass a `model class` or `model instance` to this function, then, it will generate a `RequestParser` that extract user request data from `request.json` according to the model class's definition. Parameter `excludes` and `only` can be `str` or list of `str`, then are used to specify which columns should be handled. If you passed `excludes` and `only` at same time, only `excludes` will be used. And, the primary key of the model will not be added to `RequestParser`'s argument list, unless you explicitly specify it use `only` parameter. If you pass in a model class, but not a model instance, the function will doing `required` checking, for columns that nullable=False. (If you pass in a model instance, the `required` checking will not proceed. Because in this situation, we should allow the user to ignore the assignment to a field) """ is_inst = _is_inst(model_or_inst) if isinstance(excludes, six.string_types): excludes = [excludes] if excludes and only: only = None elif isinstance(only, six.string_types): only = [only] parser = RequestPopulator() if for_populate else reqparse.RequestParser() for col in model_or_inst.__table__.columns: if only: if col.name not in only: continue elif (excludes and col.name in excludes) or col.primary_key: continue col_type = col.type.python_type kwargs = { "type": _type_dict.get(col_type.__name__, col_type) if hasattr(col_type, '__name__') else col_type } # When the context was to creating a new model instance, if a field has no default value, and is not nullable, # mark it's corresponding argument as `required`. # 创建新数据库实例时,若一个字段既没有默认值,又不允许 NULL,则把它对应 arg 设为 required if not is_inst and col.default is None and col.server_default is None and not col.nullable: kwargs["required"] = True parser.add_argument(col.name, **kwargs) return parser
0.005128
def id_lookup(paper_id, idtype): """Take an ID of type PMID, PMCID, or DOI and lookup the other IDs. If the DOI is not found in Pubmed, try to obtain the DOI by doing a reverse-lookup of the DOI in CrossRef using article metadata. Parameters ---------- paper_id : str ID of the article. idtype : str Type of the ID: 'pmid', 'pmcid', or 'doi Returns ------- ids : dict A dictionary with the following keys: pmid, pmcid and doi. """ if idtype not in ('pmid', 'pmcid', 'doi'): raise ValueError("Invalid idtype %s; must be 'pmid', 'pmcid', " "or 'doi'." % idtype) ids = {'doi': None, 'pmid': None, 'pmcid': None} pmc_id_results = pmc_client.id_lookup(paper_id, idtype) # Start with the results of the PMC lookup and then override with the # provided ID ids['pmid'] = pmc_id_results.get('pmid') ids['pmcid'] = pmc_id_results.get('pmcid') ids['doi'] = pmc_id_results.get('doi') ids[idtype] = paper_id # If we gave a DOI, then our work is done after looking for PMID and PMCID if idtype == 'doi': return ids # If we gave a PMID or PMCID, we need to check to see if we got a DOI. # If we got a DOI back, we're done. elif ids.get('doi'): return ids # If we get here, then we've given PMID or PMCID and don't have a DOI yet. # If we gave a PMCID and have neither a PMID nor a DOI, then we'll run # into problems later on when we try to the reverse lookup using CrossRef. # So we bail here and return what we have (PMCID only) with a warning. if ids.get('pmcid') and ids.get('doi') is None and ids.get('pmid') is None: logger.warning('%s: PMCID without PMID or DOI' % ids.get('pmcid')) return ids # To clarify the state of things at this point: assert ids.get('pmid') is not None assert ids.get('doi') is None # As a last result, we try to get the DOI from CrossRef (which internally # tries to get the DOI from Pubmed in the process of collecting the # necessary metadata for the lookup): ids['doi'] = crossref_client.doi_query(ids['pmid']) # It may still be None, but at this point there's nothing we can do... return ids
0.000442
def _get_path_infomation(self): """Get useful infomation from the device path.""" long_identifier = self._device_path.split('/')[4] protocol, remainder = long_identifier.split('-', 1) identifier, _, device_type = remainder.rsplit('-', 2) return (protocol, identifier, device_type)
0.00625
def accepts_port(self, port): """ Query whether this Router will accept the given port. """ if self.rejected_ports is None and self.accepted_ports is None: raise RuntimeError("policy hasn't been set yet") if self.rejected_ports: for x in self.rejected_ports: if port == x: return False return True for x in self.accepted_ports: if port == x: return True return False
0.00381
def child(self, **kwargs): '''set childSelector.''' return AutomatorDeviceObject( self.device, self.selector.clone().child(**kwargs) )
0.010989
def install_python(python, runas=None): ''' Install a python implementation. python The version of python to install, should match one of the versions listed by pyenv.list CLI Example: .. code-block:: bash salt '*' pyenv.install_python 2.0.0-p0 ''' python = re.sub(r'^python-', '', python) env = None env_list = [] if __grains__['os'] in ('FreeBSD', 'NetBSD', 'OpenBSD'): env_list.append('MAKE=gmake') if __salt__['config.option']('pyenv.build_env'): env_list.append(__salt__['config.option']('pyenv.build_env')) if env_list: env = ' '.join(env_list) ret = {} ret = _pyenv_exec('install', python, env=env, runas=runas, ret=ret) if ret['retcode'] == 0: rehash(runas=runas) return ret['stderr'] else: # Cleanup the failed installation so it doesn't list as installed uninstall_python(python, runas=runas) return False
0.001025
def get_orders(self, address, chain_name='NEO', contract_version='V2', pair=None, from_epoch_time=None, order_status=None, before_id=None, limit=50): """ Function to fetch the order history of the given address. Execution of this function is as follows:: get_orders(address=neo_get_scripthash_from_address(address=address)) The expected return result for this function is as follows:: [{ 'id': '7cbdf481-6acf-4bf3-a1ed-4773f31e6931', 'blockchain': 'neo', 'contract_hash': 'a195c1549e7da61b8da315765a790ac7e7633b82', 'address': 'fea2b883725ef2d194c9060f606cd0a0468a2c59', 'side': 'buy', 'offer_asset_id': 'c56f33fc6ecfcd0c225c4ab356fee59390af8560be0e930faebe74a6daff7c9b', 'want_asset_id': 'ab38352559b8b203bde5fddfa0b07d8b2525e132', 'offer_amount': '53718500', 'want_amount': '110000000000', 'transfer_amount': '0', 'priority_gas_amount': '0', 'use_native_token': True, 'native_fee_transfer_amount': 0, 'deposit_txn': None, 'created_at': '2018-08-03T02:44:47.692Z', 'status': 'processed', 'fills': [{ 'id': 'b6f9e530-60ff-46ff-9a71-362097a2025e', 'offer_hash': '95b3b03be0bff8f58aa86a8dd599700bbaeaffc05078329d5b726b6b995f4cda', 'offer_asset_id': 'c56f33fc6ecfcd0c225c4ab356fee59390af8560be0e930faebe74a6daff7c9b', 'want_asset_id': 'ab38352559b8b203bde5fddfa0b07d8b2525e132', 'fill_amount': '47833882', 'want_amount': '97950000000', 'filled_amount': '', 'fee_asset_id': 'ab38352559b8b203bde5fddfa0b07d8b2525e132', 'fee_amount': '73462500', 'price': '0.00048835', 'txn': None, 'status': 'success', 'created_at': '2018-08-03T02:44:47.706Z', 'transaction_hash': '694745a09e33845ec008cfb79c73986a556e619799ec73274f82b30d85bda13a' }], 'makes': [{ 'id': '357088a0-cc80-49ab-acdd-980589c2d7d8', 'offer_hash': '420cc85abf02feaceb1bcd91489a0c1949c972d2a9a05ae922fa15d79de80c00', 'available_amount': '0', 'offer_asset_id': 'c56f33fc6ecfcd0c225c4ab356fee59390af8560be0e930faebe74a6daff7c9b', 'offer_amount': '5884618', 'want_asset_id': 'ab38352559b8b203bde5fddfa0b07d8b2525e132', 'want_amount': '12050000000', 'filled_amount': '0.0', 'txn': None, 'cancel_txn': None, 'price': '0.000488350041493775933609958506224066390041494', 'status': 'cancelled', 'created_at': '2018-08-03T02:44:47.708Z', 'transaction_hash': '1afa946546550151bbbd19f197a87cec92e9be58c44ec431cae42076298548b7', 'trades': [] }] }, { .... }] :param address: The ScriptHash of the address to filter orders for. :type address: str :param pair: The trading pair to filter order requests on. :type pair: str :param chain_name: The name of the chain to find orders against. :type chain_name: str :param contract_version: The version of the contract to find orders against. :type contract_version: str :param from_epoch_time: Only return orders that are last updated at or after this time. :type from_epoch_time: int :param order_status: Only return orders have this status. Possible values are open, cancelled, completed. :type order_status: str :param before_id: Only return orders that are created before the order with this id. :type before_id: str :param limit: Only return up to this number of orders (min: 1, max: 200, default: 50). :type limit: int :return: List of dictionaries containing the orders for the given NEO address and (optional) trading pair. """ api_params = { "address": address, "contract_hash": self.get_contracts()[chain_name.upper()][contract_version.upper()], "limit": limit } if pair is not None: api_params['pair'] = pair if from_epoch_time is not None: api_params['from_epoch_time'] = from_epoch_time if order_status is not None: api_params['order_status'] = order_status if before_id is not None: api_params['before_id'] = before_id return self.request.get(path='/orders', params=api_params)
0.004023
def addfile(self, tarinfo, fileobj=None): """Add the TarInfo object `tarinfo' to the archive. If `fileobj' is given, tarinfo.size bytes are read from it and added to the archive. You can create TarInfo objects using gettarinfo(). On Windows platforms, `fileobj' should always be opened with mode 'rb' to avoid irritation about the file size. """ self._check("aw") tarinfo = copy.copy(tarinfo) buf = tarinfo.tobuf(self.format, self.encoding, self.errors) self.fileobj.write(buf) self.offset += len(buf) # If there's data to follow, append it. if fileobj is not None: copyfileobj(fileobj, self.fileobj, tarinfo.size) blocks, remainder = divmod(tarinfo.size, BLOCKSIZE) if remainder > 0: self.fileobj.write(NUL * (BLOCKSIZE - remainder)) blocks += 1 self.offset += blocks * BLOCKSIZE self.members.append(tarinfo)
0.001967
def safe_zip(*args): """like zip but with these properties: - returns a list, rather than an iterator. This is the old Python2 zip behavior. - a guarantee that all arguments are the same length. (normal zip silently drops entries to make them the same length) """ length = len(args[0]) if not all(len(arg) == length for arg in args): raise ValueError("Lengths of arguments do not match: " + str([len(arg) for arg in args])) return list(zip(*args))
0.012295
def get_properties_by_type(self, type, recursive=True, parent_path=""): """ Returns a sorted list of fields that match the type. :param type the type of the field "string","integer" or a list of types :param recursive recurse to sub object :returns a sorted list of fields the match the type """ if parent_path: parent_path += "." if isinstance(type, str): if type == "*": type = set(MAPPING_NAME_TYPE.keys()) - set(["nested", "multi_field", "multifield"]) else: type = [type] properties = [] for prop in list(self.properties.values()): if prop.type in type: properties.append((parent_path + prop.name, prop)) continue elif prop.type == "multi_field" and prop.name in prop.fields and prop.fields[prop.name].type in type: properties.append((parent_path + prop.name, prop)) continue if not recursive: continue if prop.type in ["nested", "object"]: properties.extend( prop.get_properties_by_type(type, recursive=recursive, parent_path=parent_path + prop.name)) return sorted(properties)
0.003826
def get(cls, uni_char): """Return the general category code (as Unicode string) for the given Unicode character""" uni_char = unicod(uni_char) # Force to Unicode return unicod(unicodedata.category(uni_char))
0.012931
def supports(cls, template_file=None): """ :return: Whether the engine can process given template file or not. """ if anytemplate.compat.IS_PYTHON_3: cls._priority = 99 return False # Always as it's not ported to python 3. return super(Engine, cls).supports(template_file=template_file)
0.005682
def store_in_internal_db(args, hsm, modhex_id, public_id, kh, aead): """ Store record (AEAD) in YubiHSM internal DB """ if args.verbose: print " %i bytes (%s) -> internal db..." % \ (len(aead.data), shorten_aead(aead)), try: hsm.db_store_yubikey(public_id.decode('hex'), kh, aead) if args.verbose: print "OK" except pyhsm.exception.YHSM_CommandFailed as e: if args.verbose: print "%s" % (pyhsm.defines.status2str(e.status)) else: print "Storing ID %s FAILED: %s" % (modhex_id, pyhsm.defines.status2str(e.status)) return False return True
0.003049
def quote(cls, value): """Quote the value for the cookie. This can be any object supported by :attr:`serialization_method`. :param value: the value to quote. """ if cls.serialization_method is not None: value = cls.serialization_method.dumps(value) if cls.quote_base64: value = b''.join(base64.b64encode(value).splitlines()).strip() return value
0.004684
def add_and_get(self, delta): ''' Atomically adds `delta` to the current value. :param delta: The delta to add. ''' with self._lock.exclusive: self._value += delta return self._value
0.008097
def num_throats(self, labels='all', mode='union'): r""" Return the number of throats of the specified labels Parameters ---------- labels : list of strings, optional The throat labels that should be included in the count. If not supplied, all throats are counted. mode : string, optional Specifies how the count should be performed. The options are: **'or', 'union', 'any'** : (default) Throats with *one or more* of the given labels are counted. **'and', 'intersection', 'all'** : Throats with *all* of the given labels are counted. **'xor', 'exclusive_or'** : Throats with *only one* of the given labels are counted. **'nor', 'none', 'not'** : Throats with *none* of the given labels are counted. **'nand'** : Throats with *some but not all* of the given labels are counted. **'xnor'** : Throats with *more than one* of the given labels are counted. Returns ------- Nt : int Number of throats with the specified labels See Also -------- num_pores count Notes ----- Technically, *'nand'* and *'xnor'* should also count throats with *none* of the labels, however, to make the count more useful these are not included. """ # Count number of pores of specified type Ts = self._get_indices(labels=labels, mode=mode, element='throat') Nt = sp.shape(Ts)[0] return Nt
0.001212
def valid_id(opts, id_): ''' Returns if the passed id is valid ''' try: if any(x in id_ for x in ('/', '\\', str('\0'))): return False return bool(clean_path(opts['pki_dir'], id_)) except (AttributeError, KeyError, TypeError, UnicodeDecodeError): return False
0.003175
def update(self, friendly_name): """ Update the FunctionInstance :param unicode friendly_name: The friendly_name :returns: Updated FunctionInstance :rtype: twilio.rest.serverless.v1.service.function.FunctionInstance """ data = values.of({'FriendlyName': friendly_name, }) payload = self._version.update( 'POST', self._uri, data=data, ) return FunctionInstance( self._version, payload, service_sid=self._solution['service_sid'], sid=self._solution['sid'], )
0.003165
def _checker(keywords): """Generate a checker which tests a given value not starts with keywords.""" def _(v): """Check a given value matches to keywords.""" for k in keywords: if k in v: return False return True return _
0.007018
def set_basic_selection(self, selection, value, fields=None): """Modify data for an item or region of the array. Parameters ---------- selection : tuple An integer index or slice or tuple of int/slice specifying the requested region for each dimension of the array. value : scalar or array-like Value to be stored into the array. fields : str or sequence of str, optional For arrays with a structured dtype, one or more fields can be specified to set data for. Examples -------- Setup a 1-dimensional array:: >>> import zarr >>> import numpy as np >>> z = zarr.zeros(100, dtype=int) Set all array elements to the same scalar value:: >>> z.set_basic_selection(..., 42) >>> z[...] array([42, 42, 42, ..., 42, 42, 42]) Set a portion of the array:: >>> z.set_basic_selection(slice(10), np.arange(10)) >>> z.set_basic_selection(slice(-10, None), np.arange(10)[::-1]) >>> z[...] array([ 0, 1, 2, ..., 2, 1, 0]) Setup a 2-dimensional array:: >>> z = zarr.zeros((5, 5), dtype=int) Set all array elements to the same scalar value:: >>> z.set_basic_selection(..., 42) Set a portion of the array:: >>> z.set_basic_selection((0, slice(None)), np.arange(z.shape[1])) >>> z.set_basic_selection((slice(None), 0), np.arange(z.shape[0])) >>> z[...] array([[ 0, 1, 2, 3, 4], [ 1, 42, 42, 42, 42], [ 2, 42, 42, 42, 42], [ 3, 42, 42, 42, 42], [ 4, 42, 42, 42, 42]]) For arrays with a structured dtype, the `fields` parameter can be used to set data for a specific field, e.g.:: >>> a = np.array([(b'aaa', 1, 4.2), ... (b'bbb', 2, 8.4), ... (b'ccc', 3, 12.6)], ... dtype=[('foo', 'S3'), ('bar', 'i4'), ('baz', 'f8')]) >>> z = zarr.array(a) >>> z.set_basic_selection(slice(0, 2), b'zzz', fields='foo') >>> z[:] array([(b'zzz', 1, 4.2), (b'zzz', 2, 8.4), (b'ccc', 3, 12.6)], dtype=[('foo', 'S3'), ('bar', '<i4'), ('baz', '<f8')]) Notes ----- This method provides the underlying implementation for modifying data via square bracket notation, see :func:`__setitem__` for equivalent examples using the alternative notation. See Also -------- get_basic_selection, get_mask_selection, set_mask_selection, get_coordinate_selection, set_coordinate_selection, get_orthogonal_selection, set_orthogonal_selection, vindex, oindex, __getitem__, __setitem__ """ # guard conditions if self._read_only: err_read_only() # refresh metadata if not self._cache_metadata: self._load_metadata_nosync() # handle zero-dimensional arrays if self._shape == (): return self._set_basic_selection_zd(selection, value, fields=fields) else: return self._set_basic_selection_nd(selection, value, fields=fields)
0.003246
def arc(self, x, y, radius, start_angle, end_angle): """draw arc going counter-clockwise from start_angle to end_angle""" self._add_instruction("arc", x, y, radius, start_angle, end_angle)
0.009804
def create_course_completion(self, user_id, payload): # pylint: disable=unused-argument """ Send a completion status payload to the Degreed Completion Status endpoint Args: user_id: Unused. payload: JSON encoded object (serialized from DegreedLearnerDataTransmissionAudit) containing completion status fields per Degreed documentation. Returns: A tuple containing the status code and the body of the response. Raises: HTTPError: if we received a failure response code from Degreed """ return self._post( urljoin( self.enterprise_configuration.degreed_base_url, self.global_degreed_config.completion_status_api_path ), payload, self.COMPLETION_PROVIDER_SCOPE )
0.005747
def execute(self): """ Stops the cluster if it's running. """ cluster_name = self.params.cluster creator = make_creator(self.params.config, storage_path=self.params.storage) try: cluster = creator.load_cluster(cluster_name) except (ClusterNotFound, ConfigurationError) as err: log.error("Cannot stop cluster `%s`: %s", cluster_name, err) return os.EX_NOINPUT if not self.params.yes: confirm_or_abort( "Do you want really want to stop cluster `{cluster_name}`?" .format(cluster_name=cluster_name), msg="Aborting upon user request.") print("Destroying cluster `%s` ..." % cluster_name) cluster.stop(force=self.params.force, wait=self.params.wait)
0.002347
def acquire(self): """ Locks the account. Returns True on success, False if the account is thread-local and must not be locked. """ if self.host: self.parent.send(('acquire-account-for-host', self.host)) elif self.account_hash: self.parent.send(('acquire-account-from-hash', self.account_hash)) else: self.parent.send(('acquire-account')) response = self.parent.recv() if isinstance(response, Exception): raise response if response is None: return False self.account_hash, \ self.user, \ self.password, \ self.authorization_password, \ self.key = response return True
0.002587
def to_array(self): """ Serializes this GameHighScore to a dictionary. :return: dictionary representation of this object. :rtype: dict """ array = super(GameHighScore, self).to_array() array['position'] = int(self.position) # type int array['user'] = self.user.to_array() # type User array['score'] = int(self.score) # type int return array
0.004717
def crud_mutation_name(action, model): """ This function returns the name of a mutation that performs the specified crud action on the given model service """ model_string = get_model_string(model) # make sure the mutation name is correctly camelcases model_string = model_string[0].upper() + model_string[1:] # return the mutation name return "{}{}".format(action, model_string)
0.004717
def delete(self): """ delete() executes the query by delegating to delete_by_query() """ es = connections.get_connection(self._using) return AttrDict( es.delete_by_query( index=self._index, body=self.to_dict(), **self._params ) )
0.005698
def extract_from_zip(path, candidates): """ Given a zip archive and a function to detect the presence of a given filename, unzip the archive into a temporary directory and return the full path of the file. Raise an IOError if the file cannot be found within the archive. :param path: pathname of the archive :param candidates: list of names to search for """ temp_dir = tempfile.mkdtemp() with zipfile.ZipFile(path) as archive: archive.extractall(temp_dir) return [f for f in collect_files(temp_dir) if os.path.basename(f) in candidates]
0.001661
def previous(self): """ Returns new CharacterDataWrapper TODO: Don't lower offset below 0 """ self.params['offset'] = str(int(self.params['offset']) - int(self.params['limit'])) return self.marvel.get_characters(self.marvel, (), **self.params)
0.010309
def add_function_attribute(self, attr): """Only works on function value Parameters ----------- attr : str attribute name """ if not self.is_function: raise ValueError('expected function value, got %s' % (self._kind,)) attrname = str(attr) attrval = ffi.lib.LLVMPY_GetEnumAttributeKindForName( _encode_string(attrname), len(attrname)) if attrval == 0: raise ValueError('no such attribute {!r}'.format(attrname)) ffi.lib.LLVMPY_AddFunctionAttr(self, attrval)
0.003419
def _infer_stmts(stmts, context, frame=None): """Return an iterator on statements inferred by each statement in *stmts*.""" inferred = False if context is not None: name = context.lookupname context = context.clone() else: name = None context = contextmod.InferenceContext() for stmt in stmts: if stmt is util.Uninferable: yield stmt inferred = True continue context.lookupname = stmt._infer_name(frame, name) try: for inferred in stmt.infer(context=context): yield inferred inferred = True except exceptions.NameInferenceError: continue except exceptions.InferenceError: yield util.Uninferable inferred = True if not inferred: raise exceptions.InferenceError( "Inference failed for all members of {stmts!r}.", stmts=stmts, frame=frame, context=context, )
0.001938
def tracer_config(__init__, app, args, kwargs): """ Wraps the Tornado web application initialization so that the TornadoTracing instance is created around an OpenTracing-compatible tracer. """ __init__(*args, **kwargs) tracing = app.settings.get('opentracing_tracing') tracer_callable = app.settings.get('opentracing_tracer_callable') tracer_parameters = app.settings.get('opentracing_tracer_parameters', {}) if tracer_callable is not None: if not callable(tracer_callable): tracer_callable = _get_callable_from_name(tracer_callable) tracer = tracer_callable(**tracer_parameters) tracing = TornadoTracing(tracer) if tracing is None: tracing = TornadoTracing() # fallback to the global tracer app.settings['opentracing_tracing'] = tracing tracing._trace_all = app.settings.get('opentracing_trace_all', DEFAULT_TRACE_ALL) tracing._trace_client = app.settings.get('opentracing_trace_client', DEFAULT_TRACE_CLIENT) tracing._start_span_cb = app.settings.get('opentracing_start_span_cb', None) httpclient._set_tracing_enabled(tracing._trace_client) if tracing._trace_client: httpclient._set_tracing_info(tracing._tracer_obj, tracing._start_span_cb)
0.000696
def clear_trace_filter_cache(): ''' Clear the trace filter cache. Call this after reloading. ''' global should_trace_hook try: # Need to temporarily disable a hook because otherwise # _filename_to_ignored_lines.clear() will never complete. old_hook = should_trace_hook should_trace_hook = None # Clear the linecache linecache.clearcache() _filename_to_ignored_lines.clear() finally: should_trace_hook = old_hook
0.00198
def get_property(self, key): """Expect Django Conf property""" _key = DJANGO_CONF[key] return getattr(self, _key, CONF_SPEC[_key])
0.012987
def opt(self, *, exception=None, record=False, lazy=False, ansi=False, raw=False, depth=0): r"""Parametrize a logging call to slightly change generated log message. Parameters ---------- exception : |bool|, |tuple| or |Exception|, optional If it does not evaluate as ``False``, the passed exception is formatted and added to the log message. It could be an |Exception| object or a ``(type, value, traceback)`` tuple, otherwise the exception information is retrieved from |sys.exc_info|. record : |bool|, optional If ``True``, the record dict contextualizing the logging call can be used to format the message by using ``{record[key]}`` in the log message. lazy : |bool|, optional If ``True``, the logging call attribute to format the message should be functions which will be called only if the level is high enough. This can be used to avoid expensive functions if not necessary. ansi : |bool|, optional If ``True``, logged message will be colorized according to the markups it possibly contains. raw : |bool|, optional If ``True``, the formatting of each sink will be bypassed and the message will be send as is. depth : |int|, optional Specify which stacktrace should be used to contextualize the logged message. This is useful while using the logger from inside a wrapped function to retrieve worthwhile information. Returns ------- :class:`~Logger` A logger wrapping the core logger, but transforming logged message adequately before sending. Examples -------- >>> try: ... 1 / 0 ... except ZeroDivisionError: ... logger.opt(exception=True).debug("Exception logged with debug level:") ... [18:10:02] DEBUG in '<module>' - Exception logged with debug level: Traceback (most recent call last, catch point marked): > File "<stdin>", line 2, in <module> ZeroDivisionError: division by zero >>> logger.opt(record=True).info("Current line is: {record[line]}") [18:10:33] INFO in '<module>' - Current line is: 1 >>> logger.opt(lazy=True).debug("If sink <= DEBUG: {x}", x=lambda: math.factorial(2**5)) [18:11:19] DEBUG in '<module>' - If sink <= DEBUG: 263130836933693530167218012160000000 >>> logger.opt(ansi=True).warning("We got a <red>BIG</red> problem") [18:11:30] WARNING in '<module>' - We got a BIG problem >>> logger.opt(raw=True).debug("No formatting\n") No formatting >>> def wrapped(): ... logger.opt(depth=1).info("Get parent context") ... >>> def func(): ... wrapped() ... >>> func() [18:11:54] DEBUG in 'func' - Get parent context """ return Logger(self._extra, exception, record, lazy, ansi, raw, depth)
0.005861
def get_historical_output(self, assessment, options): """ To get output of a historical Assessment :param assessment: string :param options: dict """ responseFormat=None if options and 'format' in options and options['format'] is not None: responseFormat = options['format'] options['format'] = None url = '/assessment/' + str(assessment) + '/output?' + urllib.parse.urlencode(options) response = self.http.downstream(url, responseFormat) return response
0.007156
def warsaw_up_to_warsaw(C, parameters=None, sectors=None): """Translate from the 'Warsaw up' basis to the Warsaw basis. Parameters used: - `Vus`, `Vub`, `Vcb`, `gamma`: elements of the unitary CKM matrix (defined as the mismatch between left-handed quark mass matrix diagonalization matrices). """ C_in = smeftutil.wcxf2arrays_symmetrized(C) p = default_parameters.copy() if parameters is not None: # if parameters are passed in, overwrite the default values p.update(parameters) Uu = Ud = Ul = Ue = np.eye(3) V = ckmutil.ckm.ckm_tree(p["Vus"], p["Vub"], p["Vcb"], p["delta"]) Uq = V C_out = smeftutil.flavor_rotation(C_in, Uq, Uu, Ud, Ul, Ue) C_out = smeftutil.arrays2wcxf_nonred(C_out) warsaw = wcxf.Basis['SMEFT', 'Warsaw'] all_wcs = set(warsaw.all_wcs) # to speed up lookup return {k: v for k, v in C_out.items() if k in all_wcs}
0.001083
def insert_picture(self, image_file): """ Return a |PlaceholderPicture| object depicting the image in *image_file*, which may be either a path (string) or a file-like object. The image is cropped to fill the entire space of the placeholder. A |PlaceholderPicture| object has all the properties and methods of a |Picture| shape except that the value of its :attr:`~._BaseSlidePlaceholder.shape_type` property is `MSO_SHAPE_TYPE.PLACEHOLDER` instead of `MSO_SHAPE_TYPE.PICTURE`. """ pic = self._new_placeholder_pic(image_file) self._replace_placeholder_with(pic) return PlaceholderPicture(pic, self._parent)
0.002853
def visit_Cond(self, node): ''' generic expression splitting algorithm. Should work for ifexp and if using W(rap) and U(n)W(rap) to manage difference between expr and stmt The idea is to split a BinOp in three expressions: 1. a (possibly empty) non-static expr 2. an expr containing a static expr 3. a (possibly empty) non-static expr Once split, the if body is refactored to keep the semantic, and then recursively split again, until all static expr are alone in a test condition ''' NodeTy = type(node) if NodeTy is ast.IfExp: def W(x): return x def UW(x): return x else: def W(x): return [x] def UW(x): return x[0] has_static_expr = self.gather(HasStaticExpression, node.test) if not has_static_expr: return node if node.test in self.static_expressions: return node if not isinstance(node.test, ast.BinOp): return node before, static = [], [] values = [node.test.right, node.test.left] def has_static_expression(n): return self.gather(HasStaticExpression, n) while values and not has_static_expression(values[-1]): before.append(values.pop()) while values and has_static_expression(values[-1]): static.append(values.pop()) after = list(reversed(values)) test_before = NodeTy(None, None, None) if before: assert len(before) == 1 test_before.test = before[0] test_static = NodeTy(None, None, None) if static: test_static.test = static[0] if len(static) > 1: if after: assert len(after) == 1 after = [ast.BinOp(static[1], node.test.op, after[0])] else: after = static[1:] test_after = NodeTy(None, None, None) if after: assert len(after) == 1 test_after.test = after[0] if isinstance(node.test.op, ast.BitAnd): if after: test_after.body = deepcopy(node.body) test_after.orelse = deepcopy(node.orelse) test_after = W(test_after) else: test_after = deepcopy(node.body) if static: test_static.body = test_after test_static.orelse = deepcopy(node.orelse) test_static = W(test_static) else: test_static = test_after if before: test_before.body = test_static test_before.orelse = node.orelse node = test_before else: node = UW(test_static) elif isinstance(node.test.op, ast.BitOr): if after: test_after.body = deepcopy(node.body) test_after.orelse = deepcopy(node.orelse) test_after = W(test_after) else: test_after = deepcopy(node.orelse) if static: test_static.body = deepcopy(node.body) test_static.orelse = test_after test_static = W(test_static) else: test_static = test_after if before: test_before.body = deepcopy(node.body) test_before.orelse = test_static node = test_before else: node = UW(test_static) else: raise PythranSyntaxError("operator not supported in a static if", node) self.update = True return self.visit(node)
0.000776
def acs2d(input, exec_path='', time_stamps=False, verbose=False, quiet=False, exe_args=None): r""" Run the acs2d.e executable as from the shell. Output is automatically named based on input suffix: +--------------------+----------------+------------------------------+ | INPUT | OUTPUT | EXPECTED DATA | +====================+================+==============================+ | ``*_raw.fits`` | ``*_flt.fits`` | SBC image. | +--------------------+----------------+------------------------------+ | ``*_blv_tmp.fits`` | ``*_flt.fits`` | ACSCCD output. | +--------------------+----------------+------------------------------+ | ``*_blc_tmp.fits`` | ``*_flc.fits`` | ACSCCD output with PCTECORR. | +--------------------+----------------+------------------------------+ | ``*_crj_tmp.fits`` | ``*_crj.fits`` | ACSREJ output. | +--------------------+----------------+------------------------------+ | ``*_crc_tmp.fits`` | ``*_crc.fits`` | ACSREJ output with PCTECORR. | +--------------------+----------------+------------------------------+ Parameters ---------- input : str or list of str Input filenames in one of these formats: * a single filename ('j1234567q_blv_tmp.fits') * a Python list of filenames * a partial filename with wildcards ('\*blv_tmp.fits') * filename of an ASN table ('j12345670_asn.fits') * an at-file (``@input``) exec_path : str, optional The complete path to ACS2D executable. If not given, run ACS2D given by 'acs2d.e'. time_stamps : bool, optional Set to True to turn on the printing of time stamps. verbose : bool, optional Set to True for verbose output. quiet : bool, optional Set to True for quiet output. exe_args : list, optional Arbitrary arguments passed to underlying executable call. Note: Implementation uses subprocess.call and whitespace is not permitted. E.g. use exe_args=['--nThreads', '1'] """ from stsci.tools import parseinput # Optional package dependency if exec_path: if not os.path.exists(exec_path): raise OSError('Executable not found: ' + exec_path) call_list = [exec_path] else: call_list = ['acs2d.e'] # Parse input to get list of filenames to process. # acs2d.e only takes 'file1,file2,...' infiles, dummy_out = parseinput.parseinput(input) call_list.append(','.join(infiles)) if time_stamps: call_list.append('-t') if verbose: call_list.append('-v') if quiet: call_list.append('-q') if exe_args: call_list.extend(exe_args) subprocess.check_call(call_list)
0.000342
def replace(self, text, pattern=None): """Replace selected text by *text* If *pattern* is not None, replacing selected text using regular expression text substitution""" cursor = self.textCursor() cursor.beginEditBlock() if pattern is not None: seltxt = to_text_string(cursor.selectedText()) cursor.removeSelectedText() if pattern is not None: text = re.sub(to_text_string(pattern), to_text_string(text), to_text_string(seltxt)) cursor.insertText(text) cursor.endEditBlock()
0.003241
def DeregisterHelper(cls, helper_class): """Deregisters a helper class. The helper classes are identified based on their lower case name. Args: helper_class (type): class object of the argument helper. Raises: KeyError: if helper class is not set for the corresponding name. """ helper_name = helper_class.NAME.lower() if helper_name not in cls._helper_classes: raise KeyError('Helper class not set for name: {0:s}.'.format( helper_class.NAME)) del cls._helper_classes[helper_name]
0.00367
def spa_tmplt(**kwds): """ Generate a minimal TaylorF2 approximant with optimations for the sin/cos """ # Pull out the input arguments f_lower = kwds['f_lower'] delta_f = kwds['delta_f'] distance = kwds['distance'] mass1 = kwds['mass1'] mass2 = kwds['mass2'] s1z = kwds['spin1z'] s2z = kwds['spin2z'] phase_order = int(kwds['phase_order']) #amplitude_order = int(kwds['amplitude_order']) spin_order = int(kwds['spin_order']) if 'out' in kwds: out = kwds['out'] else: out = None amp_factor = spa_amplitude_factor(mass1=mass1, mass2=mass2) / distance lal_pars = lal.CreateDict() if phase_order != -1: lalsimulation.SimInspiralWaveformParamsInsertPNPhaseOrder( lal_pars, phase_order) if spin_order != -1: lalsimulation.SimInspiralWaveformParamsInsertPNSpinOrder( lal_pars, spin_order) #Calculate the PN terms phasing = lalsimulation.SimInspiralTaylorF2AlignedPhasing( float(mass1), float(mass2), float(s1z), float(s2z), lal_pars) pfaN = phasing.v[0] pfa2 = phasing.v[2] / pfaN pfa3 = phasing.v[3] / pfaN pfa4 = phasing.v[4] / pfaN pfa5 = phasing.v[5] / pfaN pfa6 = (phasing.v[6] - phasing.vlogv[6] * log(4)) / pfaN pfa7 = phasing.v[7] / pfaN pfl5 = phasing.vlogv[5] / pfaN pfl6 = phasing.vlogv[6] / pfaN piM = lal.PI * (mass1 + mass2) * lal.MTSUN_SI kmin = int(f_lower / float(delta_f)) vISCO = 1. / sqrt(6.) fISCO = vISCO * vISCO * vISCO / piM kmax = int(fISCO / delta_f) f_max = ceilpow2(fISCO) n = int(f_max / delta_f) + 1 if not out: htilde = FrequencySeries(zeros(n, dtype=numpy.complex64), delta_f=delta_f, copy=False) else: if type(out) is not Array: raise TypeError("Output must be an instance of Array") if len(out) < kmax: kmax = len(out) if out.dtype != complex64: raise TypeError("Output array is the wrong dtype") htilde = FrequencySeries(out, delta_f=delta_f, copy=False) spa_tmplt_engine(htilde[kmin:kmax], kmin, phase_order, delta_f, piM, pfaN, pfa2, pfa3, pfa4, pfa5, pfl5, pfa6, pfl6, pfa7, amp_factor) return htilde
0.002093
def connect_async(self, connection_id, connection_string, callback): """Asynchronously connect to a device Args: connection_id (int): A unique identifier that will refer to this connection connection_string (string): A DeviceAdapter specific string that can be used to connect to a device using this DeviceAdapter. callback (callable): A function that will be called when the connection attempt finishes as callback(connection_id, adapter_id, success: bool, failure_reason: string or None) """ if callback is not None: callback(connection_id, self.id, False, "connect command is not supported in device adapter")
0.009642
def _call(self, vf, out): """Implement ``self(vf, out)``.""" if self.domain.field == ComplexNumbers(): vf[0].multiply(self._vecfield[0].conj(), out=out) else: vf[0].multiply(self._vecfield[0], out=out) if self.is_weighted: out *= self.weights[0] if len(self.domain) == 1: return tmp = self.range.element() for vfi, gi, wi in zip(vf[1:], self.vecfield[1:], self.weights[1:]): if self.domain.field == ComplexNumbers(): vfi.multiply(gi.conj(), out=tmp) else: vfi.multiply(gi, out=tmp) if self.is_weighted: tmp *= wi out += tmp
0.002635
def parse_text(self, formatted_text): """ Retursn a list of operations (draw, cup, ed,...). Each operation consist of a command and its associated data. :param formatted_text: text to parse with the default char format to apply. :return: list of Operation """ assert isinstance(formatted_text, FormattedText) ret_val = [] fmt = formatted_text.fmt if self._prev_fmt_closed else self._prev_fmt fmt = QtGui.QTextCharFormat(fmt) if not self._pending_text: stripped_text = formatted_text.txt else: stripped_text = self._pending_text + formatted_text.txt self._pending_text = '' while stripped_text: try: escape_pos = stripped_text.index(self._escape[0]) except ValueError: ret_val.append(Operation('draw', FormattedText(stripped_text, fmt))) break else: if escape_pos != 0: ret_val.append(Operation('draw', FormattedText(stripped_text[:escape_pos], fmt))) stripped_text = stripped_text[escape_pos:] fmt = QtGui.QTextCharFormat(fmt) assert stripped_text[0] == self._escape[0] while stripped_text and stripped_text[0] == self._escape[0]: if self._escape.startswith(stripped_text): # control sequence not complete self._pending_text += stripped_text stripped_text = '' break if not stripped_text.startswith(self._escape): # check vt100 escape sequences ctrl_seq = False for alt_seq in self._escape_alts: if stripped_text.startswith(alt_seq): ctrl_seq = True break if not ctrl_seq: # not a control sequence self._pending_text = '' ret_val.append(Operation('draw', FormattedText(stripped_text[:1], fmt))) fmt = QtGui.QTextCharFormat(fmt) stripped_text = stripped_text[1:] continue self._pending_text += _mid(stripped_text, 0, self._escape_len) stripped_text = stripped_text[self._escape_len:] # Non draw related command (cursor/erase) if self._pending_text in [self._escape] + self._escape_alts: m = self._supported_commands.match(stripped_text) if m and self._pending_text == self._escape: _, e = m.span() n = m.group('n') cmd = m.group('cmd') if not n: n = 0 ret_val.append(Operation(self._commands[cmd], n)) self._pending_text = '' stripped_text = stripped_text[e:] continue else: m = self._unsupported_command.match(stripped_text) if m: self._pending_text = '' stripped_text = stripped_text[m.span()[1]:] continue elif self._pending_text in ['\x1b=', '\x1b>']: self._pending_text = '' continue # Handle Select Graphic Rendition commands # get the number str_nbr = '' numbers = [] while stripped_text: if stripped_text[0].isdigit(): str_nbr += stripped_text[0] else: if str_nbr: numbers.append(str_nbr) if not str_nbr or stripped_text[0] != self._semicolon: break str_nbr = '' self._pending_text += _mid(stripped_text, 0, 1) stripped_text = stripped_text[1:] if not stripped_text: break # remove terminating char if not stripped_text.startswith(self._color_terminator): # _logger().warn('removing %s', repr(self._pending_text + stripped_text[0])) self._pending_text = '' stripped_text = stripped_text[1:] break # got consistent control sequence, ok to clear pending text self._pending_text = '' stripped_text = stripped_text[1:] if not numbers: fmt = QtGui.QTextCharFormat(formatted_text.fmt) self.end_format_scope() i_offset = 0 n = len(numbers) for i in range(n): i += i_offset code = int(numbers[i]) if self._TextColorStart <= code <= self._TextColorEnd: fmt.setForeground(_ansi_color(code - self._TextColorStart, self.color_scheme)) self._set_format_scope(fmt) elif self._BackgroundColorStart <= code <= self._BackgroundColorEnd: fmt.setBackground(_ansi_color(code - self._BackgroundColorStart, self.color_scheme)) self._set_format_scope(fmt) else: if code == self._ResetFormat: fmt = QtGui.QTextCharFormat(formatted_text.fmt) self.end_format_scope() elif code == self._BoldText: fmt.setFontWeight(QtGui.QFont.Bold) self._set_format_scope(fmt) elif code == self._NotBold: fmt.setFontWeight(QtGui.QFont.Normal) self._set_format_scope(fmt) elif code == self._ItalicText: fmt.setFontItalic(True) self._set_format_scope(fmt) elif code == self._NotItalicNotFraktur: fmt.setFontItalic(False) self._set_format_scope(fmt) elif code == self._UnderlinedText: fmt.setUnderlineStyle(fmt.SingleUnderline) fmt.setUnderlineColor(fmt.foreground().color()) self._set_format_scope(fmt) elif code == self._NotUnderlined: fmt.setUnderlineStyle(fmt.NoUnderline) self._set_format_scope(fmt) elif code == self._DefaultTextColor: fmt.setForeground(formatted_text.fmt.foreground()) self._set_format_scope(fmt) elif code == self._DefaultBackgroundColor: fmt.setBackground(formatted_text.fmt.background()) self._set_format_scope(fmt) elif code == self._Dim: fmt = QtGui.QTextCharFormat(fmt) fmt.setForeground(fmt.foreground().color().darker(self.DIM_FACTOR)) elif code == self._Negative: normal_fmt = fmt fmt = QtGui.QTextCharFormat(fmt) fmt.setForeground(normal_fmt.background()) fmt.setBackground(normal_fmt.foreground()) elif code == self._Positive: fmt = QtGui.QTextCharFormat(formatted_text.fmt) elif code in [self._RgbBackgroundColor, self._RgbTextColor]: # See http://en.wikipedia.org/wiki/ANSI_escape_code#Colors i += 1 if i == n: break next_code = int(numbers[i]) if next_code == 2: # RGB set with format: 38;2;<r>;<g>;<b> if i + 3 < n: method = fmt.setForeground if code == self._RgbTextColor else fmt.setBackground method(QtGui.QColor(int(numbers[i + 1]), int(numbers[i + 2]), int(numbers[i + 3]))) self._set_format_scope(fmt) i_offset = 3 elif next_code == 5: # 256 color mode with format: 38;5;<i> index = int(numbers[i + 1]) if index < 8: # The first 8 colors are standard low-intensity ANSI colors. color = _ansi_color(index, self.color_scheme) elif index < 16: # The next 8 colors are standard high-intensity ANSI colors. color = _ansi_color(index - 8, self.color_scheme).lighter(150) elif index < 232: # The next 216 colors are a 6x6x6 RGB cube. o = index - 16 color = QtGui.QColor((o / 36) * 51, ((o / 6) % 6) * 51, (o % 6) * 51) else: # The last 24 colors are a greyscale gradient. grey = (index - 232) * 11 color = QtGui.QColor(grey, grey, grey) if code == self._RgbTextColor: fmt.setForeground(color) else: fmt.setBackground(color) self._set_format_scope(fmt) else: _logger().warn('unsupported SGR code: %r', code) return ret_val
0.002008
def _install_directory_structure_file(cls): """ Download the latest version of `dir_structure_production.json`. """ # We initiate the link to the public suffix configuration. # It is not hard coded because this method is called only if we # are sure that the configuration file exist. dir_structure_link = PyFunceble.CONFIGURATION["links"]["dir_structure"] # We update the link according to our current version. dir_structure_link = Version(True).right_url_from_version(dir_structure_link) # We set the destination of the downloaded file. destination = ( PyFunceble.CURRENT_DIRECTORY + PyFunceble.CONFIGURATION["outputs"]["default_files"]["dir_structure"] ) if not Version(True).is_cloned() or not PyFunceble.path.isfile(destination): # The current version is not the cloned version. # We Download the link content and return the download status. data = Download(dir_structure_link, destination, return_data=True).text() File(destination).write(data, overwrite=True) return True # We are in the cloned version. # We do not need to download the file, so we are returning None. return None
0.004591
def show(self, m_a): """ Display (with a pretty print) this object :param m_a: :class:`MethodAnalysis` object """ bytecode.PrettyShow(m_a, m_a.basic_blocks.gets(), self.notes) bytecode.PrettyShowEx(m_a.exceptions.gets())
0.00722
def parse_string_factory( alg, sep, splitter, input_transform, component_transform, final_transform ): """ Create a function that will split and format a *str* into a tuple. Parameters ---------- alg : ns enum Indicate how to format and split the *str*. sep : str The string character to be inserted between adjacent numeric objects in the returned tuple. splitter : callable A function the will accept a string and returns an iterable of strings where the numbers are separated from the non-numbers. input_transform : callable A function to apply to the string input *before* applying the *splitter* function. Must return a string. component_transform : callable A function that is operated elementwise on the output of *splitter*. It must accept a single string and return either a string or a number. final_transform : callable A function to operate on the return value as a whole. It must accept a tuple and a string argument - the tuple should be the result of applying the above functions, and the string is the original input value. It must return a tuple. Returns ------- func : callable A function that accepts string input and returns a tuple containing the string split into numeric and non-numeric components, where the numeric components are converted into numeric objects. The first element is *always* a string, and then alternates number then string. Intended to be used as the *string_func* argument to *natsort_key*. See Also -------- natsort_key input_string_transform_factory string_component_transform_factory final_data_transform_factory """ # Sometimes we store the "original" input before transformation, # sometimes after. orig_after_xfrm = not (alg & NS_DUMB and alg & ns.LOCALEALPHA) original_func = input_transform if orig_after_xfrm else _no_op normalize_input = _normalize_input_factory(alg) def func(x): # Apply string input transformation function and return to x. # Original function is usually a no-op, but some algorithms require it # to also be the transformation function. x = normalize_input(x) x, original = input_transform(x), original_func(x) x = splitter(x) # Split string into components. x = py23_filter(None, x) # Remove empty strings. x = py23_map(component_transform, x) # Apply transform on components. x = sep_inserter(x, sep) # Insert '' between numbers. return final_transform(x, original) # Apply the final transform. return func
0.000364
def connect(self): """connect to the database **Return:** - ``dbConn`` -- the database connection See the class docstring for usage """ self.log.debug('starting the ``get`` method') dbSettings = self.dbSettings port = False if "tunnel" in dbSettings and dbSettings["tunnel"]: port = self._setup_tunnel( tunnelParameters=dbSettings["tunnel"] ) # SETUP A DATABASE CONNECTION host = dbSettings["host"] user = dbSettings["user"] passwd = dbSettings["password"] dbName = dbSettings["db"] dbConn = ms.connect( host=host, user=user, passwd=passwd, db=dbName, port=port, use_unicode=True, charset='utf8', local_infile=1, client_flag=ms.constants.CLIENT.MULTI_STATEMENTS, connect_timeout=36000, max_allowed_packet=51200000 ) if self.autocommit: dbConn.autocommit(True) self.log.debug('completed the ``get`` method') return dbConn
0.001715
def _MaybePurgeOrphanedData(self, event): """Maybe purge orphaned data due to a TensorFlow crash. When TensorFlow crashes at step T+O and restarts at step T, any events written after step T are now "orphaned" and will be at best misleading if they are included in TensorBoard. This logic attempts to determine if there is orphaned data, and purge it if it is found. Args: event: The event to use as a reference, to determine if a purge is needed. """ if not self.purge_orphaned_data: return ## Check if the event happened after a crash, and purge expired tags. if self.file_version and self.file_version >= 2: ## If the file_version is recent enough, use the SessionLog enum ## to check for restarts. self._CheckForRestartAndMaybePurge(event) else: ## If there is no file version, default to old logic of checking for ## out of order steps. self._CheckForOutOfOrderStepAndMaybePurge(event)
0.01417
def _render_our_module_flags(self, module, output_lines, prefix=''): """Returns a help string for a given module.""" flags = self._get_flags_defined_by_module(module) if flags: self._render_module_flags(module, flags, output_lines, prefix)
0.007782