text
stringlengths
78
104k
score
float64
0
0.18
def _child_allowed(self, child_rule): """Called to verify that the given rule can become a child of the current node. :raises AttributeError: if the child is not allowed """ num_kids = self.node.children.count() num_kids_allowed = len(self.rule.children) if not self.rule.multiple_paths: num_kids_allowed = 1 if num_kids >= num_kids_allowed: raise AttributeError('Rule %s only allows %s children' % ( self.rule_name, self.num_kids_allowed)) # verify not a duplicate for node in self.node.children.all(): if node.data.rule_label == child_rule.class_label: raise AttributeError('Child rule already exists') # check if the given rule is allowed as a child if child_rule not in self.rule.children: raise AttributeError('Rule %s is not a valid child of Rule %s' % ( child_rule.__name__, self.rule_name))
0.003964
def scan(self, ids=range(254)): """ Pings all ids within the specified list, by default it finds all the motors connected to the bus. """ return [id for id in ids if self.ping(id)]
0.015306
def close_thread_handles(self): """ Closes all open handles to threads in the snapshot. """ for aThread in self.iter_threads(): try: aThread.close_handle() except Exception: try: e = sys.exc_info()[1] msg = "Cannot close thread handle %s, reason: %s" msg %= (aThread.hThread.value, str(e)) warnings.warn(msg) except Exception: pass
0.003738
def apply_types(use_types, guess_type, line): """Apply the types on the elements of the line""" new_line = {} for k, v in line.items(): if use_types.has_key(k): new_line[k] = force_type(use_types[k], v) elif guess_type: new_line[k] = determine_type(v) else: new_line[k] = v return new_line
0.005479
def json_export(self, dest, fieldnames=None, encoding="UTF-8"): """Exports the contents of the table to a JSON-formatted file. @param dest: output file - if a string is given, the file with that name will be opened, written, and closed; if a file object is given, then that object will be written as-is, and left for the caller to be closed. @type dest: string or file @param fieldnames: attribute names to be exported; can be given as a single string with space-delimited names, or as a list of attribute names @type fieldnames: list of strings @param encoding: string (default="UTF-8"); if csv_dest is provided as a string representing an output filename, an encoding argument can be provided (Python 3 only) @type encoding: string """ close_on_exit = False if isinstance(dest, basestring): if PY_3: dest = open(dest, 'w', encoding=encoding) else: dest = open(dest, 'w') close_on_exit = True try: if isinstance(fieldnames, basestring): fieldnames = fieldnames.split() if fieldnames is None: do_all(dest.write(_to_json(o)+'\n') for o in self.obs) else: do_all(dest.write(json.dumps(ODict((f, getattr(o, f)) for f in fieldnames))+'\n') for o in self.obs) finally: if close_on_exit: dest.close()
0.007092
def pop_empty_columns(self, empty=None): """ This will pop columns from the printed columns if they only contain '' or None :param empty: list of values to treat as empty """ empty = ['', None] if empty is None else empty if len(self) == 0: return for col in list(self.columns): if self[0][col] in empty: if not [v for v in self.get_column(col) if v not in empty]: self.pop_column(col)
0.003868
def migrate_keys(self, host, port, keys, dest_db, timeout, *, copy=False, replace=False): """Atomically transfer keys from one Redis instance to another one. Keys argument must be list/tuple of keys to migrate. """ if not isinstance(host, str): raise TypeError("host argument must be str") if not isinstance(timeout, int): raise TypeError("timeout argument must be int") if not isinstance(dest_db, int): raise TypeError("dest_db argument must be int") if not isinstance(keys, (list, tuple)): raise TypeError("keys argument must be list or tuple") if not host: raise ValueError("Got empty host") if dest_db < 0: raise ValueError("dest_db must be greater equal 0") if timeout < 0: raise ValueError("timeout must be greater equal 0") if not keys: raise ValueError("keys must not be empty") flags = [] if copy: flags.append(b'COPY') if replace: flags.append(b'REPLACE') flags.append(b'KEYS') flags.extend(keys) fut = self.execute(b'MIGRATE', host, port, "", dest_db, timeout, *flags) return wait_ok(fut)
0.002285
def uncrop(data, crinfo, orig_shape, resize=False, outside_mode="constant", cval=0): """ Put some boundary to input image. :param data: input data :param crinfo: array with minimum and maximum index along each axis [[minX, maxX],[minY, maxY],[minZ, maxZ]]. If crinfo is None, the whole input image is placed into [0, 0, 0]. If crinfo is just series of three numbers, it is used as an initial point for input image placement. :param orig_shape: shape of uncropped image :param resize: True or False (default). Usefull if the data.shape does not fit to crinfo shape. :param outside_mode: 'constant', 'nearest' :return: """ if crinfo is None: crinfo = list(zip([0] * data.ndim, orig_shape)) elif np.asarray(crinfo).size == data.ndim: crinfo = list(zip(crinfo, np.asarray(crinfo) + data.shape)) crinfo = fix_crinfo(crinfo) data_out = np.ones(orig_shape, dtype=data.dtype) * cval # print 'uncrop ', crinfo # print orig_shape # print data.shape if resize: data = resize_to_shape(data, crinfo[:, 1] - crinfo[:, 0]) startx = np.round(crinfo[0][0]).astype(int) starty = np.round(crinfo[1][0]).astype(int) startz = np.round(crinfo[2][0]).astype(int) data_out[ # np.round(crinfo[0][0]).astype(int):np.round(crinfo[0][1]).astype(int)+1, # np.round(crinfo[1][0]).astype(int):np.round(crinfo[1][1]).astype(int)+1, # np.round(crinfo[2][0]).astype(int):np.round(crinfo[2][1]).astype(int)+1 startx : startx + data.shape[0], starty : starty + data.shape[1], startz : startz + data.shape[2], ] = data if outside_mode == "nearest": # for ax in range(data.ndims): # ax = 0 # copy border slice to pixels out of boundary - the higher part for ax in range(data.ndim): # the part under the crop start = np.round(crinfo[ax][0]).astype(int) slices = [slice(None), slice(None), slice(None)] slices[ax] = start repeated_slice = np.expand_dims(data_out[slices], ax) append_sz = start if append_sz > 0: tile0 = np.repeat(repeated_slice, append_sz, axis=ax) slices = [slice(None), slice(None), slice(None)] slices[ax] = slice(None, start) # data_out[start + data.shape[ax] : , :, :] = tile0 data_out[slices] = tile0 # plt.imshow(np.squeeze(repeated_slice)) # plt.show() # the part over the crop start = np.round(crinfo[ax][0]).astype(int) slices = [slice(None), slice(None), slice(None)] slices[ax] = start + data.shape[ax] - 1 repeated_slice = np.expand_dims(data_out[slices], ax) append_sz = data_out.shape[ax] - (start + data.shape[ax]) if append_sz > 0: tile0 = np.repeat(repeated_slice, append_sz, axis=ax) slices = [slice(None), slice(None), slice(None)] slices[ax] = slice(start + data.shape[ax], None) # data_out[start + data.shape[ax] : , :, :] = tile0 data_out[slices] = tile0 # plt.imshow(np.squeeze(repeated_slice)) # plt.show() return data_out
0.002393
def OnMouseWheel(self, event): """Event handler for mouse wheel actions Invokes zoom when mouse when Ctrl is also pressed """ if event.ControlDown(): if event.WheelRotation > 0: post_command_event(self.grid, self.grid.ZoomInMsg) else: post_command_event(self.grid, self.grid.ZoomOutMsg) elif self.main_window.IsFullScreen(): if event.WheelRotation > 0: newtable = self.grid.current_table - 1 else: newtable = self.grid.current_table + 1 post_command_event(self.grid, self.GridActionTableSwitchMsg, newtable=newtable) return else: wheel_speed = config["mouse_wheel_speed_factor"] x, y = self.grid.GetViewStart() direction = wheel_speed if event.GetWheelRotation() < 0 \ else -wheel_speed if event.ShiftDown(): # Scroll sideways if shift is pressed. self.grid.Scroll(x + direction, y) else: self.grid.Scroll(x, y + direction)
0.001712
def __lstring(self,lstr): """ Returns a parsed lstring by stripping out and instances of the escaped delimiter. Sometimes the raw lstring has whitespace and a double quote at the beginning or end. If present, these are removed. """ lstr = self.llsrx.sub('',lstr.encode('ascii')) lstr = self.rlsrx.sub('',lstr) lstr = self.xmltostr.xlat(lstr) lstr = self.dlmrx.sub(',',lstr) return lstr
0.011655
def save_post(self, title, text, user_id, tags, draft=False, post_date=None, last_modified_date=None, meta_data=None, post_id=None): """ Persist the blog post data. If ``post_id`` is ``None`` or ``post_id`` is invalid, the post must be inserted into the storage. If ``post_id`` is a valid id, then the data must be updated. :param title: The title of the blog post :type title: str :param text: The text of the blog post :type text: str :param user_id: The user identifier :type user_id: str :param tags: A list of tags :type tags: list :param draft: (Optional) If the post is a draft of if needs to be published. (default ``False``) :type draft: bool :param post_date: (Optional) The date the blog was posted (default datetime.datetime.utcnow() ) :type post_date: datetime.datetime :param last_modified_date: (Optional) The date when blog was last modified (default datetime.datetime.utcnow() ) :type last_modified_date: datetime.datetime :param post_id: (Optional) The post identifier. This should be ``None`` for an insert call, and a valid value for update. (default ``None``) :type post_id: str :return: The post_id value, in case of a successful insert or update. Return ``None`` if there were errors. """ new_post = post_id is None post_id = _as_int(post_id) current_datetime = datetime.datetime.utcnow() draft = 1 if draft is True else 0 post_date = post_date if post_date is not None else current_datetime last_modified_date = last_modified_date if last_modified_date is not \ None else current_datetime with self._engine.begin() as conn: try: if post_id is not None: # validate post_id exists_statement = sqla.select([self._post_table]).where( self._post_table.c.id == post_id) exists = \ conn.execute(exists_statement).fetchone() is not None post_id = post_id if exists else None post_statement = \ self._post_table.insert() if post_id is None else \ self._post_table.update().where( self._post_table.c.id == post_id) post_statement = post_statement.values( title=title, text=text, post_date=post_date, last_modified_date=last_modified_date, draft=draft ) post_result = conn.execute(post_statement) post_id = post_result.inserted_primary_key[0] \ if post_id is None else post_id self._save_tags(tags, post_id, conn) self._save_user_post(user_id, post_id, conn) except Exception as e: self._logger.exception(str(e)) post_id = None return post_id
0.001282
def poke_16(library, session, address, data): """Write an 16-bit value from the specified address. Corresponds to viPoke16 function of the VISA library. :param library: the visa library wrapped by ctypes. :param session: Unique logical identifier to a session. :param address: Source address to read the value. :param data: value to be written to the bus. :return: return value of the library call. :rtype: :class:`pyvisa.constants.StatusCode` """ return library.viPoke16(session, address, data)
0.001862
def create_modules_toc_file(master_package, modules, opts, name='modules'): """ Create the module's index. """ text = format_heading(1, '%s Modules' % opts.header) text += '.. toctree::\n' text += ' :maxdepth: %s\n\n' % opts.maxdepth modules.sort() prev_module = '' for module in modules: # look if the module is a subpackage and, if yes, ignore it if module.startswith(prev_module + '.'): continue prev_module = module text += ' %s\n' % module write_file(name, text, opts)
0.001776
def urlencode_utf8(params): """ UTF-8 safe variant of urllib.urlencode. http://stackoverflow.com/a/8152242 """ if hasattr(params, 'items'): params = params.items() params = ( '='.join(( quote_plus(k.encode('utf8'), safe='/'), quote_plus(v.encode('utf8'), safe='/') )) for k, v in params ) return '&'.join(params)
0.002551
def _add_sample_measure(self, measure_params, num_samples): """Generate memory samples from current statevector. Args: measure_params (list): List of (qubit, cmembit) values for measure instructions to sample. num_samples (int): The number of memory samples to generate. Returns: list: A list of memory values in hex format. """ # Get unique qubits that are actually measured measured_qubits = list({qubit for qubit, cmembit in measure_params}) num_measured = len(measured_qubits) # Axis for numpy.sum to compute probabilities axis = list(range(self._number_of_qubits)) for qubit in reversed(measured_qubits): # Remove from largest qubit to smallest so list position is correct # with respect to position from end of the list axis.remove(self._number_of_qubits - 1 - qubit) probabilities = np.reshape(np.sum(np.abs(self._statevector) ** 2, axis=tuple(axis)), 2 ** num_measured) # Generate samples on measured qubits samples = self._local_random.choice(range(2 ** num_measured), num_samples, p=probabilities) # Convert to bit-strings memory = [] for sample in samples: classical_memory = self._classical_memory for count, (qubit, cmembit) in enumerate(sorted(measure_params)): qubit_outcome = int((sample & (1 << count)) >> count) membit = 1 << cmembit classical_memory = (classical_memory & (~membit)) | (qubit_outcome << cmembit) value = bin(classical_memory)[2:] memory.append(hex(int(value, 2))) return memory
0.001601
def scan_line(self, line, regex): """Checks if regex is in line, returns bool""" return bool(re.search(regex, line, flags=re.IGNORECASE))
0.013072
def _pre_heat_deploy(self): """Setup before the Heat stack create or update has been done.""" clients = self.app.client_manager compute_client = clients.compute self.log.debug("Checking hypervisor stats") if utils.check_hypervisor_stats(compute_client) is None: raise exceptions.DeploymentError( "Expected hypervisor stats not met") return True
0.004751
def fit_transform(self, data): """ Fits and transforms the SFrame `data` using a fitted model. Parameters ---------- data : SFrame The data to be transformed. Returns ------- A transformed SFrame. Returns ------- out: SFrame A transformed SFrame. See Also -------- fit, transform """ self._setup_from_data(data) ret = self.transform_chain.fit_transform(data) self.__proxy__.update({"fitted" : True}) return ret
0.005068
def ssn(self, min_age=18, max_age=90): """ Returns a 10 digit Swedish SSN, "Personnummer". It consists of 10 digits in the form YYMMDD-SSGQ, where YYMMDD is the date of birth, SSS is a serial number and Q is a control character (Luhn checksum). http://en.wikipedia.org/wiki/Personal_identity_number_(Sweden) """ def _luhn_checksum(number): def digits_of(n): return [int(d) for d in str(n)] digits = digits_of(number) odd_digits = digits[-1::-2] even_digits = digits[-2::-2] checksum = 0 checksum += sum(odd_digits) for d in even_digits: checksum += sum(digits_of(d * 2)) return checksum % 10 def _calculate_luhn(partial_number): check_digit = _luhn_checksum(int(partial_number) * 10) return check_digit if check_digit == 0 else 10 - check_digit age = datetime.timedelta( days=self.generator.random.randrange(min_age * 365, max_age * 365)) birthday = datetime.datetime.now() - age pnr_date = birthday.strftime('%y%m%d') suffix = str(self.generator.random.randrange(0, 999)).zfill(3) luhn_checksum = str(_calculate_luhn(pnr_date + suffix)) pnr = '{0}-{1}{2}'.format(pnr_date, suffix, luhn_checksum) return pnr
0.001425
def store(self, t, step): """ Record the state/algeb values at time t to self.vars """ max_cache = int(self.system.tds.config.max_cache) if len(self.vars) >= max_cache > 0: self.dump() self.vars = list() self.t = list() self.k = list() logger.debug( 'varout cache cleared at simulation t = {:g}.'.format( self.system.dae.t)) self._mode = 'a' var_data = matrix([self.system.dae.x, self.system.dae.y]) # ===== This code block is deprecated ===== self.t.append(t) self.k.append(step) self.vars.append(var_data) # ========================================= # clear data cache if written to disk if self.np_nrows >= max_cache > 0: self.dump_np_vars() self.np_vars = np.zeros(self._np_block_shape) self.np_nrows = 0 self.np_t = np.zeros((self._np_block_rows,)) self.np_k = np.zeros((self._np_block_rows,)) logger.debug( 'np_vars cache cleared at simulation t = {:g}.'.format( self.system.dae.t)) self._mode = 'a' # initialize before first-time adding data if self.np_nrows == 0: self.np_ncols = len(var_data) self._np_block_shape = (self._np_block_rows, self.np_ncols) self.np_vars = np.zeros(self._np_block_shape) self.np_t = np.zeros((self._np_block_rows,)) self.np_k = np.zeros((self._np_block_rows,)) # adding data to the matrix # self.np_vars[self.np_nrows, 0] = t self.np_t[self.np_nrows] = t self.np_k[self.np_nrows] = step self.np_vars[self.np_nrows, :] = np.array(var_data).reshape((-1)) self.np_nrows += 1 # check if matrix extension is needed if self.np_nrows >= self.np_vars.shape[0]: self.np_vars = np.concatenate([self.np_vars, np.zeros(self._np_block_shape)], axis=0) self.np_t = np.concatenate([self.np_t, np.zeros((self._np_block_rows,))], axis=0) self.np_k = np.concatenate([self.np_k, np.zeros((self._np_block_rows,))], axis=0) # remove the post-computed variables from the variable list if self.system.tds.config.compute_flows: self.system.dae.y = self.system.dae.y[:self.system.dae.m]
0.002048
def archive_context(filename): """ Unzip filename to a temporary directory, set to the cwd. The unzipped target is cleaned up after. """ tmpdir = tempfile.mkdtemp() log.warn('Extracting in %s', tmpdir) old_wd = os.getcwd() try: os.chdir(tmpdir) try: with ContextualZipFile(filename) as archive: archive.extractall() except zipfile.BadZipfile as err: if not err.args: err.args = ('', ) err.args = err.args + ( MEANINGFUL_INVALID_ZIP_ERR_MSG.format(filename), ) raise # going in the directory subdir = os.path.join(tmpdir, os.listdir(tmpdir)[0]) os.chdir(subdir) log.warn('Now working in %s', subdir) yield finally: os.chdir(old_wd) shutil.rmtree(tmpdir)
0.001138
def calc_constitutive_matrix(self): """Calculates the laminate constitutive matrix This is the commonly called ``ABD`` matrix with ``shape=(6, 6)`` when the classical laminated plate theory is used, or the ``ABDE`` matrix when the first-order shear deformation theory is used, containing the transverse shear terms. """ self.A_general = np.zeros([5,5], dtype=np.float64) self.B_general = np.zeros([5,5], dtype=np.float64) self.D_general = np.zeros([5,5], dtype=np.float64) lam_thick = sum([ply.h for ply in self.plies]) self.h = lam_thick h0 = -lam_thick/2 + self.offset for ply in self.plies: hk_1 = h0 h0 += ply.h hk = h0 self.A_general += ply.QL*(hk - hk_1) self.B_general += 1/2.*ply.QL*(hk**2 - hk_1**2) self.D_general += 1/3.*ply.QL*(hk**3 - hk_1**3) self.A = self.A_general[0:3, 0:3] self.B = self.B_general[0:3, 0:3] self.D = self.D_general[0:3, 0:3] self.E = self.A_general[3:5, 3:5] conc1 = np.concatenate([self.A, self.B], axis=1) conc2 = np.concatenate([self.B, self.D], axis=1) self.ABD = np.concatenate([conc1, conc2], axis=0) self.ABDE = np.zeros((8, 8), dtype=np.float64) self.ABDE[0:6, 0:6] = self.ABD self.ABDE[6:8, 6:8] = self.E
0.003546
def in_region(rname, rstart, target_chr, target_start, target_end): """ Quick check if a point is within the target region. """ return (rname == target_chr) and \ (target_start <= rstart <= target_end)
0.004386
def collect_population_best(self, best_chromosome, best_fitness_function): """! @brief Stores the best chromosome for current specific iteration and its fitness function's value. @param[in] best_chromosome (list): The best chromosome on specific iteration. @param[in] best_fitness_function (float): Fitness function value of the chromosome. """ if not self._need_population_best: return self._best_population_result['chromosome'].append(best_chromosome) self._best_population_result['fitness_function'].append(best_fitness_function)
0.012739
def handle(self, *args, **options): """ get all the triggers that need to be handled """ from django.db import connection connection.close() failed_tries = settings.DJANGO_TH.get('failed_tries', 10) trigger = TriggerService.objects.filter( Q(provider_failed__lte=failed_tries) | Q(consumer_failed__lte=failed_tries), status=True, user__is_active=True, provider__name__status=True, consumer__name__status=True, ).select_related('consumer__name', 'provider__name') try: with Pool(processes=settings.DJANGO_TH.get('processes')) as pool: p = Pub() result = pool.map_async(p.publishing, trigger) result.get(timeout=60) except TimeoutError as e: logger.warning(e)
0.00226
def K(self): """Kernel matrix Returns ------- K : array-like, shape=[n_samples, n_samples] kernel matrix defined as the adjacency matrix with ones down the diagonal """ try: return self._kernel except AttributeError: self._kernel = self._build_kernel() return self._kernel
0.005141
def from_jd(jd): '''Return Gregorian date in a (Y, M, D) tuple''' wjd = floor(jd - 0.5) + 0.5 depoch = wjd - EPOCH quadricent = floor(depoch / INTERCALATION_CYCLE_DAYS) dqc = depoch % INTERCALATION_CYCLE_DAYS cent = floor(dqc / LEAP_SUPPRESSION_DAYS) dcent = dqc % LEAP_SUPPRESSION_DAYS quad = floor(dcent / LEAP_CYCLE_DAYS) dquad = dcent % LEAP_CYCLE_DAYS yindex = floor(dquad / YEAR_DAYS) year = ( quadricent * INTERCALATION_CYCLE_YEARS + cent * LEAP_SUPPRESSION_YEARS + quad * LEAP_CYCLE_YEARS + yindex ) if not (cent == 4 or yindex == 4): year += 1 yearday = wjd - to_jd(year, 1, 1) leap = isleap(year) if yearday < 58 + leap: leap_adj = 0 elif leap: leap_adj = 1 else: leap_adj = 2 month = floor((((yearday + leap_adj) * 12) + 373) / 367) day = int(wjd - to_jd(year, month, 1)) + 1 return (year, month, day)
0.00104
def from_jd(jd): '''Calculate Indian Civil date from Julian day Offset in years from Saka era to Gregorian epoch''' start = 80 # Day offset between Saka and Gregorian jd = trunc(jd) + 0.5 greg = gregorian.from_jd(jd) # Gregorian date for Julian day leap = isleap(greg[0]) # Is this a leap year? # Tentative year in Saka era year = greg[0] - SAKA_EPOCH # JD at start of Gregorian year greg0 = gregorian.to_jd(greg[0], 1, 1) yday = jd - greg0 # Day number (0 based) in Gregorian year if leap: Caitra = 31 # Days in Caitra this year else: Caitra = 30 if yday < start: # Day is at the end of the preceding Saka year year -= 1 yday += Caitra + (31 * 5) + (30 * 3) + 10 + start yday -= start if yday < Caitra: month = 1 day = yday + 1 else: mday = yday - Caitra if (mday < (31 * 5)): month = trunc(mday / 31) + 2 day = (mday % 31) + 1 else: mday -= 31 * 5 month = trunc(mday / 30) + 7 day = (mday % 30) + 1 return (year, month, int(day))
0.000864
def get_event_attendees(self, id, **data): """ GET /events/:id/attendees/ Returns a :ref:`paginated <pagination>` response with a key of ``attendees``, containing a list of :format:`attendee`. """ return self.get("/events/{0}/attendees/".format(id), data=data)
0.012945
def _load_text(handle, split=False, encoding="utf-8"): """Load and decode a string.""" string = handle.read().decode(encoding) return string.splitlines() if split else string
0.005376
def add(self, date_range, library_name): """ Adds the library with the given date range to the underlying collection of libraries used by this store. The underlying libraries should not overlap as the date ranges are assumed to be CLOSED_CLOSED by this function and the rest of the class. Arguments: date_range: A date range provided on the assumption that it is CLOSED_CLOSED. If for example the underlying libraries were split by year, the start of the date range would be datetime.datetime(year, 1, 1) and the end would be datetime.datetime(year, 12, 31, 23, 59, 59, 999000). The date range must fall on UTC day boundaries, that is the start must be add midnight and the end must be 1 millisecond before midnight. library_name: The name of the underlying library. This must be the name of a valid Arctic library """ # check that the library is valid try: self._arctic_lib.arctic[library_name] except Exception as e: logger.error("Could not load library") raise e assert date_range.start and date_range.end, "Date range should have start and end properties {}".format(date_range) start = date_range.start.astimezone(mktz('UTC')) if date_range.start.tzinfo is not None else date_range.start.replace(tzinfo=mktz('UTC')) end = date_range.end.astimezone(mktz('UTC')) if date_range.end.tzinfo is not None else date_range.end.replace(tzinfo=mktz('UTC')) assert start.time() == time.min and end.time() == end_time_min, "Date range should fall on UTC day boundaries {}".format(date_range) # check that the date range does not overlap library_metadata = self._get_library_metadata(date_range) if len(library_metadata) > 1 or (len(library_metadata) == 1 and library_metadata[0] != library_name): raise OverlappingDataException("""There are libraries that overlap with the date range: library: {} overlapping libraries: {}""".format(library_name, [l.library for l in library_metadata])) self._collection.update_one({'library_name': library_name}, {'$set': {'start': start, 'end': end}}, upsert=True)
0.007989
def setModelData( self, editor, model, index ): """ Sets the data for the given index from the editor's value. :param editor | <QWidget> model | <QAbstractItemModel> index | <QModelIndex> """ tree = self.parent() querywidget = tree.parent() factory = querywidget.factory() item = tree.itemFromIndex(index) value = factory.editorData(editor) item.setValue(value)
0.016729
def add_prefix(self, prefix, flags, prf): """Add network prefix. Args: prefix (str): network prefix. flags (str): network prefix flags, please refer thread documentation for details prf (str): network prf, please refer thread documentation for details """ self._req('prefix add %s %s %s' % (prefix, flags, prf)) time.sleep(1) self._req('netdataregister')
0.009112
def pretty_print_model(devicemodel): """Prints out a device model in the terminal by parsing dict.""" PRETTY_PRINT_MODEL = """Device Model ID: %(deviceModelId)s Project ID: %(projectId)s Device Type: %(deviceType)s""" logging.info(PRETTY_PRINT_MODEL % devicemodel) if 'traits' in devicemodel: for trait in devicemodel['traits']: logging.info(' Trait %s' % trait) else: logging.info('No traits') logging.info('')
0.002058
def is_scn(self): """Page contains Leica SCN XML in ImageDescription tag.""" if self.index > 1 or not self.description: return False d = self.description return d[:14] == '<?xml version=' and d[-6:] == '</scn>'
0.007874
def get_artifact(self): """Return the job artifact built by the parser.""" self.artifact[self.parser.name] = self.parser.get_artifact() return self.artifact
0.011111
def get_vars_dataframe(self, *varnames): """ Return pandas DataFrame with the value of the variables specified in `varnames`. Can be used for task/works/flow. It's recursive! .. example: flow.get_vars_dataframe("ecut", "ngkpt") work.get_vars_dataframe("acell", "usepawu") """ import pandas as pd if self.is_task: df = pd.DataFrame([{v: self.input.get(v, None) for v in varnames}], index=[self.name], columns=varnames) df["class"] = self.__class__.__name__ return df elif self.is_work: frames = [task.get_vars_dataframe(*varnames) for task in self] return pd.concat(frames) elif self.is_flow: frames = [work.get_vars_dataframe(*varnames) for work in self] return pd.concat(frames) else: #print("Ignoring node of type: `%s`" % type(self)) return pd.DataFrame(index=[self.name])
0.00504
def subtract_months(self, months: int) -> datetime: """ Subtracts a number of months from the current value """ self.value = self.value - relativedelta(months=months) return self.value
0.009615
def _init_fcp_pool(self, fcp_list, assigner_id): """The FCP infomation got from smt(zthin) looks like : host: FCP device number: xxxx host: Status: Active host: NPIV world wide port number: xxxxxxxx host: Channel path ID: xx host: Physical world wide port number: xxxxxxxx ...... host: FCP device number: xxxx host: Status: Active host: NPIV world wide port number: xxxxxxxx host: Channel path ID: xx host: Physical world wide port number: xxxxxxxx """ complete_fcp_set = self._expand_fcp_list(fcp_list) fcp_info = self._get_all_fcp_info(assigner_id) lines_per_item = 5 num_fcps = len(fcp_info) // lines_per_item for n in range(0, num_fcps): fcp_init_info = fcp_info[(5 * n):(5 * (n + 1))] fcp = FCP(fcp_init_info) dev_no = fcp.get_dev_no() if dev_no in complete_fcp_set: if fcp.is_valid(): self._fcp_pool[dev_no] = fcp else: errmsg = ("Find an invalid FCP device with properties {" "dev_no: %(dev_no)s, " "NPIV_port: %(NPIV_port)s, " "CHPID: %(CHPID)s, " "physical_port: %(physical_port)s} !") % { 'dev_no': fcp.get_dev_no(), 'NPIV_port': fcp.get_npiv_port(), 'CHPID': fcp.get_chpid(), 'physical_port': fcp.get_physical_port()} LOG.warning(errmsg) else: # normal, FCP not used by cloud connector at all msg = "Found a fcp %s not in fcp_list" % dev_no LOG.debug(msg)
0.00105
def get_column(self, position, missing_seqs=MissingSequenceHandler.SKIP): """ return a column from an alignment as a dictionary indexed by seq. name. :param position: the index to extract; these are in alignment co-ordinates, which are one-based, so the first column has index 1, and the final column has index == size(self). :param missing_seqs: how to treat sequence with no actual sequence data for the column. :return: dictionary where keys are sequence names and values are nucleotides (raw strings). """ res = {} for k in self.sequences: if isinstance(self.sequences[k], UnknownSequence): if missing_seqs is MissingSequenceHandler.TREAT_AS_ALL_GAPS: res[k] = "-" elif missing_seqs is MissingSequenceHandler.SKIP: continue else: res[k] = self.sequences[k][position - 1] return res
0.005025
def account_products(self): ''' a method to retrieve a list of the account products returns: { "error": "", "code": 200, "method": "GET", "url": "https://...", "headers": { }, "json": { "entries": [ { "productId": "3000", "productName": "Capital One 360 Savings Account" } ] } } ''' title = '%s.account_products' % self.__class__.__name__ # construct url url = self.deposits_endpoint + 'account-products' # send request details = self._requests(url) return details
0.008578
def _map_sextuple_to_phenotype( self, superterm1_id, subterm1_id, quality_id, superterm2_id, subterm2_id, modifier): """ This will take the 6-part EQ-style annotation used by ZFIN and return the ZP id. Currently relies on an external mapping file, but the method may be swapped out in the future :param superterm1_id: :param subterm1_id: :param quality_id: :param superterm2_id: :param subterm2_id: :param modifier: :return: ZP id """ zp_id = None # zfin uses free-text modifiers, # but we need to convert them to proper PATO classes for the mapping mod_id = self.resolve(modifier, False) if modifier == mod_id: LOG.warning("no mapping for pato modifier " + modifier) key = self._make_zpkey( superterm1_id, subterm1_id, quality_id, superterm2_id, subterm2_id, mod_id) mapping = self.zp_map.get(key) if mapping is None: if modifier == 'normal': pass # LOG.info("Normal phenotypes not yet supported") else: LOG.warning( "Couldn't map ZP id to %s with modifier %s", "_" .join(( superterm1_id, subterm1_id, quality_id, superterm2_id, subterm2_id, mod_id)), modifier) else: zp_id = mapping['zp_id'] return zp_id
0.00131
def refresh_client(self, from_dt=None, to_dt=None): """ Refreshes the ContactsService endpoint, ensuring that the contacts data is up-to-date. """ params_contacts = dict(self.params) params_contacts.update({ 'clientVersion': '2.1', 'locale': 'en_US', 'order': 'last,first', }) req = self.session.get( self._contacts_refresh_url, params=params_contacts ) self.response = req.json() params_refresh = dict(self.params) params_refresh.update({ 'prefToken': req.json()["prefToken"], 'syncToken': req.json()["syncToken"], }) self.session.post(self._contacts_changeset_url, params=params_refresh) req = self.session.get( self._contacts_refresh_url, params=params_contacts ) self.response = req.json()
0.002134
def noclip(args): """ %prog noclip bamfile Remove clipped reads from BAM. """ p = OptionParser(noclip.__doc__) opts, args = p.parse_args(args) if len(args) != 1: sys.exit(not p.print_help()) bamfile, = args noclipbam = bamfile.replace(".bam", ".noclip.bam") cmd = "samtools view -h {} | awk -F '\t' '($6 !~ /H|S/)'".format(bamfile) cmd += " | samtools view -@ 4 -b -o {}".format(noclipbam) sh(cmd) sh("samtools index {}".format(noclipbam))
0.001988
def sensors(self): """Return all known sensors. :return: list of :class:`Sensor` instances. """ sensors = [] try: while True: sensor = self.lib.tdSensor() sensors.append(Sensor(lib=self.lib, **sensor)) except TelldusError as e: if e.error != const.TELLSTICK_ERROR_DEVICE_NOT_FOUND: raise return sensors
0.00464
def count_reads(self, l): """ Iterate over the reads on a particular genome in the bam file. Parameters ---------- l : str A location. """ if self.__paired: cmd = [self.__samtools, 'view', '-c', '-f', '3', self.__bam, l] else: cmd = [self.__samtools, 'view', '-c', '-F', '4', self.__bam, l] #print(' '.join(cmd)) stdout = subprocess.Popen(cmd, stdout=subprocess.PIPE).stdout ret = int(stdout.readline().decode('utf-8').strip()) stdout.close() return ret
0.015528
def get_swagger_operation(self, context=default_context): """ get the swagger_schema operation representation. """ consumes = produces = context.contenttype_serializers.keys() parameters = get_swagger_parameters(self.parameters, context) responses = { "400": Response( { "description": "invalid input received", "schema": Schema( { "title": "FailureObject", "type": "object", "properties": { "success": {"type": "boolean"}, "result": {"type": "string"}, }, "required": ["success", "result"], } ), } ) } for code, details in self.response_types.items(): responses[str(code)] = details.swagger_definition(context) return Operation( { "summary": self.summary, "description": self.description, "consumes": consumes, "produces": produces, "parameters": parameters, "responses": responses, "operationId": self.raw_func.__name__, "tags": self.tags, } )
0.001371
def check_topic_model_string_format(term_dict): ''' Parameters ---------- term_dict: dict {metadataname: [term1, term2, ....], ...} Returns ------- None ''' if type(term_dict) != dict: raise TypeError("Argument for term_dict must be a dict, keyed on strings, and contain a list of strings.") for k, v in term_dict.items(): if type(v) != list: raise TypeError("Values in term dict must only be lists.") if sys.version_info[0] == 2: if type(k) != str and type(k) != unicode: raise TypeError("Keys in term dict must be of type str or unicode.") for e in v: if type(k) != str and type(k) != unicode: raise TypeError("Values in term lists must be str or unicode.") if sys.version_info[0] == 3: if type(k) != str: raise TypeError("Keys in term dict must be of type str.") for e in v: if type(e) != str: raise TypeError("Values in term lists must be str.")
0.003676
def import_object_ns(name_space, import_str, *args, **kwargs): """Tries to import object from default namespace. Imports a class and return an instance of it, first by trying to find the class in a default namespace, then failing back to a full path if not found in the default namespace. """ import_value = "%s.%s" % (name_space, import_str) try: return import_class(import_value)(*args, **kwargs) except ImportError: return import_class(import_str)(*args, **kwargs)
0.001938
def build_all(self) -> BuildProcessStats: """ Build all the targets, very high level method :return: """ stats = BuildProcessStats() for builder in self.builders: self.build_by_builder( builder=builder, stats=stats, ) return stats
0.005848
def _wait_for_files(path): """ Retry with backoff up to 1 second to delete files from a directory. :param str path: The path to crawl to delete files from :return: A list of remaining paths or None :rtype: Optional[List[str]] """ timeout = 0.001 remaining = [] while timeout < 1.0: remaining = [] if os.path.isdir(path): L = os.listdir(path) for target in L: _remaining = _wait_for_files(target) if _remaining: remaining.extend(_remaining) continue try: os.unlink(path) except FileNotFoundError as e: if e.errno == errno.ENOENT: return except (OSError, IOError, PermissionError): time.sleep(timeout) timeout *= 2 remaining.append(path) else: return return remaining
0.001075
def install(self, build_dir, install_dir=None, **kwargs): """This function builds the cmake install command.""" # pylint: disable=no-self-use del kwargs install_args = ["cmake", "--build", build_dir, "--target", "install"] install_args.extend(self._get_build_flags()) if install_dir: self._target_config.env["DESTDIR"] = install_dir return [{"args": install_args}]
0.00463
def sanitize_latex(string): """ Sanitize a string for input to LaTeX. Replacements taken from `Stack Overflow <http://stackoverflow.com/questions/2627135/how-do-i-sanitize-latex-input>`_ **Parameters** string: str **Returns** sanitized_string: str """ sanitized_string = string for old, new in _latex_replacements: sanitized_string = sanitized_string.replace(old, new) return sanitized_string
0.002208
def _read_credential_file(self, cfg): """ Implements the default (keystone) behavior. """ self.username = cfg.get("keystone", "username") self.password = cfg.get("keystone", "password", raw=True) self.tenant_id = cfg.get("keystone", "tenant_id")
0.006826
def draw_salt_bridges(self,color="blue"): """ For each bond that has been determined to be important, a line gets drawn. """ self.draw_saltbridges="" if self.saltbridges!=None: for bond in self.saltbridges.saltbridges_for_drawing: self.draw_saltbridges ="<g class='SaltBridges' transform='translate("+str((self.molecule.x_dim-self.molecule.molsize1)/2)+","+str((self.molecule.y_dim-self.molecule.molsize2)/2)+")'>'" atom = self.topology_data.universe.atoms[bond[0]-1] #zero-based index vs one-based index residue = (atom.resname, str(atom.resid), atom.segid) self.draw_saltbridges=self.draw_saltbridges+"<line x1='"+str(int(self.molecule.nearest_points_coords[residue][0]))+"' y1='"+str(int(self.molecule.nearest_points_coords[residue][1]))+"' x2='"+str(float(self.molecule.ligand_atom_coords_from_diagr[bond[1]][0]))+"' y2='"+str(float(self.molecule.ligand_atom_coords_from_diagr[bond[1]][1]))+"' style='stroke:white;stroke-width:15' />" self.draw_saltbridges=self.draw_saltbridges+"<line x1='"+str(int(self.molecule.nearest_points_coords[residue][0]))+"' y1='"+str(int(self.molecule.nearest_points_coords[residue][1]))+"' x2='"+str(float(self.molecule.ligand_atom_coords_from_diagr[bond[1]][0]))+"' y2='"+str(float(self.molecule.ligand_atom_coords_from_diagr[bond[1]][1]))+"' style='stroke:"+color+";stroke-width:4' />" self.draw_saltbridges= self.draw_saltbridges+"</g>"
0.019858
def Run(self, arg): """Returns the client stats.""" if arg is None: arg = rdf_client_action.GetClientStatsRequest() proc = psutil.Process(os.getpid()) meminfo = proc.memory_info() boot_time = rdfvalue.RDFDatetime.FromSecondsSinceEpoch(psutil.boot_time()) create_time = rdfvalue.RDFDatetime.FromSecondsSinceEpoch(proc.create_time()) stats_collector = stats_collector_instance.Get() response = rdf_client_stats.ClientStats( RSS_size=meminfo.rss, VMS_size=meminfo.vms, memory_percent=proc.memory_percent(), bytes_received=stats_collector.GetMetricValue( "grr_client_received_bytes"), bytes_sent=stats_collector.GetMetricValue("grr_client_sent_bytes"), create_time=create_time, boot_time=boot_time) response.cpu_samples = self.grr_worker.stats_collector.CpuSamplesBetween( start_time=arg.start_time, end_time=arg.end_time) response.io_samples = self.grr_worker.stats_collector.IOSamplesBetween( start_time=arg.start_time, end_time=arg.end_time) self.Send(response)
0.002735
def follow(self, delay=1.0): """\ Iterator generator that returns lines as data is added to the file. Based on: http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/157035 """ # TODO: Handle log file rotation self.trailing = True unchanged_stats = 0 while not self.should_stop_follow: where = self.file.tell() line = self.file.readline() if line: if self.trailing and line in self.line_terminators: # This is just the line terminator added to the end of the file # before a new line, ignore. self.trailing = False continue if line[-1] in self.line_terminators: line = line[:-1] if line[-1:] == '\r\n' and '\r\n' in self.line_terminators: # found crlf line = line[:-1] self.trailing = False unchanged_stats = 0 yield line else: self.trailing = True self.seek(where) yield no_new_line # Try to catch up rotated log file unchanged_stats += 1 if unchanged_stats >= self.MAX_UNCHANGED_STATS and \ where != os.stat(self.file.name).st_size: logger.info('Reopen log file because file may has been rotated.') self.reopen_file() time.sleep(delay)
0.004397
def original_failure(self): """ Return the underlying Failure object, if the result is an error. If no result is yet available, or the result was not an error, None is returned. This method is useful if you want to get the original traceback for an error result. """ try: result = self._result(0.0) except TimeoutError: return None if isinstance(result, Failure): return result else: return None
0.003752
def unpack(self, unpacker): """ Unpacks the constant pool from an unpacker stream """ (count, ) = unpacker.unpack_struct(_H) # first item is never present in the actual data buffer, but # the count number acts like it would be. items = [(None, None), ] count -= 1 # Long and Double const types will "consume" an item count, # but not data hackpass = False for _i in range(0, count): if hackpass: # previous item was a long or double hackpass = False items.append((None, None)) else: item = _unpack_const_item(unpacker) items.append(item) # if this item was a long or double, skip the next # counter. if item[0] in (CONST_Long, CONST_Double): hackpass = True self.consts = items
0.002081
def _prepend_name_prefix(self, name): """Return file name (ie. path) with the prefix directory prepended""" if not self.name_prefix: return name base = self.name_prefix if base[0] != '/': base = '/' + base if name[0] != '/': name = '/' + name return base + name
0.005797
def _handler_swagger_ui(self, request, spec, version): """ --- parameters: - name: spec in: query type: string - name: version in: query type: integer enum: [2,3] """ version = version or self._version_ui if self._spec_url: spec_url = self._spec_url else: spec_url = request.url.with_path(self['swagger:spec'].url()) proto = request.headers.get(hdrs.X_FORWARDED_PROTO) if proto: spec_url = spec_url.with_scheme(proto) if isinstance(spec, str): spec_url = spec_url.with_query(spec=spec) elif len(self._swagger_data) == 1: for basePath in self._swagger_data: spec_url = spec_url.with_query(spec=basePath) else: spec_url = spec_url.with_query(spec='/') spec_url = spec_url.human_repr() return web.Response( text=ui.rend_template(spec_url, prefix=self._swagger_ui, version=version), content_type='text/html')
0.001639
def main(target_device): """Creates an interactive terminal to the target via RTT. The main loop opens a connection to the JLink, and then connects to the target device. RTT is started, the number of buffers is presented, and then two worker threads are spawned: one for read, and one for write. The main loops sleeps until the JLink is either disconnected or the user hits ctrl-c. Args: target_device (string): The target CPU to connect to. Returns: Always returns ``0`` or a JLinkException. Raises: JLinkException on error. """ jlink = pylink.JLink() print("connecting to JLink...") jlink.open() print("connecting to %s..." % target_device) jlink.set_tif(pylink.enums.JLinkInterfaces.SWD) jlink.connect(target_device) print("connected, starting RTT...") jlink.rtt_start() while True: try: num_up = jlink.rtt_get_num_up_buffers() num_down = jlink.rtt_get_num_down_buffers() print("RTT started, %d up bufs, %d down bufs." % (num_up, num_down)) break except pylink.errors.JLinkRTTException: time.sleep(0.1) try: thread.start_new_thread(read_rtt, (jlink,)) thread.start_new_thread(write_rtt, (jlink,)) while jlink.connected(): time.sleep(1) print("JLink disconnected, exiting...") except KeyboardInterrupt: print("ctrl-c detected, exiting...") pass
0.001341
def write_to_ndef_service(self, data, *blocks): """Write block data to an NDEF compatible tag. This is a convinience method to write block data to a tag that has system code 0x12FC (NDEF). For other tags this method simply does nothing. The *data* to write must be a string or bytearray with length equal ``16 * len(blocks)``. All parameters following *data* are interpreted as block numbers to write. To actually pass a list of block numbers requires unpacking. The following example calls would have the same effect of writing 32 byte zeros into blocks 1 and 8.:: tag.write_to_ndef_service(32 * "\\0", 1, 8) tag.write_to_ndef_service(32 * "\\0", *list(1, 8)) Command execution errors raise :exc:`~nfc.tag.TagCommandError`. """ if self.sys == 0x12FC: sc_list = [ServiceCode(0, 0b001001)] bc_list = [BlockCode(n) for n in blocks] self.write_without_encryption(sc_list, bc_list, data)
0.001918
def get_method(name): """Return the PSD method registered with the given name. """ # find method name = _format_name(name) try: return METHODS[name] except KeyError as exc: exc.args = ("no PSD method registered with name {0!r}".format(name),) raise
0.003378
def build_environ(scope: Scope, body: bytes) -> dict: """ Builds a scope and request body into a WSGI environ object. """ environ = { "REQUEST_METHOD": scope["method"], "SCRIPT_NAME": scope.get("root_path", ""), "PATH_INFO": scope["path"], "QUERY_STRING": scope["query_string"].decode("ascii"), "SERVER_PROTOCOL": f"HTTP/{scope['http_version']}", "wsgi.version": (1, 0), "wsgi.url_scheme": scope.get("scheme", "http"), "wsgi.input": io.BytesIO(body), "wsgi.errors": sys.stdout, "wsgi.multithread": True, "wsgi.multiprocess": True, "wsgi.run_once": False, } # Get server name and port - required in WSGI, not in ASGI server = scope.get("server") or ("localhost", 80) environ["SERVER_NAME"] = server[0] environ["SERVER_PORT"] = server[1] # Get client IP address if scope.get("client"): environ["REMOTE_ADDR"] = scope["client"][0] # Go through headers and make them into environ entries for name, value in scope.get("headers", []): name = name.decode("latin1") if name == "content-length": corrected_name = "CONTENT_LENGTH" elif name == "content-type": corrected_name = "CONTENT_TYPE" else: corrected_name = f"HTTP_{name}".upper().replace("-", "_") # HTTPbis say only ASCII chars are allowed in headers, but we latin1 just in case value = value.decode("latin1") if corrected_name in environ: value = environ[corrected_name] + "," + value environ[corrected_name] = value return environ
0.001208
def _sampler_n_samples(self, n_samples): """ Return (sampler, n_samplers) tuples """ sampler_indices = self.rng_.choice(range(len(self.samplers)), size=n_samples, replace=True, p=self.weights) return [ (self.samplers[idx], freq) for idx, freq in itemfreq(sampler_indices) ]
0.004367
def train(self, data_iterator): """Train a keras model on a worker """ optimizer = get_optimizer(self.master_optimizer) self.model = model_from_yaml(self.yaml, self.custom_objects) self.model.compile(optimizer=optimizer, loss=self.master_loss, metrics=self.master_metrics) self.model.set_weights(self.parameters.value) feature_iterator, label_iterator = tee(data_iterator, 2) x_train = np.asarray([x for x, y in feature_iterator]) y_train = np.asarray([y for x, y in label_iterator]) self.model.compile(optimizer=self.master_optimizer, loss=self.master_loss, metrics=self.master_metrics) weights_before_training = self.model.get_weights() if x_train.shape[0] > self.train_config.get('batch_size'): self.model.fit(x_train, y_train, **self.train_config) weights_after_training = self.model.get_weights() deltas = subtract_params( weights_before_training, weights_after_training) yield deltas
0.001791
def get_mean_and_stddevs(self, sites, rup, dists, imt, stddev_types): """ See :meth:`superclass method <.base.GroundShakingIntensityModel.get_mean_and_stddevs>` for spec of input and result values. """ # extracting dictionary of coefficients specific to required # intensity measure type. C = self.COEFFS[imt] mean = (self._get_magnitude_scaling_term(C, rup.mag) + self._get_distance_scaling_term(C, rup.mag, dists.rrup) + self._get_style_of_faulting_term(C, rup.rake) + self._get_site_scaling_term(C, sites.vs30)) stddevs = self._get_stddevs(imt, rup.mag, len(dists.rrup), stddev_types) return mean, stddevs
0.002342
def track_download_request(download_url, download_title): """Track a download in Piwik""" from indico_piwik.plugin import PiwikPlugin if not download_url: raise ValueError("download_url can't be empty") if not download_title: raise ValueError("download_title can't be empty") request = PiwikRequest(server_url=PiwikPlugin.settings.get('server_api_url'), site_id=PiwikPlugin.settings.get('site_id_events'), api_token=PiwikPlugin.settings.get('server_token'), query_script=PiwikPlugin.track_script) action_url = quote(download_url) dt = datetime.now() request.call(idsite=request.site_id, rec=1, action_name=quote(download_title.encode('utf-8')), url=action_url, download=action_url, h=dt.hour, m=dt.minute, s=dt.second)
0.002139
def decrypt_or_cache(filename, **kwargs): """ Attempts to load a local version of decrypted secrets before making external api calls. This is useful as it allows credkeep secrets to be used offline. Options for decrypt_filename can be passed to this function. :param filename: filename of encrypted JSON file :return: Dict containing decrypted keys """ clear_fname = enc_to_clear_filename(filename) if clear_fname: return json.load(open(clear_fname)) return decrypt_file(filename, **kwargs)
0.005556
def date_created(self): """Date the Scopus record was created.""" date_created = self.xml.find('author-profile/date-created', ns) try: return (int(date_created.attrib['year']), int(date_created.attrib['month']), int(date_created.attrib['day'])) except AttributeError: # date_created is None return (None, None, None)
0.004843
def get_default_config_help(self): """ Return help text """ config_help = super(PassengerCollector, self).get_default_config_help() config_help.update({ "bin": "The path to the binary", "use_sudo": "Use sudo?", "sudo_cmd": "Path to sudo", "passenger_status_bin": "The path to the binary passenger-status", "passenger_memory_stats_bin": "The path to the binary passenger-memory-stats", }) return config_help
0.00339
def _syntax_style_changed(self): """ Set the style for the syntax highlighter. """ if self._highlighter is None: # ignore premature calls return if self.syntax_style: self._highlighter.set_style(self.syntax_style) else: self._highlighter.set_style_sheet(self.style_sheet)
0.005571
def download_supplementary_files(self, directory='series', download_sra=True, email=None, sra_kwargs=None, nproc=1): """Download supplementary data. .. warning:: Do not use parallel option (nproc > 1) in the interactive shell. For more details see `this issue <https://stackoverflow.com/questions/23641475/multiprocessing-working-in-python-but-not-in-ipython/23641560#23641560>`_ on SO. Args: directory (:obj:`str`, optional): Directory to download the data (in this directory function will create new directory with the files), by default this will be named with the series name + _Supp. download_sra (:obj:`bool`, optional): Indicates whether to download SRA raw data too. Defaults to True. email (:obj:`str`, optional): E-mail that will be provided to the Entrez. Defaults to None. sra_kwargs (:obj:`dict`, optional): Kwargs passed to the GSM.download_SRA method. Defaults to None. nproc (:obj:`int`, optional): Number of processes for SRA download (default is 1, no parallelization). Returns: :obj:`dict`: Downloaded data for each of the GSM """ if sra_kwargs is None: sra_kwargs = dict() if directory == 'series': dirpath = os.path.abspath(self.get_accession() + "_Supp") utils.mkdir_p(dirpath) else: dirpath = os.path.abspath(directory) utils.mkdir_p(dirpath) downloaded_paths = dict() if nproc == 1: # No need to parallelize, running ordinary download in loop downloaded_paths = dict() for gsm in itervalues(self.gsms): logger.info( "Downloading SRA files for %s series\n" % gsm.name) paths = gsm.download_supplementary_files(email=email, download_sra=download_sra, directory=dirpath, sra_kwargs=sra_kwargs) downloaded_paths[gsm.name] = paths elif nproc > 1: # Parallelization enabled downloaders = list() # Collecting params for Pool.map in a loop for gsm in itervalues(self.gsms): downloaders.append([ gsm, download_sra, email, dirpath, sra_kwargs]) p = Pool(nproc) results = p.map(_supplementary_files_download_worker, downloaders) downloaded_paths = dict(results) else: raise ValueError("Nproc should be non-negative: %s" % str(nproc)) return downloaded_paths
0.001987
def dhcp_configuration_from_querystring(querystring, option=u'DhcpConfiguration'): """ turn: {u'AWSAccessKeyId': [u'the_key'], u'Action': [u'CreateDhcpOptions'], u'DhcpConfiguration.1.Key': [u'domain-name'], u'DhcpConfiguration.1.Value.1': [u'example.com'], u'DhcpConfiguration.2.Key': [u'domain-name-servers'], u'DhcpConfiguration.2.Value.1': [u'10.0.0.6'], u'DhcpConfiguration.2.Value.2': [u'10.0.0.7'], u'Signature': [u'uUMHYOoLM6r+sT4fhYjdNT6MHw22Wj1mafUpe0P0bY4='], u'SignatureMethod': [u'HmacSHA256'], u'SignatureVersion': [u'2'], u'Timestamp': [u'2014-03-18T21:54:01Z'], u'Version': [u'2013-10-15']} into: {u'domain-name': [u'example.com'], u'domain-name-servers': [u'10.0.0.6', u'10.0.0.7']} """ key_needle = re.compile(u'{0}.[0-9]+.Key'.format(option), re.UNICODE) response_values = {} for key, value in querystring.items(): if key_needle.match(key): values = [] key_index = key.split(".")[1] value_index = 1 while True: value_key = u'{0}.{1}.Value.{2}'.format( option, key_index, value_index) if value_key in querystring: values.extend(querystring[value_key]) else: break value_index += 1 response_values[value[0]] = values return response_values
0.002004
def create(self, language, tagged_text, source_channel=values.unset): """ Create a new SampleInstance :param unicode language: The ISO language-country string that specifies the language used for the new sample :param unicode tagged_text: The text example of how end users might express the task :param unicode source_channel: The communication channel from which the new sample was captured :returns: Newly created SampleInstance :rtype: twilio.rest.autopilot.v1.assistant.task.sample.SampleInstance """ data = values.of({'Language': language, 'TaggedText': tagged_text, 'SourceChannel': source_channel, }) payload = self._version.create( 'POST', self._uri, data=data, ) return SampleInstance( self._version, payload, assistant_sid=self._solution['assistant_sid'], task_sid=self._solution['task_sid'], )
0.006024
def get_nameserver_detail_output_show_nameserver_nameserver_connected_via_ag(self, **kwargs): """Auto Generated Code """ config = ET.Element("config") get_nameserver_detail = ET.Element("get_nameserver_detail") config = get_nameserver_detail output = ET.SubElement(get_nameserver_detail, "output") show_nameserver = ET.SubElement(output, "show-nameserver") nameserver_portid_key = ET.SubElement(show_nameserver, "nameserver-portid") nameserver_portid_key.text = kwargs.pop('nameserver_portid') nameserver_connected_via_ag = ET.SubElement(show_nameserver, "nameserver-connected-via-ag") nameserver_connected_via_ag.text = kwargs.pop('nameserver_connected_via_ag') callback = kwargs.pop('callback', self._callback) return callback(config)
0.007134
def guess_datetime_format(lines: Iterable[str], threshold: int=5) \ -> Tuple[Optional[str], Optional[bool]]: '''Guess whether order of the year, month, day and 12/24 hour. Returns: tuple: First item is either str ``ymd``, ``dmy``, ``mdy`` or ``None``. Second item is either True for 12-hour time or False for 24-hour time or None. ''' time_12_score = 0 time_24_score = 0 date_ymd_score = 0 date_dmy_score = 0 date_mdy_score = 0 for line in lines: line = unicodedata.normalize('NFKD', line).lower() if DAY_PERIOD_PATTERN.search(line): time_12_score += 1 else: time_24_score += 1 if ISO_8601_DATE_PATTERN.search(line): date_ymd_score += 1 if MMM_DD_YY_PATTERN.search(line): date_mdy_score += 1 match = NN_NN_NNNN_PATTERN.search(line) if match: num_1 = int(match.group(1)) num_2 = int(match.group(2)) if num_1 > 12: date_dmy_score += 1 elif num_2 > 12: date_mdy_score += 1 time_score = time_12_score + time_24_score date_score = date_ymd_score + date_dmy_score + date_mdy_score if time_score >= threshold and date_score >= threshold: break if date_ymd_score or date_dmy_score or date_mdy_score: top = max([ (date_ymd_score, 'ymd'), (date_dmy_score, 'dmy'), (date_mdy_score, 'mdy'), ], key=lambda item: item[0] ) date_format = top[1] else: date_format = None if time_12_score or time_24_score: day_period = True if time_12_score > time_24_score else False else: day_period = None return date_format, day_period
0.001629
def launcher(deploy_mode, args, working_dir=".", cleanup=True): """Initializes arguments and starts up pyspark with the correct deploy mode and environment. Parameters ---------- deploy_mode : {"client", "cluster"} args : list Arguments to pass onwards to spark submit. working_dir : str, optional Path to working directory to use for creating conda environments. Defaults to the current working directory. cleanup : bool, optional Clean up extracted / generated files. This defaults to true since conda environments can be rather large. Returns ------- This call will spawn a child process and block until that is complete. """ spark_args = args.copy() # Scan through the arguments to find --conda # TODO: make this optional, if not specified ignore all the python stuff # Is this double dash in front of conda env correct? i = spark_args.index("--conda-env") # pop off the '--conda-env' portion and just drop it on the floor spark_args.pop(i) # Now pop off the actual conda env var passed to the launcher conda_env = spark_args.pop(i) cleanup_functions = [] # What else could this possibly be other than a string here? assert isinstance(conda_env, str) func_kwargs = {'conda_env': conda_env, 'deploy_mode': deploy_mode, 'working_dir': working_dir, 'cleanup_functions': cleanup_functions} if conda_env.startswith("hdfs:/"): # "hadoop fs -ls" can return URLs with only a single "/" after the "hdfs:" scheme env_name, env_dir, env_archive = _conda_from_hdfs(**func_kwargs) elif conda_env.endswith(".zip"): # We have a precreated conda environment around. env_name, env_dir, conda_env = _conda_from_zip(**func_kwargs) elif conda_env.endswith(".yaml"): # The case where we have to CREATE the environment ourselves env_name, env_dir, env_archive = _conda_from_yaml(**func_kwargs) else: raise NotImplementedError("Can only run launcher if your conda env is on hdfs (starts " "with 'hdfs:/', is already a zip (ends with '.zip'), or is " "coming from a yaml specification (ends with '.yaml' and " "conforms to the conda environment.yaml spec)") del func_kwargs func_kwargs = dict(env_dir=env_dir, env_name=env_name, env_archive=env_archive, args=spark_args) funcs = {'client': run_pyspark_yarn_client, 'cluster': run_pyspark_yarn_cluster} try: funcs[deploy_mode](**func_kwargs) finally: if not cleanup: return # iterate over and call all cleanup functions for function in cleanup_functions: try: function() except: log.exception("Cleanup function %s failed", function)
0.004084
def connect(cls, region, session=None, access_key=None, secret_key=None, host=None, port=80, is_secure=True, **kwargs): """ Connect to an AWS region. Parameters ---------- region : str Name of an AWS region session : :class:`~botocore.session.Session`, optional The Session object to use for the connection access_key : str, optional If session is None, set this access key when creating the session secret_key : str, optional If session is None, set this secret key when creating the session host : str, optional Address of the host. Use this to connect to a local instance. port : int, optional Connect to the host on this port (default 80) is_secure : bool, optional Enforce https connection (default True) **kwargs : dict Keyword arguments to pass to the constructor """ if session is None: session = botocore.session.get_session() if access_key is not None: session.set_credentials(access_key, secret_key) url = None if host is not None: protocol = 'https' if is_secure else 'http' url = "%s://%s:%d" % (protocol, host, port) client = session.create_client('dynamodb', region, endpoint_url=url, use_ssl=is_secure) return cls(client, **kwargs)
0.001989
def evaluate(data): """Provide evaluations for multiple callers split by structural variant type. """ work_dir = utils.safe_makedir(os.path.join(data["dirs"]["work"], "structural", dd.get_sample_name(data), "validate")) truth_sets = tz.get_in(["config", "algorithm", "svvalidate"], data) if truth_sets and data.get("sv"): if isinstance(truth_sets, dict): val_summary, df_csv = _evaluate_multi(data["sv"], truth_sets, work_dir, data) summary_plots = _plot_evaluation(df_csv) data["sv-validate"] = {"csv": val_summary, "plot": summary_plots, "df": df_csv} else: assert isinstance(truth_sets, six.string_types) and utils.file_exists(truth_sets), truth_sets val_summary = _evaluate_vcf(data["sv"], truth_sets, work_dir, data) title = "%s structural variants" % dd.get_sample_name(data) summary_plots = validateplot.classifyplot_from_valfile(val_summary, outtype="png", title=title) data["sv-validate"] = {"csv": val_summary, "plot": summary_plots[0] if len(summary_plots) > 0 else None} return data
0.007647
def rot_consts(geom, masses, units=_EURC.INV_INERTIA, on_tol=_DEF.ORTHONORM_TOL): """Rotational constants for a given molecular system. Calculates the rotational constants for the provided system with numerical value given in the units provided in `units`. The orthnormality tolerance `on_tol` is required in order to be passed through to the :func:`principals` function. If the system is linear or a single atom, the effectively-zero principal moments of inertia will be assigned values of :data:`opan.const.PRM.ZERO_MOMENT_TOL` before transformation into the appropriate rotational constant units. The moments of inertia are always sorted in increasing order as :math:`0 \\leq I_A \\leq I_B \\leq I_C`; the rotational constants calculated from these will thus always be in **decreasing** order as :math:`B_A \\geq B_B \\geq B_C`, retaining the ordering and association with the three principal ``axes[:,i]`` generated by :func:`principals`. Parameters ---------- geom length-3N |npfloat_| -- Coordinates of the atoms masses length-N OR length-3N |npfloat_| -- Atomic masses of the atoms. Length-3N option is to allow calculation of a per-coordinate perturbed value. units :class:`~opan.const.EnumUnitsRotConst`, optional -- Enum value indicating the desired units of the output rotational constants. Default is :data:`~opan.const.EnumUnitsRotConst.INV_INERTIA` :math:`\\left(1\\over \\mathrm{uB^2}\\right)` on_tol |npfloat_|, optional -- Tolerance for deviation from unity/zero for principal axis dot products, within which axes are considered orthonormal. Default is :data:`opan.const.DEF.ORTHONORM_TOL` Returns ------- rc length-3 |npfloat_| -- Vector of rotational constants in the indicated units """ # Imports import numpy as np from ..const import EnumTopType as ETT, EnumUnitsRotConst as EURC, PRM, PHYS # Ensure units are valid if not units in EURC: raise ValueError("'{0}' is not a valid units value".format(units)) ## end if # Retrieve the moments, axes and top type. Geom and masses are proofed # internally in this call. mom, ax, top = principals(geom, masses, on_tol) # Check for special cases if top == ETT.ATOM: # All moments are zero; set to zero-moment threshold mom = np.repeat(PRM.ZERO_MOMENT_TOL, 3) elif top == ETT.LINEAR: # First moment is zero; set to zero-moment threshold mom[0] = PRM.ZERO_MOMENT_TOL ## end if # Calculate the values in the indicated units if units == EURC.INV_INERTIA: # 1/(amu*B^2) rc = 1.0 / (2.0 * mom) elif units == EURC.ANGFREQ_ATOMIC: # 1/Ta rc = PHYS.PLANCK_BAR / (2.0 * mom * PHYS.ME_PER_AMU) elif units == EURC.ANGFREQ_SECS: # 1/s rc = PHYS.PLANCK_BAR / (2.0 * mom * PHYS.ME_PER_AMU) / PHYS.SEC_PER_TA elif units == EURC.CYCFREQ_ATOMIC: # cyc/Ta rc = PHYS.PLANCK_BAR / (4.0 * np.pi * mom * PHYS.ME_PER_AMU) elif units == EURC.CYCFREQ_HZ: # cyc/s rc = PHYS.PLANCK_BAR / (4.0 * np.pi * mom * PHYS.ME_PER_AMU) / \ PHYS.SEC_PER_TA elif units == EURC.CYCFREQ_MHZ: # Mcyc/s rc = PHYS.PLANCK_BAR / (4.0 * np.pi * mom * PHYS.ME_PER_AMU) / \ PHYS.SEC_PER_TA / 1.0e6 elif units == EURC.WAVENUM_ATOMIC: # cyc/B rc = PHYS.PLANCK / (mom * PHYS.ME_PER_AMU) / \ (8.0 * np.pi**2.0 * PHYS.LIGHT_SPEED) elif units == EURC.WAVENUM_CM: # cyc/cm rc = PHYS.PLANCK / (mom * PHYS.ME_PER_AMU) / \ (8.0 * np.pi**2.0 * PHYS.LIGHT_SPEED * PHYS.ANG_PER_BOHR) * 1.0e8 else: # pragma: no cover -- Valid units; not implemented raise NotImplementedError("Units conversion not yet implemented.") ## end if # Return the result return rc
0.001702
def restrict(self, restriction): """ In-place restriction. Restricts the result to a specified subset of the input. rel.restrict(restriction) is equivalent to rel = rel & restriction or rel &= restriction rel.restrict(Not(restriction)) is equivalent to rel = rel - restriction or rel -= restriction The primary key of the result is unaffected. Successive restrictions are combined as logical AND: r & a & b is equivalent to r & AndList((a, b)) Any QueryExpression, collection, or sequence other than an AndList are treated as OrLists (logical disjunction of conditions) Inverse restriction is accomplished by either using the subtraction operator or the Not class. The expressions in each row equivalent: rel & True rel rel & False the empty entity set rel & 'TRUE' rel rel & 'FALSE' the empty entity set rel - cond rel & Not(cond) rel - 'TRUE' rel & False rel - 'FALSE' rel rel & AndList((cond1,cond2)) rel & cond1 & cond2 rel & AndList() rel rel & [cond1, cond2] rel & OrList((cond1, cond2)) rel & [] rel & False rel & None rel & False rel & any_empty_entity_set rel & False rel - AndList((cond1,cond2)) rel & [Not(cond1), Not(cond2)] rel - [cond1, cond2] rel & Not(cond1) & Not(cond2) rel - AndList() rel & False rel - [] rel rel - None rel rel - any_empty_entity_set rel When arg is another QueryExpression, the restriction rel & arg restricts rel to elements that match at least one element in arg (hence arg is treated as an OrList). Conversely, rel - arg restricts rel to elements that do not match any elements in arg. Two elements match when their common attributes have equal values or when they have no common attributes. All shared attributes must be in the primary key of either rel or arg or both or an error will be raised. QueryExpression.restrict is the only access point that modifies restrictions. All other operators must ultimately call restrict() :param restriction: a sequence or an array (treated as OR list), another QueryExpression, an SQL condition string, or an AndList. """ assert is_true(restriction) or not self.heading.expressions or isinstance(self, GroupBy), \ "Cannot restrict a projection with renamed attributes in place." self.restriction.append(restriction) return self
0.00509
def basic_set_of_users_exists_in_the_database(context): """ :type context: behave.runner.Context """ user_model = get_user_model() user_model.objects.create( username='administrator', is_staff=True ) user_model.objects.create( username='allowed_user' ) user_model.objects.create( username='unallowed_user' )
0.002545
async def mount(self, device): """ Mount the device if not already mounted. :param device: device object, block device path or mount path :returns: whether the device is mounted. """ device = self._find_device(device) if not self.is_handleable(device) or not device.is_filesystem: self._log.warn(_('not mounting {0}: unhandled device', device)) return False if device.is_mounted: self._log.info(_('not mounting {0}: already mounted', device)) return True options = match_config(self._config, device, 'options', None) kwargs = dict(options=options) self._log.debug(_('mounting {0} with {1}', device, kwargs)) self._check_device_before_mount(device) mount_path = await device.mount(**kwargs) self._log.info(_('mounted {0} on {1}', device, mount_path)) return True
0.002151
def add_router_to_hosting_device(self, context, hosting_device_id, router_id): """Add a (non-hosted) router to a hosting device.""" e_context = context.elevated() r_hd_binding_db = self._get_router_binding_info(e_context, router_id) if r_hd_binding_db.hosting_device_id: if r_hd_binding_db.hosting_device_id == hosting_device_id: return raise routertypeawarescheduler.RouterHostedByHostingDevice( router_id=router_id, hosting_device_id=hosting_device_id) rt_info = self.validate_hosting_device_router_combination( context, r_hd_binding_db, hosting_device_id) result = self.schedule_router_on_hosting_device( e_context, r_hd_binding_db, hosting_device_id, rt_info['slot_need']) if result: # refresh so that we get latest contents from DB e_context.session.expire(r_hd_binding_db) router = self.get_router(e_context, router_id) self.add_type_and_hosting_device_info( e_context, router, r_hd_binding_db, schedule=False) l3_cfg_notifier = self.agent_notifiers.get(AGENT_TYPE_L3_CFG) if l3_cfg_notifier: l3_cfg_notifier.router_added_to_hosting_device(context, router) else: raise routertypeawarescheduler.RouterSchedulingFailed( router_id=router_id, hosting_device_id=hosting_device_id)
0.001992
def get_current_index(self): """ Return currently selected index (or -1) """ # Need to convert to int; currently API returns a tuple of string curSel = self.__lb.curselection() if curSel and len(curSel) > 0: return int(curSel[0]) else: return -1
0.006452
def filter(cls, parent=None, **filters): """ Gets all resources of the given type and parent (if provided) which match the given filters. This will trigger an api GET request. :param parent ResourceBase: the parent of the resource - used for nesting the request url, optional :param **filters: any number of keyword arguments to filter by, e.g name='example name' :returns: a list of matching resources """ data = cls._process_filter_request(parent, **filters) return cls._load_resources(data)
0.00885
def read(self): """Read a Response, do some validation, and return it.""" if FLAGS.sc2_verbose_protocol: self._log(" Reading response ".center(60, "-")) start = time.time() response = self._read() if FLAGS.sc2_verbose_protocol: self._log(" %0.1f msec\n" % (1000 * (time.time() - start))) self._log_packet(response) if not response.HasField("status"): raise ProtocolError("Got an incomplete response without a status.") prev_status = self._status self._status = Status(response.status) # pytype: disable=not-callable if response.error: err_str = ("Error in RPC response (likely a bug). " "Prev status: %s, new status: %s, error:\n%s" % ( prev_status, self._status, "\n".join(response.error))) logging.error(err_str) raise ProtocolError(err_str) return response
0.010204
def get_cousins_treepos(self, treepos): """Given a treeposition, return the treeposition of its siblings.""" cousins_pos = [] mother_pos = self.get_parent_treepos(treepos) if mother_pos is not None: aunts_pos = self.get_siblings_treepos(mother_pos) for aunt_pos in aunts_pos: cousins_pos.extend( self.get_children_treepos(aunt_pos) ) return cousins_pos
0.009238
def add_image(self, image_path, annotations): """Adds an image and its bounding boxes to the current list of files The bounding boxes are automatically estimated based on the given annotations. **Parameters:** ``image_path`` : str The file name of the image, including its full path ``annotations`` : [dict] A list of annotations, i.e., where each annotation can be anything that :py:func:`bounding_box_from_annotation` can handle; this list can be empty, in case the image does not contain any faces """ self.image_paths.append(image_path) self.bounding_boxes.append([bounding_box_from_annotation(**a) for a in annotations])
0.005944
def get_file(self): """ Load data into a file and return file path. :return: path to file as string """ content = self._load() if not content: return None filename = "temporary_file.bin" with open(filename, "wb") as file_name: file_name.write(content) return filename
0.005495
def redundancy_output_rd_mesg(self, **kwargs): """Auto Generated Code """ config = ET.Element("config") redundancy = ET.Element("redundancy") config = redundancy output = ET.SubElement(redundancy, "output") rd_mesg = ET.SubElement(output, "rd_mesg") rd_mesg.text = kwargs.pop('rd_mesg') callback = kwargs.pop('callback', self._callback) return callback(config)
0.004535
def parse_args(argv): """ Use Argparse to parse command-line arguments. :param argv: list of arguments to parse (``sys.argv[1:]``) :type argv: :std:term:`list` :return: parsed arguments :rtype: :py:class:`argparse.Namespace` """ p = argparse.ArgumentParser( description='webhook2lambda2sqs - Generate code and manage ' 'infrastructure for receiving webhooks with AWS API ' 'Gateway and pushing to SQS via Lambda - <%s>' % PROJECT_URL ) p.add_argument('-c', '--config', dest='config', type=str, action='store', default='config.json', help='path to config.json (default: ./config.json)') p.add_argument('-v', '--verbose', dest='verbose', action='count', default=0, help='verbose output. specify twice for debug-level output.') p.add_argument('-V', '--version', action='version', version='webhook2lambda2sqs v%s <%s>' % ( VERSION, PROJECT_URL )) p.add_argument('-T', '--tf-version', dest='tf_ver', action='store', type=str, default='0.9.0', help='terraform version to generate configurations for') subparsers = p.add_subparsers(title='Action (Subcommand)', dest='action', metavar='ACTION', description='Action to ' 'perform; each action may take further ' 'parameters. Use ACTION -h for subcommand-' 'specific options and arguments.') subparsers.add_parser( 'generate', help='generate lambda function and terraform configs in ./' ) tf_parsers = [ ('genapply', 'generate function and terraform configs in ./, then run ' 'terraform apply'), ('plan', 'run terraform plan to show changes which will be made'), ('apply', 'run terraform apply to apply changes/create infrastructure'), ('destroy', 'run terraform destroy to completely destroy infrastructure') ] tf_p_objs = {} for cname, chelp in tf_parsers: tf_p_objs[cname] = subparsers.add_parser(cname, help=chelp) tf_p_objs[cname].add_argument('-t', '--terraform-path', dest='tf_path', action='store', default='terraform', type=str, help='path to terraform ' 'binary, if not in PATH') tf_p_objs[cname].add_argument('-S', '--no-stream-tf', dest='stream_tf', action='store_false', default=True, help='DO NOT stream Terraform output to ' 'STDOUT (combined) in realtime') apilogparser = subparsers.add_parser('apilogs', help='show last 10 ' 'CloudWatch Logs entries for the ' 'API Gateway') apilogparser.add_argument('-c', '--count', dest='log_count', type=int, default=10, help='number of log entries to show ' '(default 10') logparser = subparsers.add_parser('logs', help='show last 10 CloudWatch ' 'Logs entries for the function') logparser.add_argument('-c', '--count', dest='log_count', type=int, default=10, help='number of log entries to show ' '(default 10') queueparser = subparsers.add_parser('queuepeek', help='show messages from ' 'one or all of the SQS queues') queueparser.add_argument('-n', '--name', type=str, dest='queue_name', default=None, help='queue name to read (defaults ' 'to None to read all)') queueparser.add_argument('-d', '--delete', action='store_true', dest='queue_delete', default=False, help='delete messages after reading') queueparser.add_argument('-c', '--count', dest='msg_count', type=int, default=10, help='number of messages to read from ' 'each queue (default 10)') testparser = subparsers.add_parser('test', help='send test message to ' 'one or more endpoints') testparser.add_argument('-t', '--terraform-path', dest='tf_path', action='store', default='terraform', type=str, help='path to terraform ' 'binary, if not in PATH') testparser.add_argument('-n', '--endpoint-name', dest='endpoint_name', type=str, default=None, help='endpoint name (default: None, to send to ' 'all endpoints)') subparsers.add_parser( 'example-config', help='write example config to STDOUT and description ' 'of it to STDERR, then exit' ) args = p.parse_args(argv) if args.action is None: # for py3, which doesn't raise on this sys.stderr.write("ERROR: too few arguments\n") raise SystemExit(2) return args
0.001091
def get_model_agents(self): """Return a list of all Agents from all Statements. Returns ------- agents : list[indra.statements.Agent] A list of Agents that are in the model. """ model_stmts = self.get_statements() agents = [] for stmt in model_stmts: for a in stmt.agent_list(): if a is not None: agents.append(a) return agents
0.004357
async def fetch_room(self, room_id): """Lookup details for a given room id""" url = "https://production.plum.technology/v2/getRoom" data = {"rid": room_id} return await self.__post(url, data)
0.008969
def get_bgp_neighbors(self): def generate_vrf_query(vrf_name): """ Helper to provide XML-query for the VRF-type we're interested in. """ if vrf_name == "global": rpc_command = '<Get><Operational><BGP><InstanceTable><Instance><Naming>\ <InstanceName>default</InstanceName></Naming><InstanceActive><DefaultVRF>\ <GlobalProcessInfo></GlobalProcessInfo><NeighborTable></NeighborTable></DefaultVRF>\ </InstanceActive></Instance></InstanceTable></BGP></Operational></Get>' else: rpc_command = '<Get><Operational><BGP><InstanceTable><Instance><Naming>\ <InstanceName>default</InstanceName></Naming><InstanceActive><VRFTable><VRF>\ <Naming>{vrf_name}</Naming><GlobalProcessInfo></GlobalProcessInfo><NeighborTable>\ </NeighborTable></VRF></VRFTable></InstanceActive></Instance></InstanceTable>\ </BGP></Operational></Get>'.format(vrf_name=vrf_name) return rpc_command """ Initial run to figure out what VRF's are available Decided to get this one from Configured-section because bulk-getting all instance-data to do the same could get ridiculously heavy Assuming we're always interested in the DefaultVRF """ active_vrfs = ["global"] rpc_command = '<Get><Operational><BGP><ConfigInstanceTable><ConfigInstance><Naming>\ <InstanceName>default</InstanceName></Naming><ConfigInstanceVRFTable>\ </ConfigInstanceVRFTable></ConfigInstance></ConfigInstanceTable></BGP></Operational></Get>' result_tree = ETREE.fromstring(self.device.make_rpc_call(rpc_command)) for node in result_tree.xpath('.//ConfigVRF'): active_vrfs.append(napalm_base.helpers.find_txt(node, 'Naming/VRFName')) result = {} for vrf in active_vrfs: rpc_command = generate_vrf_query(vrf) result_tree = ETREE.fromstring(self.device.make_rpc_call(rpc_command)) this_vrf = {} this_vrf['peers'] = {} if vrf == "global": this_vrf['router_id'] = napalm_base.helpers.convert( text_type, napalm_base.helpers.find_txt(result_tree, 'Get/Operational/BGP/InstanceTable/Instance/InstanceActive/DefaultVRF\ /GlobalProcessInfo/VRF/RouterID')) else: this_vrf['router_id'] = napalm_base.helpers.convert( text_type, napalm_base.helpers.find_txt(result_tree, 'Get/Operational/BGP/InstanceTable/Instance/InstanceActive/VRFTable/VRF\ /GlobalProcessInfo/VRF/RouterID')) neighbors = {} for neighbor in result_tree.xpath('.//Neighbor'): this_neighbor = {} this_neighbor['local_as'] = napalm_base.helpers.convert( int, napalm_base.helpers.find_txt(neighbor, 'LocalAS')) this_neighbor['remote_as'] = napalm_base.helpers.convert( int, napalm_base.helpers.find_txt(neighbor, 'RemoteAS')) this_neighbor['remote_id'] = napalm_base.helpers.convert( text_type, napalm_base.helpers.find_txt(neighbor, 'RouterID')) if napalm_base.helpers.find_txt(neighbor, 'ConnectionAdminStatus') is "1": this_neighbor['is_enabled'] = True try: this_neighbor['description'] = napalm_base.helpers.convert( text_type, napalm_base.helpers.find_txt(neighbor, 'Description')) except AttributeError: this_neighbor['description'] = u'' this_neighbor['is_enabled'] = ( napalm_base.helpers.find_txt(neighbor, 'ConnectionAdminStatus') == "1") if str(napalm_base.helpers.find_txt(neighbor, 'ConnectionAdminStatus')) is "1": this_neighbor['is_enabled'] = True else: this_neighbor['is_enabled'] = False if str(napalm_base.helpers.find_txt(neighbor, 'ConnectionState')) == "BGP_ST_ESTAB": this_neighbor['is_up'] = True this_neighbor['uptime'] = napalm_base.helpers.convert( int, napalm_base.helpers.find_txt(neighbor, 'ConnectionEstablishedTime')) else: this_neighbor['is_up'] = False this_neighbor['uptime'] = -1 this_neighbor['address_family'] = {} if napalm_base.helpers.find_txt(neighbor, 'ConnectionRemoteAddress/AFI') == "IPv4": this_afi = "ipv4" elif napalm_base.helpers.find_txt(neighbor, 'ConnectionRemoteAddress/AFI') == "IPv6": this_afi = "ipv6" else: this_afi = napalm_base.helpers.find_txt(neighbor, 'ConnectionRemoteAddress/AFI') this_neighbor['address_family'][this_afi] = {} try: this_neighbor['address_family'][this_afi]["received_prefixes"] = \ napalm_base.helpers.convert(int, napalm_base.helpers.find_txt( neighbor, 'AFData/Entry/PrefixesAccepted'), 0) + \ napalm_base.helpers.convert(int, napalm_base.helpers.find_txt( neighbor, 'AFData/Entry/PrefixesDenied'), 0) this_neighbor['address_family'][this_afi]["accepted_prefixes"] = \ napalm_base.helpers.convert(int, napalm_base.helpers.find_txt( neighbor, 'AFData/Entry/PrefixesAccepted'), 0) this_neighbor['address_family'][this_afi]["sent_prefixes"] = \ napalm_base.helpers.convert(int, napalm_base.helpers.find_txt( neighbor, 'AFData/Entry/PrefixesAdvertised'), 0) except AttributeError: this_neighbor['address_family'][this_afi]["received_prefixes"] = -1 this_neighbor['address_family'][this_afi]["accepted_prefixes"] = -1 this_neighbor['address_family'][this_afi]["sent_prefixes"] = -1 neighbor_ip = napalm_base.helpers.ip( napalm_base.helpers.find_txt( neighbor, 'Naming/NeighborAddress/IPV4Address') or napalm_base.helpers.find_txt( neighbor, 'Naming/NeighborAddress/IPV6Address') ) neighbors[neighbor_ip] = this_neighbor this_vrf['peers'] = neighbors result[vrf] = this_vrf return result
0.004847
def save_related(self, request, form, formsets, change): """ Given the ``HttpRequest``, the parent ``ModelForm`` instance, the list of inline formsets and a boolean value based on whether the parent is being added or changed, save the related objects to the database. Note that at this point save_form() and save_model() have already been called. """ form.save_m2m() for formset in formsets: self.save_formset(request, form, formset, change=change)
0.003759
def flatten(dic, keep_iter=False, position=None): """ Returns a flattened dictionary from a dictionary of nested dictionaries and lists. `keep_iter` will treat iterables as valid values, while also flattening them. """ child = {} if not dic: return {} for k, v in get_iter(dic): if isstr(k): k = k.replace('.', '_') if position: item_position = '%s.%s' % (position, k) else: item_position = '%s' % k if is_iter(v): child.update(flatten(dic[k], keep_iter, item_position)) if keep_iter: child[item_position] = v else: child[item_position] = v return child
0.004144
def Parse(self, raw_data): """Take the results and yield results that passed through the filters. The output of each filter is used as the input for successive filters. Args: raw_data: An iterable series of rdf values. Returns: A list of rdf values that matched all filters. """ self.results = raw_data for f in self.filters: self.results = f.Parse(self.results) return self.results
0.004598