text
stringlengths
78
104k
score
float64
0
0.18
def parse_elem(element): """Parse a OSM node XML element. Args: element (etree.Element): XML Element to parse Returns: Node: Object representing parsed element """ ident = int(element.get('id')) latitude = element.get('lat') longitude = element.get('lon') flags = _parse_flags(element) return Node(ident, latitude, longitude, *flags)
0.004619
def make_naive(value, timezone): """ Makes an aware datetime.datetime naive in a given time zone. """ value = value.astimezone(timezone) if hasattr(timezone, 'normalize'): # available for pytz time zones value = timezone.normalize(value) return value.replace(tzinfo=None)
0.003215
def predict(self, x): """ Predict values for a single data point or an RDD of points using the model trained. """ if isinstance(x, RDD): return x.map(lambda v: self.predict(v)) x = _convert_to_vector(x) if self.numClasses == 2: margin = self.weights.dot(x) + self._intercept if margin > 0: prob = 1 / (1 + exp(-margin)) else: exp_margin = exp(margin) prob = exp_margin / (1 + exp_margin) if self._threshold is None: return prob else: return 1 if prob > self._threshold else 0 else: best_class = 0 max_margin = 0.0 if x.size + 1 == self._dataWithBiasSize: for i in range(0, self._numClasses - 1): margin = x.dot(self._weightsMatrix[i][0:x.size]) + \ self._weightsMatrix[i][x.size] if margin > max_margin: max_margin = margin best_class = i + 1 else: for i in range(0, self._numClasses - 1): margin = x.dot(self._weightsMatrix[i]) if margin > max_margin: max_margin = margin best_class = i + 1 return best_class
0.00141
def compile_graphql_to_gremlin(schema, graphql_string, type_equivalence_hints=None): """Compile the GraphQL input using the schema into a Gremlin query and associated metadata. Args: schema: GraphQL schema object describing the schema of the graph to be queried graphql_string: the GraphQL query to compile to Gremlin, as a string type_equivalence_hints: optional dict of GraphQL interface or type -> GraphQL union. Used as a workaround for GraphQL's lack of support for inheritance across "types" (i.e. non-interfaces), as well as a workaround for Gremlin's total lack of inheritance-awareness. The key-value pairs in the dict specify that the "key" type is equivalent to the "value" type, i.e. that the GraphQL type or interface in the key is the most-derived common supertype of every GraphQL type in the "value" GraphQL union. Recursive expansion of type equivalence hints is not performed, and only type-level correctness of this argument is enforced. See README.md for more details on everything this parameter does. ***** Be very careful with this option, as bad input here will lead to incorrect output queries being generated. ***** Returns: a CompilationResult object """ lowering_func = ir_lowering_gremlin.lower_ir query_emitter_func = emit_gremlin.emit_code_from_ir return _compile_graphql_generic( GREMLIN_LANGUAGE, lowering_func, query_emitter_func, schema, graphql_string, type_equivalence_hints, None)
0.00874
def make_tarball(src_dir): """ Make gzipped tarball from a source directory :param src_dir: source directory :raises TypeError: if src_dir is not str """ if type(src_dir) != str: raise TypeError('src_dir must be str') output_file = src_dir + ".tar.gz" log.msg("Wrapping tarball '{out}' ...".format(out=output_file)) if not _dry_run: with tarfile.open(output_file, "w:gz") as tar: tar.add(src_dir, arcname=os.path.basename(src_dir)) return output_file
0.001927
def _create_RSA_private_key(self, bytes): """ Instantiates an RSA key from bytes. Args: bytes (byte string): Bytes of RSA private key. Returns: private_key (cryptography.hazmat.primitives.asymmetric.rsa.RSAPrivateKey): RSA private key created from key bytes. """ try: private_key = serialization.load_pem_private_key( bytes, password=None, backend=default_backend() ) return private_key except Exception: private_key = serialization.load_der_private_key( bytes, password=None, backend=default_backend() ) return private_key
0.003584
def parse_doc_str(text=None, is_untabbed=True, is_stripped=True, tab=None, split_character="::"): """ Returns a str of the parsed doc for example the following would return 'a:A\nb:B' :: a:A b:B :param text: str of the text to parse, by default uses calling function doc :param is_untabbed: bool if True will untab the text :param is_stripped: bool if True will strip the text :param tab: str of the tab to use when untabbing, by default it will self determine tab size :param split_character: str of the character to split the text on :return: dict """ text = text or function_doc(2) text = text.split(split_character, 1)[-1] text = text.split(':param')[0].split(':return')[0] tab = is_untabbed and \ (tab or text[:-1 * len(text.lstrip())].split('\n')[-1]) or '' text = is_stripped and text.strip() or text return text.replace('\n%s' % tab, '\n')
0.004785
def initialize_baremetal_switch_interfaces(self, interfaces): """Initialize Nexus interfaces and for initial baremetal event. This get/create port channel number, applies channel-group to ethernet interface, and initializes trunking on interface. :param interfaces: Receive a list of interfaces containing: nexus_host: IP address of Nexus switch intf_type: String which specifies interface type. example: ethernet interface: String indicating which interface. example: 1/19 is_native: Whether native vlan must be configured. ch_grp: May replace port channel to each entry. channel number is 0 if none """ if not interfaces: return max_ifs = len(interfaces) starttime = time.time() learned, nexus_ip_list = self._build_host_list_and_verify_chgrp( interfaces) if not nexus_ip_list: return if max_ifs > 1: # update vpc db with learned vpcid or get new one. if learned: ch_grp = interfaces[0][-1] self._configure_learned_port_channel( nexus_ip_list, ch_grp) else: ch_grp = self._get_new_baremetal_portchannel_id(nexus_ip_list) else: ch_grp = 0 for i, (nexus_host, intf_type, nexus_port, is_native, ch_grp_saved) in enumerate(interfaces): if max_ifs > 1: if learned: ch_grp = ch_grp_saved else: self._config_new_baremetal_portchannel( ch_grp, nexus_host, intf_type, nexus_port) self._replace_interface_ch_grp(interfaces, i, ch_grp) # init port-channel instead of the provided ethernet intf_type = 'port-channel' nexus_port = str(ch_grp) else: self._replace_interface_ch_grp(interfaces, i, ch_grp) trunk_mode_present, vlan_present = ( self._get_interface_switch_trunk_present( nexus_host, intf_type, nexus_port)) if not vlan_present: self.send_enable_vlan_on_trunk_int( nexus_host, "", intf_type, nexus_port, False, not trunk_mode_present) elif not trunk_mode_present: LOG.warning(TRUNK_MODE_NOT_FOUND, nexus_host, nexus_help.format_interface_name( intf_type, nexus_port)) self.capture_and_print_timeshot( starttime, "init_bmif", switch=nexus_host)
0.001464
def get_objects(self, path, marker=None, limit=settings.CLOUD_BROWSER_DEFAULT_LIST_LIMIT): """Get objects. **Pseudo-directory Notes**: Rackspace has two approaches to pseudo- directories within the (really) flat storage object namespace: 1. Dummy directory storage objects. These are real storage objects of type "application/directory" and must be manually uploaded by the client. 2. Implied subdirectories using the `path` API query parameter. Both serve the same purpose, but the latter is much preferred because there is no independent maintenance of extra dummy objects, and the `path` approach is always correct (for the existing storage objects). This package uses the latter `path` approach, but gets into an ambiguous situation where there is both a dummy directory storage object and an implied subdirectory. To remedy this situation, we only show information for the dummy directory object in results if present, and ignore the implied subdirectory. But, under the hood this means that our `limit` parameter may end up with less than the desired number of objects. So, we use the heuristic that if we **do** have "application/directory" objects, we end up doing an extra query of double the limit size to ensure we can get up to the limit amount of objects. This double query approach is inefficient, but as using dummy objects should now be deprecated, the second query should only rarely occur. """ object_infos, full_query = self._get_object_infos(path, marker, limit) if full_query and len(object_infos) < limit: # The underlying query returned a full result set, but we # truncated it to under limit. Re-run at twice the limit and then # slice back. object_infos, _ = self._get_object_infos(path, marker, 2 * limit) object_infos = object_infos[:limit] return [self.obj_cls.from_info(self, x) for x in object_infos]
0.001403
def enable(self, msgid, scope="package", line=None, ignore_unknown=False): """reenable message of the given id""" self._set_msg_status( msgid, enable=True, scope=scope, line=line, ignore_unknown=ignore_unknown ) self._register_by_id_managed_msg(msgid, line, is_disabled=False)
0.009375
def parse_workflow_call_body_io_map(self, i): """ Required. :param i: :return: """ io_map = OrderedDict() if isinstance(i, wdl_parser.Terminal): raise NotImplementedError elif isinstance(i, wdl_parser.Ast): raise NotImplementedError elif isinstance(i, wdl_parser.AstList): for ast in i: if ast.name == 'IOMapping': key = self.parse_declaration_expressn(ast.attr("key"), es='') value = self.parse_declaration_expressn(ast.attr("value"), es='') io_map[key] = value else: raise NotImplementedError return io_map
0.005427
def train(self, train_set, valid_set=None, test_set=None, train_size=None): '''We train over mini-batches and evaluate periodically.''' iteration = 0 while True: if not iteration % self.config.test_frequency and test_set: try: self.test(iteration, test_set) except KeyboardInterrupt: logging.info('interrupted!') break if not iteration % self.validation_frequency and valid_set: try: if not self.evaluate(iteration, valid_set): logging.info('patience elapsed, bailing out') break except KeyboardInterrupt: logging.info('interrupted!') break train_message = "" try: train_message = self.train_func(train_set) except KeyboardInterrupt: logging.info('interrupted!') break if not iteration % self.config.monitor_frequency: logging.info('monitor (iter=%i) %s', iteration + 1, train_message) iteration += 1 if hasattr(self.network, "iteration_callback"): self.network.iteration_callback() yield train_message if valid_set: self.set_params(self.best_params) if test_set: self.test(0, test_set)
0.002034
def iter_all_users(self, number=-1, etag=None, per_page=None): """Iterate over every user in the order they signed up for GitHub. :param int number: (optional), number of users to return. Default: -1, returns all of them :param str etag: (optional), ETag from a previous request to the same endpoint :param int per_page: (optional), number of users to list per request :returns: generator of :class:`User <github3.users.User>` """ url = self._build_url('users') return self._iter(int(number), url, User, params={'per_page': per_page}, etag=etag)
0.00303
def solve_series(self, x0, params, varied_data, varied_idx, internal_x0=None, solver=None, propagate=True, **kwargs): """ Solve system for a set of parameters in which one is varied Parameters ---------- x0 : array_like Guess (subject to ``self.post_processors``) params : array_like Parameter values vaired_data : array_like Numerical values of the varied parameter. varied_idx : int or str Index of the varied parameter (indexing starts at 0). If ``self.par_by_name`` this should be the name (str) of the varied parameter. internal_x0 : array_like (default: None) Guess (*not* subject to ``self.post_processors``). Overrides ``x0`` when given. solver : str or callback See :meth:`solve`. propagate : bool (default: True) Use last successful solution as ``x0`` in consecutive solves. \\*\\*kwargs : Keyword arguments pass along to :meth:`solve`. Returns ------- xout : array Of shape ``(varied_data.size, x0.size)``. info_dicts : list of dictionaries Dictionaries each containing keys such as containing 'success', 'nfev', 'njev' etc. """ if self.x_by_name and isinstance(x0, dict): x0 = [x0[k] for k in self.names] if self.par_by_name: if isinstance(params, dict): params = [params[k] for k in self.param_names] if isinstance(varied_idx, str): varied_idx = self.param_names.index(varied_idx) new_params = np.atleast_1d(np.array(params, dtype=np.float64)) xout = np.empty((len(varied_data), len(x0))) self.internal_xout = np.empty_like(xout) self.internal_params_out = np.empty((len(varied_data), len(new_params))) info_dicts = [] new_x0 = np.array(x0, dtype=np.float64) # copy conds = kwargs.get('initial_conditions', None) # see ConditionalNeqSys for idx, value in enumerate(varied_data): try: new_params[varied_idx] = value except TypeError: new_params = value # e.g. type(new_params) == int if conds is not None: kwargs['initial_conditions'] = conds x, info_dict = self.solve(new_x0, new_params, internal_x0, solver, **kwargs) if propagate: if info_dict['success']: try: # See ChainedNeqSys.solve new_x0 = info_dict['x_vecs'][0] internal_x0 = info_dict['internal_x_vecs'][0] conds = info_dict['intermediate_info'][0].get( 'conditions', None) except: new_x0 = x internal_x0 = None conds = info_dict.get('conditions', None) xout[idx, :] = x self.internal_xout[idx, :] = self.internal_x self.internal_params_out[idx, :] = self.internal_params info_dicts.append(info_dict) return xout, info_dicts
0.001489
def reduce_to_cycles(self): """ Iteratively eliminate leafs to reduce the set of objects to only those that build cycles. Return the reduced graph. If there are no cycles, None is returned. """ if not self._reduced: reduced = copy(self) reduced.objects = self.objects[:] reduced.metadata = [] reduced.edges = [] self.num_in_cycles = reduced._reduce_to_cycles() reduced.num_in_cycles = self.num_in_cycles if self.num_in_cycles: reduced._get_edges() reduced._annotate_objects() for meta in reduced.metadata: meta.cycle = True else: reduced = None self._reduced = reduced return self._reduced
0.002389
def get_all_connected_interfaces(): """! @brief Returns all the connected devices with a CMSIS-DAPv2 interface.""" # find all cmsis-dap devices try: all_devices = usb.core.find(find_all=True, custom_match=HasCmsisDapv2Interface()) except usb.core.NoBackendError: common.show_no_libusb_warning() return [] # iterate on all devices found boards = [] for board in all_devices: new_board = PyUSBv2() new_board.vid = board.idVendor new_board.pid = board.idProduct new_board.product_name = board.product new_board.vendor_name = board.manufacturer new_board.serial_number = board.serial_number boards.append(new_board) return boards
0.004932
def parse_config(self, config_source): """ Parses a landslide configuration file and returns a normalized python dict. """ self.log(u"Config %s" % config_source) try: raw_config = configparser.RawConfigParser() raw_config.read(config_source) except Exception as e: raise RuntimeError(u"Invalid configuration file: %s" % e) config = {} config['source'] = raw_config.get('landslide', 'source')\ .replace('\r', '').split('\n') if raw_config.has_option('landslide', 'theme'): config['theme'] = raw_config.get('landslide', 'theme') self.log(u"Using configured theme %s" % config['theme']) if raw_config.has_option('landslide', 'destination'): config['destination'] = raw_config.get('landslide', 'destination') if raw_config.has_option('landslide', 'linenos'): config['linenos'] = raw_config.get('landslide', 'linenos') for boolopt in ('embed', 'relative', 'copy_theme'): if raw_config.has_option('landslide', boolopt): config[boolopt] = raw_config.getboolean('landslide', boolopt) if raw_config.has_option('landslide', 'extensions'): config['extensions'] = ",".join(raw_config.get('landslide', 'extensions')\ .replace('\r', '').split('\n')) if raw_config.has_option('landslide', 'css'): config['css'] = raw_config.get('landslide', 'css')\ .replace('\r', '').split('\n') if raw_config.has_option('landslide', 'js'): config['js'] = raw_config.get('landslide', 'js')\ .replace('\r', '').split('\n') return config
0.002859
def _determine_nTrackIterations(self,nTrackIterations): """Determine a good value for nTrackIterations based on the misalignment between stream and orbit; just based on some rough experience for now""" if not nTrackIterations is None: self.nTrackIterations= nTrackIterations return None if numpy.fabs(self.misalignment(quantity=False)) < 1./180.*numpy.pi: self.nTrackIterations= 0 elif numpy.fabs(self.misalignment(quantity=False)) >= 1./180.*numpy.pi \ and numpy.fabs(self.misalignment(quantity=False)) < 3./180.*numpy.pi: self.nTrackIterations= 1 elif numpy.fabs(self.misalignment(quantity=False)) >= 3./180.*numpy.pi: self.nTrackIterations= 2 return None
0.014085
def parse_xml(sentence, tab="\t", id=""): """ Returns the given Sentence object as an XML-string (plain bytestring, UTF-8 encoded). The tab delimiter is used as indendation for nested elements. The id can be used as a unique identifier per sentence for chunk id's and anchors. For example: "I eat pizza with a fork." => <sentence token="word, part-of-speech, chunk, preposition, relation, anchor, lemma" language="en"> <chunk type="NP" relation="SBJ" of="1"> <word type="PRP" lemma="i">I</word> </chunk> <chunk type="VP" relation="VP" id="1" anchor="A1"> <word type="VBP" lemma="eat">eat</word> </chunk> <chunk type="NP" relation="OBJ" of="1"> <word type="NN" lemma="pizza">pizza</word> </chunk> <chunk type="PNP" of="A1"> <chunk type="PP"> <word type="IN" lemma="with">with</word> </chunk> <chunk type="NP"> <word type="DT" lemma="a">a</word> <word type="NN" lemma="fork">fork</word> </chunk> </chunk> <chink> <word type="." lemma=".">.</word> </chink> </sentence> """ uid = lambda *parts: "".join([str(id), _UID_SEPARATOR ]+[str(x) for x in parts]).lstrip(_UID_SEPARATOR) push = lambda indent: indent+tab # push() increases the indentation. pop = lambda indent: indent[:-len(tab)] # pop() decreases the indentation. indent = tab xml = [] # Start the sentence element: # <sentence token="word, part-of-speech, chunk, preposition, relation, anchor, lemma"> xml.append('<%s%s %s="%s" %s="%s">' % ( XML_SENTENCE, XML_ID and " %s=\"%s\"" % (XML_ID, str(id)) or "", XML_TOKEN, ", ".join(sentence.token), XML_LANGUAGE, sentence.language )) # Collect chunks that are PNP anchors and assign id. anchors = {} for chunk in sentence.chunks: if chunk.attachments: anchors[chunk.start] = len(anchors) + 1 # Traverse all words in the sentence. for word in sentence.words: chunk = word.chunk pnp = word.chunk and word.chunk.pnp or None # Start the PNP element if the chunk is the first chunk in PNP: # <chunk type="PNP" of="A1"> if pnp and pnp.start == chunk.start: a = pnp.anchor and ' %s="%s"' % (XML_OF, uid("A", anchors.get(pnp.anchor.start, ""))) or "" xml.append(indent + '<%s %s="PNP"%s>' % (XML_CHUNK, XML_TYPE, a)) indent = push(indent) # Start the chunk element if the word is the first word in the chunk: # <chunk type="VP" relation="VP" id="1" anchor="A1"> if chunk and chunk.start == word.index: if chunk.relations: # Create the shortest possible attribute values for multiple relations, # e.g., [(1,"OBJ"),(2,"OBJ")]) => relation="OBJ" id="1|2" r1 = unzip(0, chunk.relations) # Relation id's. r2 = unzip(1, chunk.relations) # Relation roles. r1 = [x is None and "-" or uid(x) for x in r1] r2 = [x is None and "-" or x for x in r2] r1 = not len(unique(r1)) == 1 and "|".join(r1) or (r1+[None])[0] r2 = not len(unique(r2)) == 1 and "|".join(r2) or (r2+[None])[0] xml.append(indent + '<%s%s%s%s%s%s>' % ( XML_CHUNK, chunk.type and ' %s="%s"' % (XML_TYPE, chunk.type) or "", chunk.relations and chunk.role != None and ' %s="%s"' % (XML_RELATION, r2) or "", chunk.relation and chunk.type == "VP" and ' %s="%s"' % (XML_ID, uid(chunk.relation)) or "", chunk.relation and chunk.type != "VP" and ' %s="%s"' % (XML_OF, r1) or "", chunk.attachments and ' %s="%s"' % (XML_ANCHOR, uid("A",anchors[chunk.start])) or "" )) indent = push(indent) # Words outside of a chunk are wrapped in a <chink> tag: # <chink> if not chunk: xml.append(indent + '<%s>' % XML_CHINK) indent = push(indent) # Add the word element: # <word type="VBP" lemma="eat">eat</word> xml.append(indent + '<%s%s%s%s>%s</%s>' % ( XML_WORD, word.type and ' %s="%s"' % (XML_TYPE, xml_encode(word.type)) or '', word.lemma and ' %s="%s"' % (XML_LEMMA, xml_encode(word.lemma)) or '', (" "+" ".join(['%s="%s"' % (k,v) for k,v in word.custom_tags.items() if v != None])).rstrip(), xml_encode(unicode(word)), XML_WORD )) if not chunk: # Close the <chink> element if outside of a chunk. indent = pop(indent); xml.append(indent + "</%s>" % XML_CHINK) if chunk and chunk.stop-1 == word.index: # Close the <chunk> element if this is the last word in the chunk. indent = pop(indent); xml.append(indent + "</%s>" % XML_CHUNK) if pnp and pnp.stop-1 == word.index: # Close the PNP element if this is the last word in the PNP. indent = pop(indent); xml.append(indent + "</%s>" % XML_CHUNK) xml.append("</%s>" % XML_SENTENCE) # Return as a plain str. return "\n".join(xml).encode("utf-8")
0.007165
def save(self): """Write changed .pth file back to disk""" if not self.dirty: return data = '\n'.join(map(self.make_relative, self.paths)) if data: log.debug("Saving %s", self.filename) data = ( "import sys; sys.__plen = len(sys.path)\n" "%s\n" "import sys; new=sys.path[sys.__plen:];" " del sys.path[sys.__plen:];" " p=getattr(sys,'__egginsert',0); sys.path[p:p]=new;" " sys.__egginsert = p+len(new)\n" ) % data if os.path.islink(self.filename): os.unlink(self.filename) f = open(self.filename, 'wt') f.write(data) f.close() elif os.path.exists(self.filename): log.debug("Deleting empty %s", self.filename) os.unlink(self.filename) self.dirty = False
0.002139
def set_slats_level(self, slatsLevel=0.0, shutterLevel=None): """ sets the slats and shutter level Args: slatsLevel(float): the new level of the slats. 0.0 = open, 1.0 = closed, shutterLevel(float): the new level of the shutter. 0.0 = open, 1.0 = closed, None = use the current value Returns: the result of the _restCall """ if shutterLevel is None: shutterLevel = self.shutterLevel data = { "channelIndex": 1, "deviceId": self.id, "slatsLevel": slatsLevel, "shutterLevel": shutterLevel, } return self._restCall("device/control/setSlatsLevel", json.dumps(data))
0.00554
def glossary( self, term, definition): """*genarate a MMD glossary* **Key Arguments:** - ``term`` -- the term to add as a glossary item - ``definition`` -- the definition of the glossary term **Return:** - ``glossary`` -- the glossary text **Usage:** To genarate a glossary item: .. code-block:: python text = \"\"\"Pomaceous fruit of plants of the genus Malus in the family Rosaceae. Also the makers of really great products.\"\"\" definition = md.glossary("Apple", text) print definition # OUTPUT: # [^apple] # # [^apple]: Apple # Pomaceous fruit of plants of the genus Malus in the family Rosaceae. # Also the makers of really great products. """ term = term.strip() term = term.lower() title = term.title() definition = definition.strip() regex = re.compile(r'\n(\S)') definition = regex.sub("\n \g<1>", definition) return "[^%(term)s]\n\n[^%(term)s]: %(title)s\n %(definition)s" % locals()
0.005521
def on_connection_open(self, connection): """This method is called by pika once the connection to RabbitMQ has been established. :type connection: pika.TornadoConnection """ LOGGER.debug('Connection opened') connection.add_on_connection_blocked_callback( self.on_connection_blocked) connection.add_on_connection_unblocked_callback( self.on_connection_unblocked) connection.add_backpressure_callback(self.on_back_pressure_detected) self.channel = self._open_channel()
0.003546
def trim_data_back_to(monthToKeep): """ This method will remove data from the summary text file and the dictionary file for tests that occurs before the number of months specified by monthToKeep. :param monthToKeep: :return: """ global g_failed_tests_info_dict current_time = time.time() # unit in seconds oldest_time_allowed = current_time - monthToKeep*30*24*3600 # in seconds clean_up_failed_test_dict(oldest_time_allowed) clean_up_summary_text(oldest_time_allowed)
0.005769
def profiler(profiles, projectpath,parameters,serviceid,servicename,serviceurl,printdebug=None): """Given input files and parameters, produce metadata for outputfiles. Returns a list of matched profiles (empty if none match), and a program.""" parameters = sanitizeparameters(parameters) matched = [] program = Program(projectpath) for profile in profiles: if profile.match(projectpath, parameters)[0]: matched.append(profile) program.update( profile.generate(projectpath,parameters,serviceid,servicename,serviceurl) ) return matched, program
0.024958
def all_folders( path_name, keyword='', has_date=False, date_fmt=DATE_FMT ) -> list: """ Search all folders with criteria Returned list will be sorted by last modified Args: path_name: full path name keyword: keyword to search has_date: whether has date in file name (default False) date_fmt: date format to check for has_date parameter Returns: list: all folder names fulfilled criteria """ if not os.path.exists(path=path_name): return [] path_name = path_name.replace('\\', '/') if keyword: folders = sort_by_modified([ f.replace('\\', '/') for f in glob.iglob(f'{path_name}/*{keyword}*') if os.path.isdir(f) and (f.replace('\\', '/').split('/')[-1][0] != '~') ]) else: folders = sort_by_modified([ f'{path_name}/{f}' for f in os.listdir(path=path_name) if os.path.isdir(f'{path_name}/{f}') and (f[0] != '~') ]) if has_date: folders = filter_by_dates(folders, date_fmt=date_fmt) return folders
0.003683
def _run__http(self, action, replace): """More complex HTTP query.""" query = action['query'] # self._debug = True url = '{type}://{host}{path}'.format(path=query['path'], **action) content = None method = query.get('method', "get").lower() self.debug("{} {} url={}\n", action['type'], method, url) if method == "post": content = query['content'] headers = query.get('headers', {}) if replace and action.get('template'): self.rfxcfg.macro_expand(url, replace) if content: if isinstance(content, dict): for key, value in content.items(): content[key] = self.rfxcfg.macro_expand(value, replace) else: content = self.rfxcfg.macro_expand(content, replace) newhdrs = dict() for key, value in headers.items(): newhdrs[key.lower()] = self.rfxcfg.macro_expand(value, replace) headers = newhdrs self.debug("{} headers={}\n", action['type'], headers) self.debug("{} content={}\n", action['type'], content) if content and isinstance(content, dict): content = json.dumps(content) self.logf("Action {name} {type}\n", **action) result = getattr(requests, method)(url, headers=headers, data=content, timeout=action.get('timeout', 5)) expect = action.get('expect', {}) expected_codes = expect.get("response-codes", (200, 201, 202, 204)) self.debug("{} expect codes={}\n", action['type'], expected_codes) self.debug("{} status={} content={}\n", action['type'], result.status_code, result.text) if result.status_code not in expected_codes: self.die("Unable to make {} call, unexpected result ({})", action['type'], result.status_code) if 'content' in expect: self.debug("{} expect content={}\n", action['type'], expect['content']) if expect['content'] not in result.text: self.die("{} call to {} failed\nExpected: {}\nReceived:\n{}", action['type'], url, expect['content'], result.text) if 'regex' in expect: self.debug("{} expect regex={}\n", action['type'], expect['regex']) if not re.search(expect['regex'], result.text): self.die("{} call to {} failed\nRegex: {}\nDid not match:\n{}", action['type'], url, expect['regex'], result.text) self.log(result.text, level=common.log_msg) self.logf("Success, status={}\n", result.status_code, level=common.log_good) return True
0.002204
def _try_join_cancelled_thread(thread): """Join a thread, but if the thread doesn't terminate for some time, ignore it instead of waiting infinitely.""" thread.join(10) if thread.is_alive(): logging.warning("Thread %s did not terminate within grace period after cancellation", thread.name)
0.008902
def get_request_data(self, var_name, full_data=False): """ :param var_name: :param full_data: If you want `.to_array()` with this data, ready to be sent. :return: A tuple of `to_array()` dict and the files (:py:func:`InputFile.get_request_files()`). Files can be None, if no file was given, but an url or existing `file_id`. If `self.media` is an `InputFile` however, the first tuple element (either the string, or the dict's `['media']` if `full_data=True`), will be set to `attach://{var_name}_media` automatically. If `self.thumb` is an `InputFile` however, the first tuple element's `['thumb']`, will be set to `attach://{var_name}_thumb` automatically. """ if not full_data: raise ArithmeticError('we have a thumbnail, please use `full_data=True`.') # end if file = {} data, file_to_add = super(InputMediaWithThumb, self).get_request_data(var_name, full_data=True) if file_to_add: file.update(file_to_add) # end if data['thumb'], file_to_add = self.get_inputfile_data(self.thumb, var_name, suffix='_thumb') if data['thumb'] is None: del data['thumb'] # having `'thumb': null` in the json produces errors. # end if if file_to_add: file.update(file_to_add) # end if return data, (file or None)
0.007498
def push_chunk(self, x, timestamp=0.0, pushthrough=True): """Push a list of samples into the outlet. samples -- A list of samples, either as a list of lists or a list of multiplexed values. timestamp -- Optionally the capture time of the most recent sample, in agreement with local_clock(); if omitted, the current time is used. The time stamps of other samples are automatically derived according to the sampling rate of the stream. (default 0.0) pushthrough Whether to push the chunk through to the receivers instead of buffering it with subsequent samples. Note that the chunk_size, if specified at outlet construction, takes precedence over the pushthrough flag. (default True) """ try: n_values = self.channel_count * len(x) data_buff = (self.value_type * n_values).from_buffer(x) handle_error(self.do_push_chunk(self.obj, data_buff, c_long(n_values), c_double(timestamp), c_int(pushthrough))) except TypeError: if len(x): if type(x[0]) is list: x = [v for sample in x for v in sample] if self.channel_format == cf_string: x = [v.encode('utf-8') for v in x] if len(x) % self.channel_count == 0: constructor = self.value_type*len(x) # noinspection PyCallingNonCallable handle_error(self.do_push_chunk(self.obj, constructor(*x), c_long(len(x)), c_double(timestamp), c_int(pushthrough))) else: raise ValueError("each sample must have the same number of " "channels.")
0.005102
def delete_file(self, fid): """ Delete file from WeedFS :param string fid: File ID """ url = self.get_file_url(fid) return self.conn.delete_data(url)
0.010101
def type_to_string(t): """Get string representation of memory type""" if t == MemoryElement.TYPE_I2C: return 'I2C' if t == MemoryElement.TYPE_1W: return '1-wire' if t == MemoryElement.TYPE_DRIVER_LED: return 'LED driver' if t == MemoryElement.TYPE_LOCO: return 'Loco Positioning' if t == MemoryElement.TYPE_TRAJ: return 'Trajectory' if t == MemoryElement.TYPE_LOCO2: return 'Loco Positioning 2' return 'Unknown'
0.003656
def archive(folder, dry_run=False): "Move an active project to the archive." # error handling on archive_dir already done in main() for f in folder: if not os.path.exists(f): bail('folder does not exist: ' + f) _archive_safe(folder, PROJ_ARCHIVE, dry_run=dry_run)
0.003322
def _eval_kwargs(self): """Evaluates any parameterized methods in the kwargs""" evaled_kwargs = {} for k, v in self.p.kwargs.items(): if util.is_param_method(v): v = v() evaled_kwargs[k] = v return evaled_kwargs
0.007067
def send_contact(chat_id, phone_number, first_name, last_name=None, reply_to_message_id=None, reply_markup=None, disable_notification=False, **kwargs): """ Use this method to send phone contacts. :param chat_id: Unique identifier for the target chat or username of the target channel (in the format @channelusername) :param phone_number: Contact's phone number. :param first_name: Contact's first name. :param last_name: Contact's last name. :param reply_to_message_id: If the message is a reply, ID of the original message :param reply_markup: Additional interface options. A JSON-serialized object for a custom reply keyboard, instructions to hide keyboard or to force a reply from the user. :param disable_notification: Sends the message silently. iOS users will not receive a notification, Android users will receive a notification with no sound. Other apps coming soon. :param kwargs: Args that get passed down to :class:`TelegramBotRPCRequest` :type chat_id: int or str :type phone_number: str :type first_name: str :type last_name: str :type reply_to_message_id: int :type reply_markup: ReplyKeyboardMarkup or ReplyKeyboardHide or ForceReply :type disable_notification: bool :returns: On success, the sent Message is returned. :rtype: TelegramBotRPCRequest """ # required args params = dict( chat_id=chat_id, phone_number=phone_number, first_name=first_name, ) # optional args params.update( _clean_params( last_name=last_name, reply_to_message_id=reply_to_message_id, reply_markup=reply_markup, disable_notification=disable_notification, ) ) return TelegramBotRPCRequest('sendContact', params=params, on_result=Message.from_result, **kwargs)
0.004566
def scale_0to1(image_in, exclude_outliers_below=False, exclude_outliers_above=False): """Scale the two images to [0, 1] based on min/max from both. Parameters ----------- image_in : ndarray Input image exclude_outliers_{below,above} : float Lower/upper limit, a value between 0 and 100. Returns ------- scaled_image : ndarray clipped and/or scaled image """ min_value = image_in.min() max_value = image_in.max() # making a copy to ensure no side-effects image = image_in.copy() if exclude_outliers_below: perctl = float(exclude_outliers_below) image[image < np.percentile(image, perctl)] = min_value if exclude_outliers_above: perctl = float(exclude_outliers_above) image[image > np.percentile(image, 100.0 - perctl)] = max_value image = (image - min_value) / (max_value - min_value) return image
0.001043
def _request_new_chunk(self): """ Called to request a new chunk of data to be read from the Crazyflie """ # Figure out the length of the next request new_len = self._bytes_left if new_len > _ReadRequest.MAX_DATA_LENGTH: new_len = _ReadRequest.MAX_DATA_LENGTH logger.debug('Requesting new chunk of {}bytes at 0x{:X}'.format( new_len, self._current_addr)) # Request the data for the next address pk = CRTPPacket() pk.set_header(CRTPPort.MEM, CHAN_READ) pk.data = struct.pack('<BIB', self.mem.id, self._current_addr, new_len) reply = struct.unpack('<BBBBB', pk.data[:-1]) self.cf.send_packet(pk, expected_reply=reply, timeout=1)
0.002649
def add_exac_info(genes, alias_genes, exac_lines): """Add information from the exac genes Currently we only add the pLi score on gene level The exac resource only use HGNC symbol to identify genes so we need our alias mapping. Args: genes(dict): Dictionary with all genes alias_genes(dict): Genes mapped to all aliases ensembl_lines(iteable): Iteable with raw ensembl info """ LOG.info("Add exac pli scores") for exac_gene in parse_exac_genes(exac_lines): hgnc_symbol = exac_gene['hgnc_symbol'].upper() pli_score = exac_gene['pli_score'] for hgnc_id in get_correct_ids(hgnc_symbol, alias_genes): genes[hgnc_id]['pli_score'] = pli_score
0.007895
def create_from_hdu(cls, hdu, ebins=None): """ Creates an HPX object from a FITS header. hdu : The FITS hdu ebins : Energy bin edges [optional] """ convname = HPX.identify_HPX_convention(hdu.header) conv = HPX_FITS_CONVENTIONS[convname] try: pixels = hdu.data[conv.idxstring] except KeyError: pixels = None return cls.create_from_header(hdu.header, ebins, pixels)
0.00431
def add_command(self, handler, name=None): """Add a subcommand `name` which invokes `handler`. """ if name is None: name = docstring_to_subcommand(handler.__doc__) # TODO: Prevent overwriting 'help'? self._commands[name] = handler
0.007067
def mine_urls(urls, params=None, callback=None, **kwargs): """Concurrently retrieve URLs. :param urls: A set of URLs to concurrently retrieve. :type urls: iterable :param params: (optional) The URL parameters to send with each request. :type params: dict :param callback: (optional) A callback function to be called on each :py:class:`aiohttp.client.ClientResponse`. :param \*\*kwargs: (optional) Arguments that ``get_miner`` takes. """ miner = Miner(**kwargs) try: miner.loop.add_signal_handler(signal.SIGINT, miner.close) miner.loop.run_until_complete(miner.mine_urls(urls, params, callback)) except RuntimeError: pass
0.004098
def _generate_examples(self, archive_paths, objects_getter, bboxes_getter, prefixes=None): """Yields examples.""" trainable_classes = set( self.info.features['objects_trainable']['label'].names) for i, archive_path in enumerate(archive_paths): prefix = prefixes[i] if prefixes else None objects = objects_getter(prefix) bboxes = bboxes_getter(prefix) logging.info('Opening archive %s ...', archive_path) archive = tfds.download.iter_archive( archive_path, tfds.download.ExtractMethod.TAR_STREAM) for fpath, fobj in archive: fname = os.path.basename(fpath) image_id = int(os.path.splitext(fname)[0], 16) image_objects = [obj._asdict() for obj in objects.get(image_id, [])] image_bboxes = [bbox._asdict() for bbox in bboxes.get(image_id, [])] image_objects_trainable = [ obj for obj in image_objects if obj['label'] in trainable_classes ] yield { 'image': _resize_image_if_necessary( fobj, target_pixels=self.builder_config.target_pixels), 'image/filename': fname, 'objects': image_objects, 'objects_trainable': image_objects_trainable, 'bobjects': image_bboxes, }
0.00613
def set_current_canvas(canvas): """ Make a canvas active. Used primarily by the canvas itself. """ # Notify glir canvas.context._do_CURRENT_command = True # Try to be quick if canvasses and canvasses[-1]() is canvas: return # Make this the current cc = [c() for c in canvasses if c() is not None] while canvas in cc: cc.remove(canvas) cc.append(canvas) canvasses[:] = [weakref.ref(c) for c in cc]
0.004376
def _validate_alias_name(alias_name): """ Check if the alias name is valid. Args: alias_name: The name of the alias to validate. """ if not alias_name: raise CLIError(EMPTY_ALIAS_ERROR) if not re.match('^[a-zA-Z]', alias_name): raise CLIError(INVALID_STARTING_CHAR_ERROR.format(alias_name[0]))
0.002915
def _iter_convert_to_object(self, iterable): """Iterable yields tuples of (binsha, mode, name), which will be converted to the respective object representation""" for binsha, mode, name in iterable: path = join_path(self.path, name) try: yield self._map_id_to_type[mode >> 12](self.repo, binsha, mode, path) except KeyError: raise TypeError("Unknown mode %o found in tree data for path '%s'" % (mode, path))
0.01002
def ParseID3v1(data): """Parse an ID3v1 tag, returning a list of ID3v2.4 frames.""" try: data = data[data.index(b'TAG'):] except ValueError: return None if 128 < len(data) or len(data) < 124: return None # Issue #69 - Previous versions of Mutagen, when encountering # out-of-spec TDRC and TYER frames of less than four characters, # wrote only the characters available - e.g. "1" or "" - into the # year field. To parse those, reduce the size of the year field. # Amazingly, "0s" works as a struct format string. unpack_fmt = "3s30s30s30s%ds29sBB" % (len(data) - 124) try: tag, title, artist, album, year, comment, track, genre = unpack( unpack_fmt, data) except StructError: return None if tag != b"TAG": return None def fix(data): return data.split(b'\x00')[0].strip().decode('latin1') title, artist, album, year, comment = map( fix, [title, artist, album, year, comment]) frames = {} if title: frames['TIT2'] = TIT2(encoding=0, text=title) if artist: frames['TPE1'] = TPE1(encoding=0, text=[artist]) if album: frames['TALB'] = TALB(encoding=0, text=album) if year: frames['TDRC'] = TDRC(encoding=0, text=year) if comment: frames['COMM'] = COMM(encoding=0, lang='eng', desc="ID3v1 Comment", text=comment) # Don't read a track number if it looks like the comment was # padded with spaces instead of nulls (thanks, WinAmp). if track and ((track != 32) or (data[-3] == b'\x00'[0])): frames['TRCK'] = TRCK(encoding=0, text=str(track)) if genre != 255: frames['TCON'] = TCON(encoding=0, text=str(genre)) return frames
0.000559
def transformer_tall_train_uniencdec(): """Train CNN/DM with a unidirectional encoder and decoder.""" hparams = transformer_tall() hparams.max_input_seq_length = 750 hparams.max_target_seq_length = 100 hparams.optimizer = "true_adam" hparams.learning_rate_schedule = ("linear_warmup*constant*cosdecay") hparams.learning_rate_decay_steps = 150000 hparams.learning_rate_constant = 2e-4 hparams.unidirectional_encoder = True return hparams
0.024123
def _from_dict(cls, _dict): """Initialize a RuntimeEntity object from a json dictionary.""" args = {} if 'entity' in _dict: args['entity'] = _dict.get('entity') else: raise ValueError( 'Required property \'entity\' not present in RuntimeEntity JSON' ) if 'location' in _dict: args['location'] = _dict.get('location') else: raise ValueError( 'Required property \'location\' not present in RuntimeEntity JSON' ) if 'value' in _dict: args['value'] = _dict.get('value') else: raise ValueError( 'Required property \'value\' not present in RuntimeEntity JSON') if 'confidence' in _dict: args['confidence'] = _dict.get('confidence') if 'metadata' in _dict: args['metadata'] = _dict.get('metadata') if 'groups' in _dict: args['groups'] = [ CaptureGroup._from_dict(x) for x in (_dict.get('groups')) ] return cls(**args)
0.004488
def start(self): """Start process.""" logger.debug(str(' '.join(self._cmd_list))) if not self._fired: self._partial_ouput = None self._process.start(self._cmd_list[0], self._cmd_list[1:]) self._timer.start() else: raise CondaProcessWorker('A Conda ProcessWorker can only run once ' 'per method call.')
0.004773
def to_pickle(graph: BELGraph, file: Union[str, BinaryIO], protocol: int = HIGHEST_PROTOCOL) -> None: """Write this graph to a pickle object with :func:`networkx.write_gpickle`. Note that the pickle module has some incompatibilities between Python 2 and 3. To export a universally importable pickle, choose 0, 1, or 2. :param graph: A BEL graph :param file: A file or filename to write to :param protocol: Pickling protocol to use. Defaults to ``HIGHEST_PROTOCOL``. .. seealso:: https://docs.python.org/3.6/library/pickle.html#data-stream-format """ raise_for_not_bel(graph) nx.write_gpickle(graph, file, protocol=protocol)
0.007508
def umi_transform(data): """ transform each read by identifying the barcode and UMI for each read and putting the information in the read name """ fq1 = data["files"][0] umi_dir = os.path.join(dd.get_work_dir(data), "umis") safe_makedir(umi_dir) transform = dd.get_umi_type(data) if not transform: logger.info("No UMI transform specified, assuming pre-transformed data.") if is_transformed(fq1): logger.info("%s detected as pre-transformed, passing it on unchanged." % fq1) data["files"] = [fq1] return data else: logger.error("No UMI transform was specified, but %s does not look " "pre-transformed. Assuming non-umi data." % fq1) return data if file_exists(transform): transform_file = transform else: transform_file = get_transform_file(transform) if not file_exists(transform_file): logger.error( "The UMI transform can be specified as either a file or a " "bcbio-supported transform. Either the file %s does not exist " "or the transform is not supported by bcbio. Supported " "transforms are %s." % (dd.get_umi_type(data), ", ".join(SUPPORTED_TRANSFORMS))) sys.exit(1) out_base = dd.get_sample_name(data) + ".umitransformed.fq.gz" out_file = os.path.join(umi_dir, out_base) if file_exists(out_file): data["files"] = [out_file] return data umis = config_utils.get_program("umis", data, default="umis") cores = dd.get_num_cores(data) # skip transformation if the file already looks transformed with open_fastq(fq1) as in_handle: read = next(in_handle) if "UMI_" in read: data["files"] = [out_file] return data cmd = ("{umis} fastqtransform {transform_file} " "--cores {cores} " "{fq1}" "| seqtk seq -L 20 - | gzip > {tx_out_file}") message = ("Inserting UMI and barcode information into the read name of %s" % fq1) with file_transaction(out_file) as tx_out_file: do.run(cmd.format(**locals()), message) data["files"] = [out_file] return data
0.001747
def read(self, to_read, timeout_ms): """Reads data from this file. in to_read of type int Number of bytes to read. in timeout_ms of type int Timeout (in ms) to wait for the operation to complete. Pass 0 for an infinite timeout. return data of type str Array of data read. raises :class:`OleErrorNotimpl` The method is not implemented yet. """ if not isinstance(to_read, baseinteger): raise TypeError("to_read can only be an instance of type baseinteger") if not isinstance(timeout_ms, baseinteger): raise TypeError("timeout_ms can only be an instance of type baseinteger") data = self._call("read", in_p=[to_read, timeout_ms]) return data
0.007177
def _set_alarm_owner(self, v, load=False): """ Setter method for alarm_owner, mapped from YANG variable /rmon/alarm_entry/alarm_owner (owner-string) If this variable is read-only (config: false) in the source YANG file, then _set_alarm_owner is considered as a private method. Backends looking to populate this variable should do so via calling thisObj._set_alarm_owner() directly. """ if hasattr(v, "_utype"): v = v._utype(v) try: t = YANGDynClass(v,base=RestrictedClassType(base_type=unicode, restriction_dict={'pattern': u'[a-zA-Z]{1}([-a-zA-Z0-9\\.\\\\\\\\@#\\+\\*\\(\\)=\\{~\\}%<>=$_\\[\\]\\|]{0,14})', 'length': [u'1 .. 15']}), is_leaf=True, yang_name="alarm-owner", rest_name="owner", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'tailf-common': {u'info': u'Owner identity', u'alt-name': u'owner'}}, namespace='urn:brocade.com:mgmt:brocade-rmon', defining_module='brocade-rmon', yang_type='owner-string', is_config=True) except (TypeError, ValueError): raise ValueError({ 'error-string': """alarm_owner must be of a type compatible with owner-string""", 'defined-type': "brocade-rmon:owner-string", 'generated-type': """YANGDynClass(base=RestrictedClassType(base_type=unicode, restriction_dict={'pattern': u'[a-zA-Z]{1}([-a-zA-Z0-9\\.\\\\\\\\@#\\+\\*\\(\\)=\\{~\\}%<>=$_\\[\\]\\|]{0,14})', 'length': [u'1 .. 15']}), is_leaf=True, yang_name="alarm-owner", rest_name="owner", parent=self, path_helper=self._path_helper, extmethods=self._extmethods, register_paths=True, extensions={u'tailf-common': {u'info': u'Owner identity', u'alt-name': u'owner'}}, namespace='urn:brocade.com:mgmt:brocade-rmon', defining_module='brocade-rmon', yang_type='owner-string', is_config=True)""", }) self.__alarm_owner = t if hasattr(self, '_set'): self._set()
0.005211
def new_event(event): """ Requests a new event be created in the store. http://msdn.microsoft.com/en-us/library/aa564690(v=exchg.140).aspx <m:CreateItem SendMeetingInvitations="SendToAllAndSaveCopy" xmlns:m="http://schemas.microsoft.com/exchange/services/2006/messages" xmlns:t="http://schemas.microsoft.com/exchange/services/2006/types"> <m:SavedItemFolderId> <t:DistinguishedFolderId Id="calendar"/> </m:SavedItemFolderId> <m:Items> <t:CalendarItem> <t:Subject>{event.subject}</t:Subject> <t:Body BodyType="HTML">{event.subject}</t:Body> <t:Start></t:Start> <t:End></t:End> <t:Location></t:Location> <t:RequiredAttendees> {% for attendee_email in meeting.required_attendees %} <t:Attendee> <t:Mailbox> <t:EmailAddress>{{ attendee_email }}</t:EmailAddress> </t:Mailbox> </t:Attendee> HTTPretty {% endfor %} </t:RequiredAttendees> {% if meeting.optional_attendees %} <t:OptionalAttendees> {% for attendee_email in meeting.optional_attendees %} <t:Attendee> <t:Mailbox> <t:EmailAddress>{{ attendee_email }}</t:EmailAddress> </t:Mailbox> </t:Attendee> {% endfor %} </t:OptionalAttendees> {% endif %} {% if meeting.conference_room %} <t:Resources> <t:Attendee> <t:Mailbox> <t:EmailAddress>{{ meeting.conference_room.email }}</t:EmailAddress> </t:Mailbox> </t:Attendee> </t:Resources> {% endif %} </t:CalendarItem> </m:Items> </m:CreateItem> """ id = T.DistinguishedFolderId(Id=event.calendar_id) if event.calendar_id in DISTINGUISHED_IDS else T.FolderId(Id=event.calendar_id) start = convert_datetime_to_utc(event.start) end = convert_datetime_to_utc(event.end) root = M.CreateItem( M.SavedItemFolderId(id), M.Items( T.CalendarItem( T.Subject(event.subject), T.Body(event.body or u'', BodyType="HTML"), ) ), SendMeetingInvitations="SendToAllAndSaveCopy" ) calendar_node = root.xpath(u'/m:CreateItem/m:Items/t:CalendarItem', namespaces=NAMESPACES)[0] if event.reminder_minutes_before_start: calendar_node.append(T.ReminderIsSet('true')) calendar_node.append(T.ReminderMinutesBeforeStart(str(event.reminder_minutes_before_start))) else: calendar_node.append(T.ReminderIsSet('false')) calendar_node.append(T.Start(start.strftime(EXCHANGE_DATETIME_FORMAT))) calendar_node.append(T.End(end.strftime(EXCHANGE_DATETIME_FORMAT))) if event.is_all_day: calendar_node.append(T.IsAllDayEvent('true')) calendar_node.append(T.Location(event.location or u'')) if event.required_attendees: calendar_node.append(resource_node(element=T.RequiredAttendees(), resources=event.required_attendees)) if event.optional_attendees: calendar_node.append(resource_node(element=T.OptionalAttendees(), resources=event.optional_attendees)) if event.resources: calendar_node.append(resource_node(element=T.Resources(), resources=event.resources)) if event.recurrence: if event.recurrence == u'daily': recurrence = T.DailyRecurrence( T.Interval(str(event.recurrence_interval)), ) elif event.recurrence == u'weekly': recurrence = T.WeeklyRecurrence( T.Interval(str(event.recurrence_interval)), T.DaysOfWeek(event.recurrence_days), ) elif event.recurrence == u'monthly': recurrence = T.AbsoluteMonthlyRecurrence( T.Interval(str(event.recurrence_interval)), T.DayOfMonth(str(event.start.day)), ) elif event.recurrence == u'yearly': recurrence = T.AbsoluteYearlyRecurrence( T.DayOfMonth(str(event.start.day)), T.Month(event.start.strftime("%B")), ) calendar_node.append( T.Recurrence( recurrence, T.EndDateRecurrence( T.StartDate(event.start.strftime(EXCHANGE_DATE_FORMAT)), T.EndDate(event.recurrence_end_date.strftime(EXCHANGE_DATE_FORMAT)), ) ) ) return root
0.006725
def get_resampled_top_edge(self, angle_var=0.1): """ This methods computes a simplified representation of a fault top edge by removing the points that are not describing a change of direction, provided a certain tolerance angle. :param float angle_var: Number representing the maximum deviation (in degrees) admitted without the creation of a new segment :returns: A :class:`~openquake.hazardlib.geo.line.Line` representing the rupture surface's top edge. """ mesh = self.mesh top_edge = [Point(mesh.lons[0][0], mesh.lats[0][0], mesh.depths[0][0])] for i in range(len(mesh.triangulate()[1][0]) - 1): v1 = numpy.asarray(mesh.triangulate()[1][0][i]) v2 = numpy.asarray(mesh.triangulate()[1][0][i + 1]) cosang = numpy.dot(v1, v2) sinang = numpy.linalg.norm(numpy.cross(v1, v2)) angle = math.degrees(numpy.arctan2(sinang, cosang)) if abs(angle) > angle_var: top_edge.append(Point(mesh.lons[0][i + 1], mesh.lats[0][i + 1], mesh.depths[0][i + 1])) top_edge.append(Point(mesh.lons[0][-1], mesh.lats[0][-1], mesh.depths[0][-1])) line_top_edge = Line(top_edge) return line_top_edge
0.001404
def content(): """Helper method that returns just the content. This method was added so that the text could be reused in the dock_help module. .. versionadded:: 3.2.2 :returns: A message object without brand element. :rtype: safe.messaging.message.Message """ message = m.Message() paragraph = m.Paragraph( m.Image( 'file:///%s/img/screenshots/' 'osm-downloader-screenshot.png' % resources_path()), style_class='text-center' ) message.add(paragraph) body = tr( 'This tool will fetch building (\'structure\') or road (' '\'highway\') data from the OpenStreetMap project for you. ' 'The downloaded data will have InaSAFE keywords defined and a ' 'default QGIS style applied. To use this tool effectively:' ) tips = m.BulletedList() tips.add(tr( 'Your current extent, when opening this window, will be used to ' 'determine the area for which you want data to be retrieved. ' 'You can interactively select the area by using the ' '\'select on map\' button - which will temporarily hide this ' 'window and allow you to drag a rectangle on the map. After you ' 'have finished dragging the rectangle, this window will ' 'reappear.')) tips.add(tr( 'Check the output directory is correct. Note that the saved ' 'dataset will be named after the type of data being downloaded ' 'e.g. roads.shp or buildings.shp (and associated files).' )) tips.add(tr( 'By default simple file names will be used (e.g. roads.shp, ' 'buildings.shp). If you wish you can specify a prefix to ' 'add in front of this default name. For example using a prefix ' 'of \'padang-\' will cause the downloaded files to be saved as ' '\'padang-roads.shp\' and \'padang-buildings.shp\'. Note that ' 'the only allowed prefix characters are A-Z, a-z, 0-9 and the ' 'characters \'-\' and \'_\'. You can leave this blank if you ' 'prefer.' )) tips.add(tr( 'If a dataset already exists in the output directory it will be ' 'overwritten.' )) tips.add(tr( 'This tool requires a working internet connection and fetching ' 'buildings or roads will consume your bandwidth.')) tips.add(m.Link( 'http://www.openstreetmap.org/copyright', text=tr( 'Downloaded data is copyright OpenStreetMap contributors ' '(click for more info).') )) message.add(m.Paragraph(body)) message.add(tips) message.add(m.Paragraph( # format 'When the __Political boundaries__' for proper i18n tr('When the %s ' 'box in the Feature types menu is ticked, the Political boundary ' 'options panel will be enabled. The panel lets you select which ' 'admin level you wish to download. The admin levels are country ' 'specific. When you select an admin level, the local name for ' 'that admin level will be shown. You can change which country ' 'is used for the admin level description using the country drop ' 'down menu. The country will be automatically set to coincide ' 'with the view extent if a matching country can be found.') % ( m.ImportantText(tr('Political boundaries')).to_html(), ))) message.add(m.Paragraph( m.ImportantText(tr('Note: ')), tr( 'We have only provide presets for a subset of the available ' 'countries. If you want to know what the levels are for your ' 'country, please check on the following web page: '), m.Link( 'http://wiki.openstreetmap.org/wiki/Tag:boundary%3Dadministrative', text=tr( 'List of OSM Admin Boundary definitions ')))) return message
0.000253
def update(self, new_games): """ new_games is a list of .tfrecord.zz new game records. """ new_games.sort(key=os.path.basename) first_new_game = None for idx, game in enumerate(new_games): timestamp = file_timestamp(game) if timestamp <= self.examples[-1][0]: continue elif first_new_game is None: first_new_game = idx num_new_games = len(new_games) - idx print("Found {}/{} new games".format( num_new_games, len(new_games))) self.total_updates += num_new_games self.examples.extend(self.func(game)) if first_new_game is None: print("No new games", file_timestamp( new_games[-1]), self.examples[-1][0])
0.002445
def plot_fit(self): """ Add the fit to the plot. """ self.plt.plot(*self.fit.fit, **self.options['fit'])
0.014706
def _group_filter_values(seg, filter_indices, ms_per_input): """ Takes a list of 1s and 0s and returns a list of tuples of the form: ['y/n', timestamp]. """ ret = [] for filter_value, (_segment, timestamp) in zip(filter_indices, seg.generate_frames_as_segments(ms_per_input)): if filter_value == 1: if len(ret) > 0 and ret[-1][0] == 'n': ret.append(['y', timestamp]) # The last one was different, so we create a new one elif len(ret) > 0 and ret[-1][0] == 'y': ret[-1][1] = timestamp # The last one was the same as this one, so just update the timestamp else: ret.append(['y', timestamp]) # This is the first one else: if len(ret) > 0 and ret[-1][0] == 'n': ret[-1][1] = timestamp elif len(ret) > 0 and ret[-1][0] == 'y': ret.append(['n', timestamp]) else: ret.append(['n', timestamp]) return ret
0.003956
def _remove_wire_nets(block): """ Remove all wire nodes from the block. """ wire_src_dict = _ProducerList() wire_removal_set = set() # set of all wirevectors to be removed # one pass to build the map of value producers and # all of the nets and wires to be removed for net in block.logic: if net.op == 'w': wire_src_dict[net.dests[0]] = net.args[0] if not isinstance(net.dests[0], Output): wire_removal_set.add(net.dests[0]) # second full pass to create the new logic without the wire nets new_logic = set() for net in block.logic: if net.op != 'w' or isinstance(net.dests[0], Output): new_args = tuple(wire_src_dict.find_producer(x) for x in net.args) new_net = LogicNet(net.op, net.op_param, new_args, net.dests) new_logic.add(new_net) # now update the block with the new logic and remove wirevectors block.logic = new_logic for dead_wirevector in wire_removal_set: del block.wirevector_by_name[dead_wirevector.name] block.wirevector_set.remove(dead_wirevector) block.sanity_check()
0.00087
def doesIntersect(self, other): ''' :param: other - Line subclass :return: boolean Returns True iff: ccw(self.A,self.B,other.A) * ccw(self.A,self.B,other.B) <= 0 and ccw(other.A,other.B,self.A) * ccw(other.A,other.B,self.B) <= 0 ''' if self.A.ccw(self.B, other.A) * self.A.ccw(self.B, other.B) > 0: return False if other.A.ccw(other.B, self.A) * other.A.ccw(other.B, self.B) > 0: return False return True
0.003781
def onMessageReceived(self, method_frame, properties, body): """ React to received message - deserialize it, add it to users reaction function stored in ``self.react_fn`` and send back result. If `Exception` is thrown during process, it is sent back instead of message. Note: In case of `Exception`, response message doesn't have useful `body`, but in headers is stored following (string) parameters: - ``exception``, where the Exception's message is stored - ``exception_type``, where ``e.__class__`` is stored - ``exception_name``, where ``e.__class__.__name__`` is stored - ``traceback`` where the full traceback is stored (contains line number) This allows you to react to unexpected cases at the other end of the AMQP communication. """ # if UUID is not in headers, just ack the message and ignore it if "UUID" not in properties.headers: self.process_exception( e=ValueError("No UUID provided, message ignored."), uuid="", routing_key=self.parseKey(method_frame), body=body ) return True # ack message key = self.parseKey(method_frame) uuid = properties.headers["UUID"] try: result = self.react_fn( serializers.deserialize(body, self.globals), self.get_sendback(uuid, key) ) print "sending response", key self.sendResponse( serializers.serialize(result), uuid, key ) except Exception, e: self.process_exception( e=e, uuid=uuid, routing_key=key, body=str(e), tb=traceback.format_exc().strip() ) return True
0.001511
def get_locale(self): """ Retrieve the best matching locale using request headers .. note:: Probably one of the thing to enhance quickly. :rtype: str """ best_match = request.accept_languages.best_match(['de', 'fr', 'en', 'la']) if best_match is None: if len(request.accept_languages) > 0: best_match = request.accept_languages[0][0][:2] else: return self.__default_lang__ lang = self.__default_lang__ if best_match == "de": lang = "ger" elif best_match == "fr": lang = "fre" elif best_match == "en": lang = "eng" elif best_match == "la": lang = "lat" return lang
0.003922
def _add_labels(self, axes, dtype): """Given a 2x2 array of axes, add x and y labels Parameters ---------- axes: numpy.ndarray, 2x2 A numpy array containing the four principal axes of an SIP plot dtype: string Can be either 'rho' or 'r', indicating the type of data that is plotted: 'rho' stands for resistivities/conductivities, 'r' stands for impedances/condactances Returns ------- None """ for ax in axes[1, :].flat: ax.set_xlabel('frequency [Hz]') if dtype == 'rho': axes[0, 0].set_ylabel(r'$|\rho| [\Omega m]$') axes[0, 1].set_ylabel(r'$-\phi [mrad]$') axes[1, 0].set_ylabel(r"$\sigma' [S/m]$") axes[1, 1].set_ylabel(r"$\sigma'' [S/m]$") elif dtype == 'r': axes[0, 0].set_ylabel(r'$|R| [\Omega]$') axes[0, 1].set_ylabel(r'$-\phi [mrad]$') axes[1, 0].set_ylabel(r"$Y' [S]$") axes[1, 1].set_ylabel(r"$Y'' [S]$") else: raise Exception('dtype not known: {}'.format(dtype))
0.001741
def geocode( self, query, query_type='StreetAddress', maximum_responses=25, is_freeform=False, filtering=None, exactly_one=True, timeout=DEFAULT_SENTINEL, ): """ Return a location point by address. :param str query: The query string to be geocoded. :param str query_type: The type to provide for geocoding. It can be `PositionOfInterest`, `StreetAddress` or `CadastralParcel`. `StreetAddress` is the default choice if none provided. :param int maximum_responses: The maximum number of responses to ask to the API in the query body. :param str is_freeform: Set if return is structured with freeform structure or a more structured returned. By default, value is False. :param str filtering: Provide string that help setting geocoder filter. It contains an XML string. See examples in documentation and ignfrance.py file in directory tests. :param bool exactly_one: Return one result or a list of results, if available. :param int timeout: Time, in seconds, to wait for the geocoding service to respond before raising a :class:`geopy.exc.GeocoderTimedOut` exception. Set this only if you wish to override, on this call only, the value set during the geocoder's initialization. :rtype: ``None``, :class:`geopy.location.Location` or a list of them, if ``exactly_one=False``. """ query = self.format_string % query # Check if acceptable query type if query_type not in ['PositionOfInterest', 'StreetAddress', 'CadastralParcel']: raise GeocoderQueryError("""You did not provided a query_type the webservice can consume. It should be PositionOfInterest, 'StreetAddress or CadastralParcel""") # Check query validity for CadastralParcel if query_type == 'CadastralParcel' and len(query.strip()) != 14: raise GeocoderQueryError("""You must send a string of fourteen characters long to match the cadastre required code""") sub_request = """ <GeocodeRequest returnFreeForm="{is_freeform}"> <Address countryCode="{query_type}"> <freeFormAddress>{query}</freeFormAddress> {filtering} </Address> </GeocodeRequest> """ xml_request = self.xml_request.format( method_name='LocationUtilityService', sub_request=sub_request, maximum_responses=maximum_responses ) # Manage type change for xml case sensitive if is_freeform: is_freeform = 'true' else: is_freeform = 'false' # Manage filtering value if filtering is None: filtering = '' # Create query using parameters request_string = xml_request.format( is_freeform=is_freeform, query=query, query_type=query_type, filtering=filtering ) params = { 'xls': request_string } url = "?".join((self.api, urlencode(params))) logger.debug("%s.geocode: %s", self.__class__.__name__, url) raw_xml = self._request_raw_content(url, timeout) return self._parse_xml( raw_xml, is_freeform=is_freeform, exactly_one=exactly_one )
0.001082
def _from_json(json_data): """ Creates a Earthquake from json data. :param json_data: The raw json data to parse :type json_data: dict :returns: Earthquake """ try: coordinates = json_data['geometry']['coordinates'] except KeyError: raise USGSException("The geometry information was not returned from the USGS website.") try: properties = json_data['properties'] except KeyError: raise USGSException("One of the earthquakes did not have any property information") return Earthquake(Coordinate._from_json(coordinates), _parse_float(properties.get('mag', '0'), 0.0), properties.get('place', ''), _parse_int(properties.get('time', '0'), 0), properties.get('url', ''), _parse_int(properties.get('felt', '0'), 0), _parse_float(properties.get('cdi', '0'), 0.0), _parse_float(properties.get('mmi', '0'), 0.0), properties['alert'] if 'alert' in properties and properties['alert'] else '', properties.get('status', ''), _parse_int(properties.get('sig', '0'), 0), json_data.get('id', ''), _parse_float(properties.get('dmin', '0'), 0.0), _parse_float(properties.get('rms', '0'), 0.0), _parse_float(properties.get('gap', '0'), 0.0))
0.003683
def export(self, output_folder): """Export matrices as ``*.npy`` files to an output folder.""" if not os.path.exists(output_folder): os.makedirs(output_folder) self._interact_with_folder(output_folder, 'w')
0.008264
def multiple_choice_field_data(field, **kwargs): """ Return random value for MultipleChoiceField >>> CHOICES = [('YNG', 'Child'), ('MIDDLE', 'Parent') ,('OLD', 'GrandParent')] >>> result = any_form_field(forms.MultipleChoiceField(choices=CHOICES)) >>> type(result) <type 'str'> """ if field.choices: from django_any.functions import valid_choices l = list(valid_choices(field.choices)) random.shuffle(l) choices = [] count = xunit.any_int(min_value=1, max_value=len(field.choices)) for i in xrange(0, count): choices.append(l[i]) return ' '.join(choices) return 'None'
0.005935
def set_window_refresh_callback(window, cbfun): """ Sets the refresh callback for the specified window. Wrapper for: GLFWwindowrefreshfun glfwSetWindowRefreshCallback(GLFWwindow* window, GLFWwindowrefreshfun cbfun); """ window_addr = ctypes.cast(ctypes.pointer(window), ctypes.POINTER(ctypes.c_long)).contents.value if window_addr in _window_refresh_callback_repository: previous_callback = _window_refresh_callback_repository[window_addr] else: previous_callback = None if cbfun is None: cbfun = 0 c_cbfun = _GLFWwindowrefreshfun(cbfun) _window_refresh_callback_repository[window_addr] = (cbfun, c_cbfun) cbfun = c_cbfun _glfw.glfwSetWindowRefreshCallback(window, cbfun) if previous_callback is not None and previous_callback[0] != 0: return previous_callback[0]
0.002257
def par_compute_residuals(i): """Compute components of the residual and stopping thresholds that can be done in parallel. Parameters ---------- i : int Index of group to compute """ # Compute the residuals in parallel, need to check if the residuals # depend on alpha global mp_ry0 global mp_ry1 global mp_sy0 global mp_sy1 global mp_nrmAx global mp_nrmBy global mp_nrmu mp_ry0[i] = np.sum((mp_DXnr[i] - mp_Y0[i])**2) mp_ry1[i] = mp_alpha**2*np.sum((mp_Xnr[mp_grp[i]:mp_grp[i+1]]- mp_Y1[mp_grp[i]:mp_grp[i+1]])**2) mp_sy0[i] = np.sum((mp_Y0old[i] - mp_Y0[i])**2) mp_sy1[i] = mp_alpha**2*np.sum((mp_Y1old[mp_grp[i]:mp_grp[i+1]]- mp_Y1[mp_grp[i]:mp_grp[i+1]])**2) mp_nrmAx[i] = np.sum(mp_DXnr[i]**2) + mp_alpha**2 * np.sum( mp_Xnr[mp_grp[i]:mp_grp[i+1]]**2) mp_nrmBy[i] = np.sum(mp_Y0[i]**2) + mp_alpha**2 * np.sum( mp_Y1[mp_grp[i]:mp_grp[i+1]]**2) mp_nrmu[i] = np.sum(mp_U0[i]**2) + np.sum(mp_U1[mp_grp[i]:mp_grp[i+1]]**2)
0.002715
def import_project(controller, project_id, stream, location=None, name=None, keep_compute_id=False): """ Import a project contain in a zip file You need to handle OSerror exceptions :param controller: GNS3 Controller :param project_id: ID of the project to import :param stream: A io.BytesIO of the zipfile :param location: Directory for the project if None put in the default directory :param name: Wanted project name, generate one from the .gns3 if None :param keep_compute_id: If true do not touch the compute id :returns: Project """ if location and ".gns3" in location: raise aiohttp.web.HTTPConflict(text="The destination path should not contain .gns3") try: with zipfile.ZipFile(stream) as myzip: try: topology = json.loads(myzip.read("project.gns3").decode()) # We import the project on top of an existing project (snapshots) if topology["project_id"] == project_id: project_name = topology["name"] else: # If the project name is already used we generate a new one if name: project_name = controller.get_free_project_name(name) else: project_name = controller.get_free_project_name(topology["name"]) except KeyError: raise aiohttp.web.HTTPConflict(text="Can't import topology the .gns3 is corrupted or missing") if location: path = location else: projects_path = controller.projects_directory() path = os.path.join(projects_path, project_id) try: os.makedirs(path, exist_ok=True) except UnicodeEncodeError as e: raise aiohttp.web.HTTPConflict(text="The project name contain non supported or invalid characters") myzip.extractall(path) topology = load_topology(os.path.join(path, "project.gns3")) topology["name"] = project_name # To avoid unexpected behavior (project start without manual operations just after import) topology["auto_start"] = False topology["auto_open"] = False topology["auto_close"] = True # Generate a new node id node_old_to_new = {} for node in topology["topology"]["nodes"]: if "node_id" in node: node_old_to_new[node["node_id"]] = str(uuid.uuid4()) _move_node_file(path, node["node_id"], node_old_to_new[node["node_id"]]) node["node_id"] = node_old_to_new[node["node_id"]] else: node["node_id"] = str(uuid.uuid4()) # Update link to use new id for link in topology["topology"]["links"]: link["link_id"] = str(uuid.uuid4()) for node in link["nodes"]: node["node_id"] = node_old_to_new[node["node_id"]] # Generate new drawings id for drawing in topology["topology"]["drawings"]: drawing["drawing_id"] = str(uuid.uuid4()) # Modify the compute id of the node depending of compute capacity if not keep_compute_id: # For some VM type we move them to the GNS3 VM if possible # unless it's a linux host without GNS3 VM if not sys.platform.startswith("linux") or controller.has_compute("vm"): for node in topology["topology"]["nodes"]: if node["node_type"] in ("docker", "qemu", "iou", "nat"): node["compute_id"] = "vm" else: # Round-robin through available compute resources. compute_nodes = itertools.cycle(controller.computes) for node in topology["topology"]["nodes"]: node["compute_id"] = next(compute_nodes) compute_created = set() for node in topology["topology"]["nodes"]: if node["compute_id"] != "local": # Project created on the remote GNS3 VM? if node["compute_id"] not in compute_created: compute = controller.get_compute(node["compute_id"]) yield from compute.post("/projects", data={ "name": project_name, "project_id": project_id, }) compute_created.add(node["compute_id"]) yield from _move_files_to_compute(compute, project_id, path, os.path.join("project-files", node["node_type"], node["node_id"])) # And we dump the updated.gns3 dot_gns3_path = os.path.join(path, project_name + ".gns3") # We change the project_id to avoid erasing the project topology["project_id"] = project_id with open(dot_gns3_path, "w+") as f: json.dump(topology, f, indent=4) os.remove(os.path.join(path, "project.gns3")) if os.path.exists(os.path.join(path, "images")): _import_images(controller, path) project = yield from controller.load_project(dot_gns3_path, load=False) return project except zipfile.BadZipFile: raise aiohttp.web.HTTPConflict(text="Can't import topology the file is corrupted or not a GNS3 project (invalid zip)")
0.002505
def calculate_backend(name_from_env, backends=None): """ Calculates which backend to use with the following algorithm: - Try to read the GOLESS_BACKEND environment variable. Usually 'gevent' or 'stackless'. If a value is set but no backend is available or it fails to be created, this function will error. - Determine the default backend (gevent for PyPy, stackless for Python). If no default can be determined or created, continue. - Try to create all the runtimes and choose the first one to create successfully. - If no runtime can be created, return a NullBackend, which will error when accessed. The "default" backend is the less-easy backend for a runtime. Since PyPy has stackless by default, gevent is intentional. Since Stackless is a separate interpreter for CPython, that is more intentional than gevent. We feel this is a good default behavior. """ if backends is None: backends = _default_backends if name_from_env: if name_from_env not in backends: raise RuntimeError( 'Invalid backend %r specified. Valid backends are: %s' % (name_from_env, _default_backends.keys())) # Allow this to raise, since it was explicitly set from the environment # noinspection PyCallingNonCallable return backends[name_from_env]() try: return _calc_default(backends) except SystemError: pass for maker in backends.values(): # noinspection PyBroadException try: return maker() except Exception: pass return NullBackend()
0.000599
def _update_yaw_and_pitch(self): """ Updates the camera vectors based on the current yaw and pitch """ front = Vector3([0.0, 0.0, 0.0]) front.x = cos(radians(self.yaw)) * cos(radians(self.pitch)) front.y = sin(radians(self.pitch)) front.z = sin(radians(self.yaw)) * cos(radians(self.pitch)) self.dir = vector.normalise(front) self.right = vector.normalise(vector3.cross(self.dir, self._up)) self.up = vector.normalise(vector3.cross(self.right, self.dir))
0.003738
def get_interfaces(zone, permanent=True): ''' List interfaces bound to a zone .. versionadded:: 2016.3.0 CLI Example: .. code-block:: bash salt '*' firewalld.get_interfaces zone ''' cmd = '--zone={0} --list-interfaces'.format(zone) if permanent: cmd += ' --permanent' return __firewall_cmd(cmd).split()
0.002778
def augment(module_name, base_class): """Call the augment() method for all of the derived classes in the module """ for name, cls in inspect.getmembers(sys.modules[module_name], lambda x : inspect.isclass(x) and issubclass(x, base_class) ): if cls == base_class: continue cls.augment()
0.016484
def see_form(self, url): """ Assert the existence of a HTML form that submits to the given URL. """ elements = ElementSelector( world.browser, str('//form[@action="%s"]' % url), filter_displayed=True, ) if not elements: raise AssertionError("Expected form not found.")
0.003077
def read_tree(input, schema): '''Read a tree from a string or file Args: ``input`` (``str``): Either a tree string, a path to a tree file (plain-text or gzipped), or a DendroPy Tree object ``schema`` (``str``): The schema of ``input`` (DendroPy, Newick, NeXML, or Nexus) Returns: * If the input is Newick, either a ``Tree`` object if ``input`` contains a single tree, or a ``list`` of ``Tree`` objects if ``input`` contains multiple trees (one per line) * If the input is NeXML or Nexus, a ``dict`` of trees represented by ``input``, where keys are tree names (``str``) and values are ``Tree`` objects ''' schema_to_function = { 'dendropy': read_tree_dendropy, 'newick': read_tree_newick, 'nexml': read_tree_nexml, 'nexus': read_tree_nexus } if schema.lower() not in schema_to_function: raise ValueError("Invalid schema: %s (valid options: %s)" % (schema, ', '.join(sorted(schema_to_function.keys())))) return schema_to_function[schema.lower()](input)
0.005666
def download_count_upload(job, master_ip, input_file, output_file, kmer_length, spark_conf, memory, sudo): ''' Runs k-mer counting. 1. If the input file is located in S3, the file is copied into HDFS. 2. If the input file is not in Parquet format, the file is converted into Parquet. 3. The k-mers are counted and saved as text. 4. If the output path is an S3 URL, the file is copied back to S3. :param job: Toil job :param input_file: URL/path to input file to count k-mers on :param output_file: URL/path to save k-mer counts at :param kmer_length: The length of k-mer substrings to count. :param spark_conf: Optional Spark configuration. If set, memory should \ not be set. :param memory: Amount of memory to provided to Spark workers. Must be set \ if spark_conf is not set. :param sudo: Whether or not to run Spark containers with sudo. :type job: toil.Job :type input_file: string :type output_file: string :type kmer_length: int or string :type spark_conf: list of string or None :type memory: int or None :type sudo: boolean ''' if master_ip is not None: hdfs_dir = "hdfs://{0}:{1}/".format(master_ip, HDFS_MASTER_PORT) else: _log.warn('Master IP is not set. If default filesystem is not set, jobs may fail.') hdfs_dir = "" # if the file isn't already in hdfs, copy it in hdfs_input_file = hdfs_dir if input_file.startswith("s3://"): # append the s3 file name to our hdfs path hdfs_input_file += input_file.split("/")[-1] # run the download _log.info("Downloading input file %s to %s.", input_file, hdfs_input_file) call_conductor(job, master_ip, input_file, hdfs_input_file, memory=memory, override_parameters=spark_conf) else: if not input_file.startswith("hdfs://"): _log.warn("If not in S3, input file (%s) expected to be in HDFS (%s).", input_file, hdfs_dir) # where are we writing the output to? is it going to a location in hdfs or not? run_upload = True hdfs_output_file = hdfs_dir + "kmer_output.txt" if output_file.startswith(hdfs_dir): run_upload = False hdfs_output_file = output_file # do we need to convert to adam? if (hdfs_input_file.endswith('.bam') or hdfs_input_file.endswith('.sam') or hdfs_input_file.endswith('.fq') or hdfs_input_file.endswith('.fastq')): hdfs_tmp_file = hdfs_input_file # change the file extension to adam hdfs_input_file = '.'.join(hdfs_input_file.split('.')[:-1].append('adam')) # convert the file _log.info('Converting %s into ADAM format at %s.', hdfs_tmp_file, hdfs_input_file) call_adam(job, master_ip, ['transform', hdfs_tmp_file, hdfs_input_file], memory=memory, override_parameters=spark_conf) # run k-mer counting _log.info('Counting %d-mers in %s, and saving to %s.', kmer_length, hdfs_input_file, hdfs_output_file) call_adam(job, master_ip, ['count_kmers', hdfs_input_file, hdfs_output_file, str(kmer_length)], memory=memory, override_parameters=spark_conf) # do we need to upload the file back? if so, run upload if run_upload: _log.info("Uploading output file %s to %s.", hdfs_output_file, output_file) call_conductor(job, master_ip, hdfs_output_file, output_file, memory=memory, override_parameters=spark_conf)
0.003392
def any_contains_any(strings, candidates): """Whether any of the strings contains any of the candidates.""" for string in strings: for c in candidates: if c in string: return True
0.004386
def GetMemZippedMB(self): '''Undocumented.''' counter = c_uint() ret = vmGuestLib.VMGuestLib_GetMemZippedMB(self.handle.value, byref(counter)) if ret != VMGUESTLIB_ERROR_SUCCESS: raise VMGuestLibException(ret) return counter.value
0.014815
def clear_data(self): """Removes the content data. raise: NoAccess - ``Metadata.isRequired()`` is ``true`` or ``Metadata.isReadOnly()`` is ``true`` *compliance: mandatory -- This method must be implemented.* """ # [email protected], Jan 9, 2015 # Removes the item from AWS S3 and resets URL to '' odl_repo, url = get_aws_s3_handle(self._config_map) existing_url = self._payload.get_url_metadata().get_existing_string_values()[0] # try to clear from payload first, in case that fails we won't mess with AWS self._payload.clear_url() key_path = existing_url.replace(url, '') # for boto3, remove leading / if key_path[0] == '/': key_path = key_path[1::] odl_repo.delete_object( Bucket=self._config_map['s3_bucket'], Key=key_path )
0.004444
def route(rule=None, blueprint=None, defaults=None, endpoint=None, is_member=False, methods=None, only_if=None, **rule_options): """ Decorator to set default route rules for a view function. The arguments this function accepts are very similar to Flask's :meth:`~flask.Flask.route`, however, the ``is_member`` perhaps deserves an example:: class UserResource(ModelResource): class Meta: model = User member_param = '<int:id>' include_methods = ['list', 'get'] @route(is_member=True, methods=['POST']) def set_profile_pic(user): # do stuff # registered like so in your ``app_bundle/routes.py``: routes = lambda: [ resource(UserResource), ] # results in the following routes: # UserResource.list => GET /users # UserResource.get => GET /users/<int:id> # UserResource.set_profile_pic => POST /users/<int:id>/set-profile-pic :param rule: The URL rule. :param defaults: Any default values for parameters in the URL rule. :param endpoint: The endpoint name of this view. Determined automatically if left unspecified. :param is_member: Whether or not this view is for a :class:`~flask_unchained.bundles.resource.resource.Resource` member method. :param methods: A list of HTTP methods supported by this view. Defaults to ``['GET']``. :param only_if: A boolean or callable to dynamically determine whether or not to register this route with the app. :param rule_options: Other kwargs passed on to :class:`~werkzeug.routing.Rule`. """ def wrapper(fn): fn_routes = getattr(fn, FN_ROUTES_ATTR, []) route = Route(rule, fn, blueprint=blueprint, defaults=defaults, endpoint=endpoint, is_member=is_member, methods=methods, only_if=only_if, **rule_options) setattr(fn, FN_ROUTES_ATTR, fn_routes + [route]) return fn if callable(rule): fn = rule rule = None return wrapper(fn) return wrapper
0.002213
def media_url(self, with_ssl=False): """ Used to return a base media URL. Depending on whether we're serving media remotely or locally, this either hands the decision off to the backend, or just uses the value in settings.STATIC_URL. args: with_ssl: (bool) If True, return an HTTPS url (depending on how the backend handles it). """ if self.serve_remote: # Hand this off to whichever backend is being used. url = self.remote_media_url(with_ssl) else: # Serving locally, just use the value in settings.py. url = self.local_media_url return url.rstrip('/')
0.004167
def request(self, api_commands, *, timeout=None): """Make a request. Timeout is in seconds.""" if not isinstance(api_commands, list): return self._execute(api_commands, timeout=timeout) command_results = [] for api_command in api_commands: result = self._execute(api_command, timeout=timeout) command_results.append(result) return command_results
0.004706
def create_child_ref(self, transform_path, child_id=None): """ Creates a new child TransformRef with transform_path specified. :param transform_path: :param child_id: :return: TransformRef child """ transform_ref = TransformRef(transform_path, child_id) self.add_child_ref(transform_ref) return transform_ref
0.005263
def get_tail(self): """Gets tail :return: Tail of linked list """ node = self.head last_node = self.head while node is not None: last_node = node node = node.next_node return last_node
0.007491
def coerce(self, value): """Coerce a single value according to this parameter's settings. @param value: A L{str}, or L{None}. If L{None} is passed - meaning no value is avalable at all, not even the empty string - and this parameter is optional, L{self.default} will be returned. """ if value is None: if self.optional: return self.default else: value = "" if value == "": if not self.allow_none: raise MissingParameterError(self.name, kind=self.kind) return self.default try: self._check_range(value) parsed = self.parse(value) if self.validator and not self.validator(parsed): raise ValueError(value) return parsed except ValueError: try: value = value.decode("utf-8") message = "Invalid %s value %s" % (self.kind, value) except UnicodeDecodeError: message = "Invalid %s value" % self.kind raise InvalidParameterValueError(message)
0.001727
def get_user(login, hashes=False): ''' Get user account details login : string login name hashes : boolean include NTHASH and LMHASH in verbose output CLI Example: .. code-block:: bash salt '*' pdbedit.get kaylee ''' users = list_users(verbose=True, hashes=hashes) return users[login] if login in users else {}
0.002674
def hoist_mutation(self, random_state): """Perform the hoist mutation operation on the program. Hoist mutation selects a random subtree from the embedded program to be replaced. A random subtree of that subtree is then selected and this is 'hoisted' into the original subtrees location to form an offspring. This method helps to control bloat. Parameters ---------- random_state : RandomState instance The random number generator. Returns ------- program : list The flattened tree representation of the program. """ # Get a subtree to replace start, end = self.get_subtree(random_state) subtree = self.program[start:end] # Get a subtree of the subtree to hoist sub_start, sub_end = self.get_subtree(random_state, subtree) hoist = subtree[sub_start:sub_end] # Determine which nodes were removed for plotting removed = list(set(range(start, end)) - set(range(start + sub_start, start + sub_end))) return self.program[:start] + hoist + self.program[end:], removed
0.001696
def _get_parent_id_list(self, qualifier_id, hierarchy_id): """Returns list of parent id strings for qualifier_id in hierarchy. Uses memcache if caching is enabled. """ if self._caching_enabled(): key = 'parent_id_list_{0}'.format(str(qualifier_id)) # If configured to use memcache as the caching engine, use it. # Otherwise default to diskcache caching_engine = 'diskcache' try: config = self._runtime.get_configuration() parameter_id = Id('parameter:cachingEngine@json') caching_engine = config.get_value_by_parameter(parameter_id).get_string_value() except (AttributeError, KeyError, errors.NotFound): pass if caching_engine == 'memcache': import memcache caching_host = '127.0.0.1:11211' try: config = self._runtime.get_configuration() parameter_id = Id('parameter:cachingHostURI@json') caching_host = config.get_value_by_parameter(parameter_id).get_string_value() except (AttributeError, KeyError, errors.NotFound): pass mc = memcache.Client([caching_host], debug=0) parent_id_list = mc.get(key) if parent_id_list is None: parent_ids = self._get_hierarchy_session(hierarchy_id).get_parents(qualifier_id) parent_id_list = [str(parent_id) for parent_id in parent_ids] mc.set(key, parent_id_list) elif caching_engine == 'diskcache': import diskcache with diskcache.Cache('/tmp/dlkit_cache') as cache: # A little bit non-DRY, since it's almost the same as for memcache above. # However, for diskcache.Cache, we have to call ".close()" or use a # ``with`` statement to safeguard calling ".close()", so we keep this # separate from the memcache implementation. parent_id_list = cache.get(key) if parent_id_list is None: parent_ids = self._get_hierarchy_session(hierarchy_id).get_parents(qualifier_id) parent_id_list = [str(parent_id) for parent_id in parent_ids] cache.set(key, parent_id_list) else: raise errors.NotFound('The {0} caching engine was not found.'.format(caching_engine)) else: parent_ids = self._get_hierarchy_session(hierarchy_id).get_parents(qualifier_id) parent_id_list = [str(parent_id) for parent_id in parent_ids] return parent_id_list
0.004643
def random_array(shape, mean=128., std=20.): """Creates a uniformly distributed random array with the given `mean` and `std`. Args: shape: The desired shape mean: The desired mean (Default value = 128) std: The desired std (Default value = 20) Returns: Random numpy array of given `shape` uniformly distributed with desired `mean` and `std`. """ x = np.random.random(shape) # normalize around mean=0, std=1 x = (x - np.mean(x)) / (np.std(x) + K.epsilon()) # and then around the desired mean/std x = (x * std) + mean return x
0.005085
def py_lnotab(self): """The encoded lnotab that python uses to compute when lines start. Note ---- See Objects/lnotab_notes.txt in the cpython source for more details. """ reverse_lnotab = reverse_dict(self.lnotab) py_lnotab = [] prev_instr = 0 prev_lno = self.firstlineno for addr, instr in enumerate(_sparse_args(self.instrs)): lno = reverse_lnotab.get(instr) if lno is None: continue delta = lno - prev_lno py_lnotab.append(addr - prev_instr) py_lnotab.append(min(delta, max_lnotab_increment)) delta -= max_lnotab_increment while delta > 0: py_lnotab.append(0) py_lnotab.append(min(delta, max_lnotab_increment)) delta -= max_lnotab_increment prev_lno = lno prev_instr = addr return bytes(py_lnotab)
0.002073
def window(iterable, size=2): ''' yields wondows of a given size ''' iterable = iter(iterable) d = deque(islice(iterable, size-1), maxlen=size) for _ in map(d.append, iterable): yield tuple(d)
0.00463
def load_map_projection(filename, center=None, center_right=None, radius=None, method='orthographic', registration='native', chirality=None, sphere_radius=None, pre_affine=None, post_affine=None, meta_data=None): ''' load_map_projection(filename) yields the map projection indicated by the given file name. Map projections define the parameters of a projection to the 2D cortical surface via a registartion name and projection parameters. This function is primarily a wrapper around the MapProjection.load() function; for information about options, see MapProjection.load. ''' return MapProjection.load(filename, center=center, center_right=center_right, radius=radius, method=method, registration=registration, chirality=chirality, sphere_radius=sphere_radius, pre_affine=pre_affine, post_affine=post_affine)
0.008671
def get_environmental_configuration(self, id_or_uri): """ Returns a description of the environmental configuration (supported feature set, calibrated minimum & maximum power, location & dimensions, ...) of the resource. Args: id_or_uri: Can be either the Unmanaged Device id or the uri Returns: dict: EnvironmentalConfiguration """ uri = self._client.build_uri(id_or_uri) + "/environmentalConfiguration" return self._client.get(uri)
0.005415
def counter(self, key, value, timestamp=None): """Set a counter value If the inner key does not exist is is created :param key: counter to update :type key: str :param value: counter value :type value: float :return: An alignak_stat brok if broks are enabled else None """ _min, _max, count, _sum = self.stats.get(key, (None, None, 0, 0)) count += 1 _sum += value if _min is None or value < _min: _min = value if _max is None or value > _max: _max = value self.stats[key] = (_min, _max, count, _sum) # Manage local statsd part if self.statsd_enabled and self.statsd_sock: # beware, we are sending ms here, timer is in seconds packet = '%s.%s.%s:%d|c' % (self.statsd_prefix, self.name, key, value) packet = packet.encode('utf-8') try: self.statsd_sock.sendto(packet, self.statsd_addr) except (socket.error, socket.gaierror): pass # cannot send? ok not a huge problem here and we cannot # log because it will be far too verbose :p # Manage Graphite part if self.statsd_enabled and self.carbon: self.send_to_graphite(key, value, timestamp=timestamp) # Manage file part if self.statsd_enabled and self.file_d: if timestamp is None: timestamp = int(time.time()) packet = self.line_fmt if not self.date_fmt: date = "%s" % timestamp else: date = datetime.datetime.fromtimestamp(timestamp).strftime(self.date_fmt) packet = packet.replace("#date#", date) packet = packet.replace("#counter#", '%s.%s.%s' % (self.statsd_prefix, self.name, key)) packet = packet.replace("#value#", '%d' % value) packet = packet.replace("#uom#", 'c') try: self.file_d.write(packet) except IOError: logger.warning("Could not write to the file: %s", packet) if self.broks_enabled: logger.debug("alignak stat brok: %s = %s", key, value) if timestamp is None: timestamp = int(time.time()) return Brok({'type': 'alignak_stat', 'data': { 'ts': timestamp, 'type': 'counter', 'metric': '%s.%s.%s' % (self.statsd_prefix, self.name, key), 'value': value, 'uom': 'c' }}) return None
0.002195
def closing_address(self, block_identifier: BlockSpecification) -> Optional[Address]: """ Returns the address of the closer of the channel. """ return self.token_network.closing_address( participant1=self.participant1, participant2=self.participant2, block_identifier=block_identifier, channel_identifier=self.channel_identifier, )
0.007444
def line(self, x1, y1, x2, y2, draw=True): '''Draws a line from (x1,y1) to (x2,y2)''' p = self._path self.newpath() self.moveto(x1,y1) self.lineto(x2,y2) self.endpath(draw=draw) self._path = p return p
0.015094
def lazy_parallelize(func, result, processes=None, partition_size=None): """ Lazily computes an iterable in parallel, and returns them in pool chunks :param func: Function to apply :param result: Data to apply to :param processes: Number of processes to use in parallel :param partition_size: Size of partitions for each parallel process :return: Iterable of chunks where each chunk as func applied to it """ if processes is None or processes < 1: processes = CPU_COUNT else: processes = min(processes, CPU_COUNT) partition_size = partition_size or compute_partition_size(result, processes) pool = Pool(processes=processes) partitions = split_every(partition_size, iter(result)) packed_partitions = (pack(func, (partition, )) for partition in partitions) for pool_result in pool.imap(unpack, packed_partitions): yield pool_result pool.terminate()
0.002141
def get_gpg_home( appname, config_dir=None ): """ Get the GPG keyring directory for a particular application. Return the path. """ assert is_valid_appname(appname) config_dir = get_config_dir( config_dir ) path = os.path.join( config_dir, "gpgkeys", appname ) return path
0.023102