def serialize(self, ctx, message): assert message in (self.REQUEST, self.RESPONSE) self.event_manager.fire_event("before_serialize", ctx) if ctx.out_error is not None: ctx.out_document = [ctx.out_error.to_dict(ctx.out_error)] else: # get the result message if message is self.REQUEST: out_type = ctx.descriptor.in_message elif message is self.RESPONSE: out_type = ctx.descriptor.out_message if out_type is None: return out_type_info = out_type._type_info # instantiate the result message out_instance = out_type() # assign raw result to its wrapper, result_message for i in range(len(out_type_info)): attr_name = out_type_info.keys()[i] setattr(out_instance, attr_name, ctx.out_object[i]) ctx.out_document = self._object_to_doc(out_type, out_instance, skip_depth=self.skip_depth) self.event_manager.fire_event("after_serialize", ctx)
def make_cache_level(ncaches, prototypes, level, next_cache): global next_subsys_index, proto_l1, testerspec, proto_tester index = next_subsys_index[level] next_subsys_index[level] += 1 # Create a subsystem to contain the crossbar and caches, and # any testers subsys = SubSystem() setattr(system, "l%dsubsys%d" % (level, index), subsys) # The levels are indexing backwards through the list ntesters = testerspec[len(cachespec) - level] # Scale the progress threshold as testers higher up in the tree # (smaller level) get a smaller portion of the overall bandwidth, # and also make the interval of packet injection longer for the # testers closer to the memory (larger level) to prevent them # hogging all the bandwidth limit = (len(cachespec) - level + 1) * 100000000 testers = [proto_tester(interval=10 * (level * level + 1), progress_check=limit) for i in xrange(ntesters)] if ntesters: subsys.tester = testers if level != 0: # Create a crossbar and add it to the subsystem, note that # we do this even with a single element on this level xbar = L2XBar() subsys.xbar = xbar if next_cache: xbar.master = next_cache.cpu_side # Create and connect the caches, both the ones fanning out # to create the tree, and the ones used to connect testers # on this level tree_caches = [prototypes[0]() for i in xrange(ncaches[0])] tester_caches = [proto_l1() for i in xrange(ntesters)] subsys.cache = tester_caches + tree_caches for cache in tree_caches: cache.mem_side = xbar.slave make_cache_level(ncaches[1:], prototypes[1:], level - 1, cache) for tester, cache in zip(testers, tester_caches): tester.port = cache.cpu_side cache.mem_side = xbar.slave else: if not next_cache: print "Error: No next-level cache at top level" sys.exit(1) if ntesters > 1: # Create a crossbar and add it to the subsystem xbar = L2XBar() subsys.xbar = xbar xbar.master = next_cache.cpu_side for tester in testers: tester.port = xbar.slave else: # Single tester testers[0].port = next_cache.cpu_side
def create_or_update_by_guid(self, guid, **kwargs): """ Look up a FeedItem by GUID, updating it if it exists, and creating it if it doesn't. We don't limit it by feed because an item could be in another feed if some feeds are themselves aggregators. That's also why we don't update the feed field if the feed item already exists. Returns (item, created) like get_or_create(). """ try: item = self.get(guid=guid) except self.model.DoesNotExist: # Create a new item log.debug('Creating entry: %s', guid) kwargs['guid'] = guid item = self.create(**kwargs) else: log.debug('Updating entry: %s', guid) # Update an existing one. kwargs.pop('feed', None) # Don't update the date since most feeds get this wrong. kwargs.pop('date_modified') for k, v in kwargs.items(): setattr(item, k, v) item.save() return item
def from_element(cls, elem): new_note = Note() for child_el in elem: if not child_el.tag: continue setattr(new_note, child_el.tag, child_el.text) return new_note
def _addNamedParams(self, alias, **d): self.namedparams.update(d) if not alias: # create the reverse mapping: from parameter index to name. self.paramnames.update(dict((v,k) for k,v in d.items())) # Create a property for each named parameter. for n,i in self.namedparams.items(): #print('Adding named parameter', n, 'to class', self.__class__) if hasattr(self.__class__, n): #print(' class', self.__class__, 'already has attr', n) continue #if hasattr(self, n): # print(' self of type', self.__class__, 'already has that attr') # continue # def makeGetter(ii): # return lambda x: x._getThing(ii) # def makeSetter(ii): # return lambda x,v: x._setThing(ii, v) # getter = makeGetter(i) # setter = makeSetter(i) def makeNamedGetter(nm): #return lambda x: x._getThing(self.namedparams[nm]) return lambda x: x._getNamedThing(nm) def makeNamedSetter(nm): #return lambda x,v: x._setThing(self.namedparams[nm], v) return lambda x,v: x._setNamedThing(nm, v) getter = makeNamedGetter(n) setter = makeNamedSetter(n) prop = property(getter, setter, None, 'named param %s' % n) setattr(self.__class__, n, prop)
def load_cascade_file(self, module_path, cascade_file_path): if not hasattr(self.__class__, "cascade"): if isabs(cascade_file_path): cascade_file = cascade_file_path else: cascade_file = join(abspath(dirname(module_path)), cascade_file_path) setattr(self.__class__, "cascade", cv.Load(cascade_file))
def __init__(self, conn, dumps, loads): self._conn = conn self._dumps = dumps self._loads = loads for attr in ('fileno', 'close', 'poll', 'recv_bytes', 'send_bytes'): obj = getattr(conn, attr) setattr(self, attr, obj)
def _set(self, value): '''set value for attribute %s. value -- initialize value, immutable type ''' %str(key) if not hasattr(self, what.attrs_aname): setattr(self, what.attrs_aname, {}) getattr(self, what.attrs_aname)[key] = value
def update_aggregate(self, ag_model, location): agg = ag_model.objects.filter(location=location) if agg: agg = agg[0] else: agg = ag_model(location=location) #print agg.__dict__ #summaries = [] trees = Tree.objects.filter(plot__geometry__within=location.geometry) plots = Plot.objects.filter(geometry__within=location.geometry) #print trees agg.total_trees = trees.count() agg.total_plots = plots.count() trees = trees.exclude( Q(dbh=None) | Q(dbh=0.0) ).exclude(species=None) #print agg.total_trees #TODO figure out how to summarize diff stratum stuff field_names = [x.name for x in ResourceSummaryModel._meta.fields if not x.name == 'id'] if agg.total_trees == 0: for f in field_names: setattr(agg, f, 0.0) else: #TODO speed this up for f in field_names: fn = 'treeresource__' + f s = trees.aggregate(Sum(fn))[fn + '__sum'] or 0.0 setattr(agg,f,s) agg.save()
def populatePanel(self, contentPanel, headerPanel): contentSizer = contentPanel.GetSizer() self.panel = contentPanel self.headerPanel = headerPanel gridPrice = wx.GridSizer(1, 3) contentSizer.Add( gridPrice, 0, wx.EXPAND | wx.ALL, 0) for type in ("ship", "fittings", "total"): image = "%sPrice_big" % type if type != "ship" else "ship_big" box = wx.BoxSizer(wx.HORIZONTAL) gridPrice.Add(box, 0, wx.ALIGN_TOP) box.Add(bitmapLoader.getStaticBitmap(image, contentPanel, "icons"), 0, wx.ALIGN_CENTER) vbox = wx.BoxSizer(wx.VERTICAL) box.Add(vbox, 1, wx.EXPAND) vbox.Add(wx.StaticText(contentPanel, wx.ID_ANY, type.capitalize()), 0, wx.ALIGN_LEFT) hbox = wx.BoxSizer(wx.HORIZONTAL) vbox.Add(hbox) lbl = wx.StaticText(contentPanel, wx.ID_ANY, "0.00 ISK") setattr(self, "labelPrice%s" % type.capitalize(), lbl) hbox.Add(lbl, 0, wx.ALIGN_LEFT) # hbox.Add(wx.StaticText(contentPanel, wx.ID_ANY, " ISK"), 0, wx.ALIGN_LEFT) self.labelEMStatus = wx.StaticText(contentPanel, wx.ID_ANY, "") contentSizer.Add(self.labelEMStatus,0)
def _loadEntry(self): if not hasattr(self, '_flags'): info = self._pts._ListEntry(self._id) for field in self._attrs: setattr(self, '_%s' % field, getattr(info, field)) for field in self._entry_attrs: setattr(self, '_%s' % field, self._pts.getEntry(getattr(info, field)))
def applyMethod(sql, methodName): @_transaction def method(self, **kwargs): self.cursor.execute(sql, kwargs) return self.cursor.lastrowid setattr(self.__class__, methodName, method)
def applyMethod(stmts, methodName): @_transaction def method(self, _=None, **kwargs): # Received un-named parameter, it would be a iterable if _ != None: # Parameters are given as a dictionary, # put them in the correct place (bad guy...) if isinstance(_, dict): kwargs = _ # Iterable of parameters, execute as normal else: for kwargs in _: for stmt in stmts: self.cursor.execute(stmt, kwargs) return self.cursor.execute(stmts[0], kwargs) rowid = self.cursor.lastrowid for stmt in stmts[1:]: self.cursor.execute(stmt, kwargs) return rowid setattr(self.__class__, methodName, method)
def _lun_type(self, xml_root): lun_type = constants.PRODUCT_LUN_TYPE.get(self.conf.san_product, 'Thick') def _verify_conf_lun_type(lun_type): if lun_type not in constants.LUN_TYPE_MAP: msg = _("Invalid lun type %s is configured.") % lun_type LOG.error(msg) raise exception.InvalidInput(reason=msg) if self.conf.san_product in constants.PRODUCT_LUN_TYPE: product_lun_type = constants.PRODUCT_LUN_TYPE[ self.conf.san_product] if lun_type != product_lun_type: msg = _("%(array)s array requires %(valid)s lun type, " "but %(conf)s is specified.") % { 'array': self.conf.san_product, 'valid': product_lun_type, 'conf': lun_type} LOG.error(msg) raise exception.InvalidInput(reason=msg) text = xml_root.findtext('LUN/LUNType') if text: lun_type = text.strip() _verify_conf_lun_type(lun_type) lun_type = constants.LUN_TYPE_MAP[lun_type] setattr(self.conf, 'lun_type', lun_type)
def applyMethod(stmts, methodName): @_transaction def method(self, **kwargs): for stmt in stmts: self.cursor.execute(stmt, kwargs) setattr(self.__class__, methodName, method)
def __init__(self, *args, **kwargs): """Constructor to resolve values for all Parameters. For example, the Task:: class MyTask(luigi.Task): count = luigi.IntParameter() can be instantiated as ``MyTask(count=10)``. """ params = self.get_params() param_values = self.get_param_values(params, args, kwargs) # Set all values on class instance for key, value in param_values: setattr(self, key, value) # Register args and kwargs as an attribute on the class. Might be useful self.param_args = tuple(value for key, value in param_values) self.param_kwargs = dict(param_values) # Build up task id task_id_parts = [] param_objs = dict(params) for param_name, param_value in param_values: if dict(params)[param_name].significant: task_id_parts.append('%s=%s' % (param_name, param_objs[param_name].serialize(param_value))) self.task_id = '%s(%s)' % (self.task_family, ', '.join(task_id_parts)) self.__hash = hash(self.task_id)
def __init__(self, *args, **kwargs): xpcshell.XPCShellTestThread.__init__(self, *args, **kwargs) # embed the mobile params from the harness into the TestThread mobileArgs = kwargs.get('mobileArgs') for key in mobileArgs: setattr(self, key, mobileArgs[key])
def setValues(self,**kargs): #print "setValues",kargs for k in kargs: #print k,kargs[k] if hasattr(self,k): #print getattr(self,k) setattr(self,k,float(kargs[k]))
def init(self, XMLRoot=None): """Initialisation is called before populating with XML data. The basic implementation simply dynamically assigns variable names and their values, converted to the most sane type found. Reimplement as necessary.""" if XMLRoot != None: for prop in XMLRoot: setattr(self, prop.tag, Utility.convert(prop.text))
def option_none(option, opt, value, parser): """ checks a parameter for taking value""" if parser.rargs and not parser.rargs[0].startswith('-'): print "Option arg error" print opt, " option should be empty" sys.exit(2) setattr(parser.values, option.dest, True)
def port_cassavotes(): from r2.models import Vote, Account, Link, Comment from r2.models.vote import CassandraVote, CassandraLinkVote, CassandraCommentVote from r2.lib.db.tdb_cassandra import CL from r2.lib.utils import fetch_things2, to36, progress ts = [(Vote.rel(Account, Link), CassandraLinkVote), (Vote.rel(Account, Comment), CassandraCommentVote)] dataattrs = set(['valid_user', 'valid_thing', 'ip', 'organic']) for prel, crel in ts: vq = prel._query(sort=desc('_date'), data=True, eager_load=False) vq = fetch_things2(vq) vq = progress(vq, persec=True) for v in vq: t1 = to36(v._thing1_id) t2 = to36(v._thing2_id) cv = crel(thing1_id = t1, thing2_id = t2, date=v._date, name=v._name) for dkey, dval in v._t.iteritems(): if dkey in dataattrs: setattr(cv, dkey, dval) cv._commit(write_consistency_level=CL.ONE)
def read(self, read_path=None): """Read the metadata from the associated file. If read_path is specified, read metadata from that file instead. Raises a `ReadError` if the file could not be read. """ if read_path is None: read_path = self.path else: read_path = normpath(read_path) try: f = MediaFile(syspath(read_path)) except (OSError, IOError) as exc: raise ReadError(read_path, exc) for key in ITEM_KEYS_META: value = getattr(f, key) if isinstance(value, (int, long)): # Filter values wider than 64 bits (in signed # representation). SQLite cannot store them. # py26: Post transition, we can use: # value.bit_length() > 63 if abs(value) >= 2 ** 63: value = 0 setattr(self, key, value) # Database's mtime should now reflect the on-disk value. if read_path == self.path: self.mtime = self.current_mtime() self.path = read_path
def delete_objects(seen_objs): """ Iterate through a list of seen classes, and remove any instances that are referred to. """ try: ordered_classes = seen_objs.keys() except CyclicDependency: # If there is a cyclic dependency, we cannot in general delete the # objects. However, if an appropriate transaction is set up, or if the # database is lax enough, it will succeed. So for now, we go ahead and # try anyway. ordered_classes = seen_objs.unordered_keys() obj_pairs = {} for cls in ordered_classes: items = seen_objs[cls].items() items.sort() obj_pairs[cls] = items # Pre-notify all instances to be deleted. for pk_val, instance in items: signals.pre_delete.send(sender=cls, instance=instance) pk_list = [pk for pk,instance in items] del_query = sql.DeleteQuery(cls, connection) del_query.delete_batch_related(pk_list) update_query = sql.UpdateQuery(cls, connection) for field, model in cls._meta.get_fields_with_model(): if (field.rel and field.null and field.rel.to in seen_objs and filter(lambda f: f.column == field.column, field.rel.to._meta.fields)): if model: sql.UpdateQuery(model, connection).clear_related(field, pk_list) else: update_query.clear_related(field, pk_list) # Now delete the actual data. for cls in ordered_classes: items = obj_pairs[cls] items.reverse() pk_list = [pk for pk,instance in items] del_query = sql.DeleteQuery(cls, connection) del_query.delete_batch(pk_list) # Last cleanup; set NULLs where there once was a reference to the # object, NULL the primary key of the found objects, and perform # post-notification. for pk_val, instance in items: for field in cls._meta.fields: if field.rel and field.null and field.rel.to in seen_objs: setattr(instance, field.attname, None) signals.post_delete.send(sender=cls, instance=instance) setattr(instance, cls._meta.pk.attname, None) transaction.commit_unless_managed()
def __call__(self, parser, namespace, fname, option_string=None): ext = os.path.splitext(fname)[1][1:] if ext not in allowed: option_string = '({})'.format(option_string) if option_string else '' parser.error("file extension is not one of {}{}".format(allowed, option_string)) else: setattr(namespace, self.dest, fname)
def get_cached_row(klass, row, index_start, max_depth=0, cur_depth=0, requested=None): """ Helper function that recursively returns an object with the specified related attributes already populated. """ if max_depth and requested is None and cur_depth > max_depth: # We've recursed deeply enough; stop now. return None restricted = requested is not None index_end = index_start + len(klass._meta.fields) fields = row[index_start:index_end] if not [x for x in fields if x is not None]: # If we only have a list of Nones, there was not related object. obj = None else: obj = klass(*fields) for f in klass._meta.fields: if not select_related_descend(f, restricted, requested): continue if restricted: next = requested[f.name] else: next = None cached_row = get_cached_row(f.rel.to, row, index_end, max_depth, cur_depth+1, next) if cached_row: rel_obj, index_end = cached_row if obj is not None: setattr(obj, f.get_cache_name(), rel_obj) return obj, index_end
def _make_scalar_compound_controller(self, fcurves, keyframes, bez_chans, default_xform): ctrl = plCompoundController() subctrls = ("X", "Y", "Z") for i in subctrls: setattr(ctrl, i, plLeafController()) exported_frames = ([], [], []) ctrl_fcurves = { i.array_index: i for i in fcurves } for keyframe in keyframes: for i, subctrl in enumerate(subctrls): fval = keyframe.values.get(i, None) if fval is not None: keyframe_type = hsKeyFrame.kBezScalarKeyFrame if i in bez_chans else hsKeyFrame.kScalarKeyFrame exported = hsScalarKey() exported.frame = keyframe.frame_num exported.frameTime = keyframe.frame_time exported.inTan = keyframe.in_tans[i] exported.outTan = keyframe.out_tans[i] exported.type = keyframe_type exported.value = fval exported_frames[i].append(exported) for i, subctrl in enumerate(subctrls): my_keyframes = exported_frames[i] # ensure this controller has at least ONE keyframe if not my_keyframes: hack_frame = hsScalarKey() hack_frame.frame = 0 hack_frame.frameTime = 0.0 hack_frame.type = hsKeyFrame.kScalarKeyFrame hack_frame.value = default_xform[i] my_keyframes.append(hack_frame) getattr(ctrl, subctrl).keys = (my_keyframes, my_keyframes[0].type) return ctrl
def register(self, mod): # Derive the name of the kernel from the module name = mod[mod.rfind('.') + 1:] # See if a kernel has already been registered under this name if hasattr(self, name): # Same name different module if getattr(self, name)._mod != mod: raise RuntimeError('Attempt to re-register "{}" with a ' 'different module'.format(name)) # Otherwise (since we're already registered) return else: return # Generate the kernel providing method def kernel_meth(self, tplargs, dims, **kwargs): # Render the source of kernel src, ndim, argn, argt = self._render_kernel(name, mod, tplargs) # Compile the kernel fun = self._build_kernel(name, src, list(it.chain(*argt))) # Process the argument list argb = self._build_arglst(dims, argn, argt, kwargs) # Return a ComputeKernel subclass instance return self._instantiate_kernel(dims, fun, argb) # Attach the module to the method as an attribute kernel_meth._mod = mod # Bind setattr(self, name, types.MethodType(kernel_meth, self))
def __getattr__(self, name): if name in self.ok_names: attr = getattr(self.real, name) setattr(self, name, attr) return attr else: raise AttributeError, name # Attribute not allowed
def write(self, path=None): """Write the item's metadata to a media file. ``path`` defaults to the item's path property. Can raise either a `ReadError` or a `WriteError`. """ if path is None: path = self.path else: path = normpath(path) try: f = MediaFile(syspath(path)) except (OSError, IOError) as exc: raise ReadError(self.path, exc) plugins.send('write', item=self, path=path) for key in ITEM_KEYS_WRITABLE: setattr(f, key, self[key]) try: f.save(id3v23=beets.config['id3v23'].get(bool)) except (OSError, IOError, MutagenError) as exc: raise WriteError(self.path, exc) # The file has a new mtime. self.mtime = self.current_mtime() plugins.send('after_write', item=self)
def _ordered_dict(loader: SafeLineLoader, node: yaml.nodes.MappingNode) -> OrderedDict: """Load YAML mappings into an ordered dictionary to preserve key order.""" loader.flatten_mapping(node) nodes = loader.construct_pairs(node) seen = {} # type: Dict min_line = None for (key, _), (node, _) in zip(nodes, node.value): line = getattr(node, '__line__', 'unknown') if line != 'unknown' and (min_line is None or line < min_line): min_line = line if key in seen: fname = getattr(loader.stream, 'name', '') first_mark = yaml.Mark(fname, 0, seen[key], -1, None, None) second_mark = yaml.Mark(fname, 0, line, -1, None, None) raise yaml.MarkedYAMLError( context="duplicate key: \"{}\"".format(key), context_mark=first_mark, problem_mark=second_mark, ) seen[key] = line processed = OrderedDict(nodes) setattr(processed, '__config_file__', loader.name) setattr(processed, '__line__', min_line) return processed
parentdir = '/'.join(fullpath.split('/')[:-2]) sys.path.insert(0, parentdir) from comitup import iwscan # noqa device_list = None settings_cache = {} pp = pprint.PrettyPrinter(indent=4) log = logging.getLogger('comitup') this_module = sys.modules[__name__] for key in nm.__dict__: if key.startswith("NM_"): setattr(this_module, key, nm.__dict__[key]) def initialize(): nm.Settings.ReloadConnections() def nm_state(): log.debug("Calling nm.NetworkManager.State()") return nm.NetworkManager.State def none_on_exception(*exceptions): def _none_on_exception(fp): @wraps(fp)
def parse(path, module_name=None, include_dirs=None, include_dir=None, lexer=None, parser=None, enable_cache=True): """Parse a single thrift file to module object, e.g.:: >>> from thriftpy.parser.parser import parse >>> note_thrift = parse("path/to/note.thrift") <module 'note_thrift' (built-in)> :param path: file path to parse, should be a string ending with '.thrift'. :param module_name: the name for parsed module, the default is the basename without extension of `path`. :param include_dirs: directories to find thrift files while processing the `include` directive, by default: ['.']. :param include_dir: directory to find child thrift files. Note this keyword parameter will be deprecated in the future, it exists for compatiable reason. If it's provided (not `None`), it will be appended to `include_dirs`. :param lexer: ply lexer to use, if not provided, `parse` will new one. :param parser: ply parser to use, if not provided, `parse` will new one. :param enable_cache: if this is set to be `True`, parsed module will be cached, this is enabled by default. If `module_name` is provided, use it as cache key, else use the `path`. """ if os.name == 'nt' and sys.version_info < (3, 2): os.path.samefile = lambda f1, f2: os.stat(f1) == os.stat(f2) # dead include checking on current stack for thrift in thrift_stack: if thrift.__thrift_file__ is not None and \ os.path.samefile(path, thrift.__thrift_file__): raise ThriftParserError('Dead including on %s' % path) global thrift_cache cache_key = module_name or os.path.normpath(path) if enable_cache and cache_key in thrift_cache: return thrift_cache[cache_key] if lexer is None: lexer = lex.lex() if parser is None: parser = yacc.yacc(debug=False, write_tables=0) global include_dirs_ if include_dirs is not None: include_dirs_ = include_dirs if include_dir is not None: include_dirs_.append(include_dir) if not path.endswith('.thrift'): raise ThriftParserError('Path should end with .thrift') url_scheme = urlparse(path).scheme if url_scheme == '': with open(path) as fh: data = fh.read() elif url_scheme in ('http', 'https'): data = urlopen(path).read() else: raise ThriftParserError('ThriftPy does not support generating module ' 'with path in protocol \'{}\''.format( url_scheme)) if module_name is not None and not module_name.endswith('_thrift'): raise ThriftParserError('ThriftPy can only generate module with ' '\'_thrift\' suffix') if module_name is None: basename = os.path.basename(path) module_name = os.path.splitext(basename)[0] thrift = types.ModuleType(module_name) setattr(thrift, '__thrift_file__', path) thrift_stack.append(thrift) lexer.lineno = 1 parser.parse(data) thrift_stack.pop() if enable_cache: thrift_cache[cache_key] = thrift return thrift
def _config_zero_init(config): configs_no_init = copy.deepcopy(config) for key in configs_no_init.__dict__.keys(): if "_range" in key or "_std" in key: setattr(configs_no_init, key, 0.0) return configs_no_init
def __init__(self, options=[]): """Create a new OptionDummy instance. The attributes listed in 'options' will be initialized to None.""" for opt in options: setattr(self, opt, None)
class FancyGetopt: """Wrapper around the standard 'getopt()' module that provides some handy extra functionality: * short and long options are tied together * options have help strings, and help text can be assembled from them * options set attributes of a passed-in object * boolean options can have "negative aliases" -- eg. if --quiet is the "negative alias" of --verbose, then "--quiet" on the command line sets 'verbose' to false """ def __init__(self, option_table=None): # The option table is (currently) a list of 3-tuples: # (long_option, short_option, help_string) # if an option takes an argument, its long_option should have '=' # appended; short_option should just be a single character, no ':' # in any case. If a long_option doesn't have a corresponding # short_option, short_option should be None. All option tuples # must have long options. self.option_table = option_table # 'option_index' maps long option names to entries in the option # table (ie. those 3-tuples). self.option_index = {} if self.option_table: self._build_index() # 'alias' records (duh) alias options; {'foo': 'bar'} means # --foo is an alias for --bar self.alias = {} # 'negative_alias' keeps track of options that are the boolean # opposite of some other option self.negative_alias = {} # These keep track of the information in the option table. We # don't actually populate these structures until we're ready to # parse the command-line, since the 'option_table' passed in here # isn't necessarily the final word. self.short_opts = [] self.long_opts = [] self.short2long = {} self.attr_name = {} self.takes_arg = {} # And 'option_order' is filled up in 'getopt()'; it records the # original order of options (and their values) on the command-line, # but expands short options, converts aliases, etc. self.option_order = [] # __init__ () def _build_index(self): self.option_index.clear() for option in self.option_table: self.option_index[option[0]] = option def set_option_table(self, option_table): self.option_table = option_table self._build_index() def add_option(self, long_option, short_option=None, help_string=None): if self.option_index.has_key(long_option): raise DistutilsGetoptError, \ "option conflict: already an option '%s'" % long_option else: option = (long_option, short_option, help_string) self.option_table.append(option) self.option_index[long_option] = option def has_option(self, long_option): """Return true if the option table for this parser has an option with long name 'long_option'.""" return self.option_index.has_key(long_option) def get_attr_name(self, long_option): """Translate long option name 'long_option' to the form it has as an attribute of some object: ie., translate hyphens to underscores.""" return string.translate(long_option, longopt_xlate) def _check_alias_dict(self, aliases, what): assert type(aliases) is DictionaryType for (alias, opt) in aliases.items(): if not self.option_index.has_key(alias): raise DistutilsGetoptError, \ ("invalid %s '%s': " "option '%s' not defined") % (what, alias, alias) if not self.option_index.has_key(opt): raise DistutilsGetoptError, \ ("invalid %s '%s': " "aliased option '%s' not defined") % (what, alias, opt) def set_aliases(self, alias): """Set the aliases for this option parser.""" self._check_alias_dict(alias, "alias") self.alias = alias def set_negative_aliases(self, negative_alias): """Set the negative aliases for this option parser. 'negative_alias' should be a dictionary mapping option names to option names, both the key and value must already be defined in the option table.""" self._check_alias_dict(negative_alias, "negative alias") self.negative_alias = negative_alias def _grok_option_table(self): """Populate the various data structures that keep tabs on the option table. Called by 'getopt()' before it can do anything worthwhile. """ self.long_opts = [] self.short_opts = [] self.short2long.clear() for option in self.option_table: try: (long, short, help) = option except ValueError: raise DistutilsGetoptError, \ "invalid option tuple " + str(option) # Type- and value-check the option names if type(long) is not StringType or len(long) < 2: raise DistutilsGetoptError, \ ("invalid long option '%s': " "must be a string of length >= 2") % long if (not ((short is None) or (type(short) is StringType and len(short) == 1))): raise DistutilsGetoptError, \ ("invalid short option '%s': " "must a single character or None") % short self.long_opts.append(long) if long[-1] == '=': # option takes an argument? if short: short = short + ':' long = long[0:-1] self.takes_arg[long] = 1 else: # Is option is a "negative alias" for some other option (eg. # "quiet" == "!verbose")? alias_to = self.negative_alias.get(long) if alias_to is not None: if self.takes_arg[alias_to]: raise DistutilsGetoptError, \ ("invalid negative alias '%s': " "aliased option '%s' takes a value") % \ (long, alias_to) self.long_opts[-1] = long # XXX redundant?! self.takes_arg[long] = 0 else: self.takes_arg[long] = 0 # If this is an alias option, make sure its "takes arg" flag is # the same as the option it's aliased to. alias_to = self.alias.get(long) if alias_to is not None: if self.takes_arg[long] != self.takes_arg[alias_to]: raise DistutilsGetoptError, \ ("invalid alias '%s': inconsistent with " "aliased option '%s' (one of them takes a value, " "the other doesn't") % (long, alias_to) # Now enforce some bondage on the long option name, so we can # later translate it to an attribute name on some object. Have # to do this a bit late to make sure we've removed any trailing # '='. if not longopt_re.match(long): raise DistutilsGetoptError, \ ("invalid long option name '%s' " + "(must be letters, numbers, hyphens only") % long self.attr_name[long] = self.get_attr_name(long) if short: self.short_opts.append(short) self.short2long[short[0]] = long # for option_table # _grok_option_table() def getopt(self, args=None, object=None): """Parse the command-line options in 'args' and store the results as attributes of 'object'. If 'args' is None or not supplied, uses 'sys.argv[1:]'. If 'object' is None or not supplied, creates a new OptionDummy object, stores option values there, and returns a tuple (args, object). If 'object' is supplied, it is modified in place and 'getopt()' just returns 'args'; in both cases, the returned 'args' is a modified copy of the passed-in 'args' list, which is left untouched. """ if args is None: args = sys.argv[1:] if object is None: object = OptionDummy() created_object = 1 else: created_object = 0 self._grok_option_table() short_opts = string.join(self.short_opts) try: (opts, args) = getopt.getopt(args, short_opts, self.long_opts) except getopt.error, msg: raise DistutilsArgError, msg for (opt, val) in opts: if len(opt) == 2 and opt[0] == '-': # it's a short option opt = self.short2long[opt[1]] elif len(opt) > 2 and opt[0:2] == '--': opt = opt[2:] else: raise DistutilsInternalError, \ "this can't happen: bad option string '%s'" % opt alias = self.alias.get(opt) if alias: opt = alias if not self.takes_arg[opt]: # boolean option? if val != '': # shouldn't have a value! raise DistutilsInternalError, \ "this can't happen: bad option value '%s'" % val alias = self.negative_alias.get(opt) if alias: opt = alias val = 0 else: val = 1 attr = self.attr_name[opt] setattr(object, attr, val) self.option_order.append((opt, val)) # for opts if created_object: return (args, object) else: return args
def __init__(self, *args, **kwargs): # noqa: E501 """SingleJobRunMessage - a model defined in OpenAPI Keyword Args: _check_type (bool): if True, values for parameters in openapi_types will be type checked and a TypeError will be raised if the wrong type is input. Defaults to True _path_to_item (tuple/list): This is a list of keys or values to drill down to the model in received_data when deserializing a response _spec_property_naming (bool): True if the variable names in the input data are serialized names, as specified in the OpenAPI document. False if the variable names in the input data are pythonic names, e.g. snake case (default) _configuration (Configuration): the instance to use when deserializing a file_type parameter. If passed, type conversion is attempted If omitted no type conversion is done. _visited_composed_classes (tuple): This stores a tuple of classes that we have traveled through so that if we see that class again we will not use its discriminator again. When traveling through a discriminator, the composed schema that is is traveled through is added to this set. For example if Animal has a discriminator petType and we pass in "Dog", and the class Dog allOf includes Animal, we move through Animal once using the discriminator, and pick Dog. Then in Dog, we will make an instance of the Animal class but this time we won't travel through its discriminator because we passed in _visited_composed_classes = (Animal,) message (str): The status message returned from the API call.. [optional] # noqa: E501 is_error (bool): True if there was an error performing the API call.. [optional] # noqa: E501 object_type (str): The type of object being returned.. [optional] # noqa: E501 status_code (int): The HTTP status code returned.. [optional] # noqa: E501 object (SingleJobRun): [optional] # noqa: E501 """ _check_type = kwargs.pop('_check_type', True) _spec_property_naming = kwargs.pop('_spec_property_naming', False) _path_to_item = kwargs.pop('_path_to_item', ()) _configuration = kwargs.pop('_configuration', None) _visited_composed_classes = kwargs.pop('_visited_composed_classes', ()) if args: raise ApiTypeError( "Invalid positional arguments=%s passed to %s. Remove those invalid positional arguments." % ( args, self.__class__.__name__, ), path_to_item=_path_to_item, valid_classes=(self.__class__, ), ) self._data_store = {} self._check_type = _check_type self._spec_property_naming = _spec_property_naming self._path_to_item = _path_to_item self._configuration = _configuration self._visited_composed_classes = _visited_composed_classes + ( self.__class__, ) for var_name, var_value in kwargs.items(): if var_name not in self.attribute_map and \ self._configuration is not None and \ self._configuration.discard_unknown_keys and \ self.additional_properties_type is None: # discard variable. continue setattr(self, var_name, var_value)
def __init__(self, *bases, **data): self._bases = list(bases) for k,v in data.items(): setattr(self, k, v)
def __setitem__(self, key, value): setattr(self, key, value)
def p_seen_union(p): '''seen_union : UNION IDENTIFIER ''' val = _make_empty_struct(p[2]) setattr(thrift_stack[-1], p[2], val) p[0] = val
def p_exception(p): '''exception : EXCEPTION IDENTIFIER '{' field_seq '}' ''' val = _make_struct(p[2], p[4], base_cls=TException) setattr(thrift_stack[-1], p[2], val) _add_thrift_meta('exceptions', val)
def p_enum(p): # noqa '''enum : ENUM IDENTIFIER '{' enum_seq '}' ''' val = _make_enum(p[2], p[4]) setattr(thrift_stack[-1], p[2], val) _add_thrift_meta('enums', val)
def p_seen_struct(p): '''seen_struct : STRUCT IDENTIFIER ''' val = _make_empty_struct(p[2]) setattr(thrift_stack[-1], p[2], val) p[0] = val
def _parse_qresult(self): """Parse query results (PRIVATE).""" # parse the queries for event, qresult_elem in self.xml_iter: # </Iteration> marks the end of a single query # which means we can process it if event == "end" and qresult_elem.tag == "Iteration": # we'll use the following schema # <!ELEMENT Iteration ( # Iteration_iter-num, # Iteration_query-ID?, # Iteration_query-def?, # Iteration_query-len?, # Iteration_hits?, # Iteration_stat?, # Iteration_message?)> # assign query attributes with fallbacks query_id = qresult_elem.findtext("Iteration_query-ID") if query_id is None: query_id = self._fallback["id"] query_desc = qresult_elem.findtext("Iteration_query-def") if query_desc is None: query_desc = self._fallback["description"] query_len = qresult_elem.findtext("Iteration_query-len") if query_len is None: query_len = self._fallback["len"] blast_query_id = query_id # handle blast searches against databases with Blast's IDs # 'Query_' marks the beginning of a BLAST+-generated ID, # 'lcl|' marks the beginning of a BLAST legacy-generated ID if not self._use_raw_query_ids and ( query_id.startswith("Query_") or query_id.startswith("lcl|") ): # store the Blast-generated query ID id_desc = query_desc.split(" ", 1) query_id = id_desc[0] try: query_desc = id_desc[1] except IndexError: query_desc = "" hit_list, key_list = [], [] for hit in self._parse_hit( qresult_elem.find("Iteration_hits"), query_id ): if hit: # need to keep track of hit IDs, since there could be duplicates, if hit.id in key_list: warnings.warn( "Renaming hit ID %r to a BLAST-generated ID " "%r since the ID was already matched " "by your query %r. Your BLAST database " "may contain duplicate entries." % (hit.id, hit.blast_id, query_id), BiopythonParserWarning, ) # fallback to Blast-generated IDs, if the ID is already present # and restore the desc, too hit.description = "%s %s" % (hit.id, hit.description) hit.id = hit.blast_id # and change the hit_id of the HSPs contained for hsp in hit: hsp.hit_id = hit.blast_id else: key_list.append(hit.id) hit_list.append(hit) # create qresult and assign its attributes qresult = QueryResult(hit_list, query_id) qresult.description = query_desc qresult.seq_len = int(query_len) qresult.blast_id = blast_query_id for key, value in self._meta.items(): setattr(qresult, key, value) # statistics are stored in Iteration_stat's 'grandchildren' with the # following DTD # <!ELEMENT Statistics ( # Statistics_db-num, # Statistics_db-len, # Statistics_hsp-len, # Statistics_eff-space, # Statistics_kappa, # Statistics_lambda, # Statistics_entropy)> stat_iter_elem = qresult_elem.find("Iteration_stat") if stat_iter_elem is not None: stat_elem = stat_iter_elem.find("Statistics") for key, val_info in _ELEM_QRESULT_OPT.items(): value = stat_elem.findtext(key) if value is not None: caster = val_info[1] # recast only if value is not intended to be str if value is not None and caster is not str: value = caster(value) setattr(qresult, val_info[0], value) # delete element after we finish parsing it qresult_elem.clear() yield qresult
def p_typedef(p): '''typedef : TYPEDEF field_type IDENTIFIER''' setattr(thrift_stack[-1], p[3], p[2])
def attr_setdefault(obj, name, value): """Like dict.setdefault, but for objects.""" if not hasattr(obj, name): setattr(obj, name, value) return getattr(obj, name)
def __setstate__(self, state): for slot, value in state.items(): setattr(self, slot, value)
def change_nonspecific(key, value): self.key_changed = key self.update(self.rxcenter, self.txcenter, self.rxsps, self.txsps) self.key_changed = None setattr(self, 'last_%s' % key, value)
"""Augment pandas DataFrame with methods for machine learning""" __version__ = '0.1.1' import logging import numpy as np import pandas as pd from pandas.core.base import PandasObject from pandas_ml_common.df.ml import ML from pandas_ml_common.lazy import LazyInit from pandas_ml_common.utils import get_pandas_object, Constant _log = logging.getLogger(__name__) _log.debug(f"numpy version {np.__version__}") _log.debug(f"pandas version {pd.__version__}") setattr(PandasObject, "ml", property(lambda self: ML(self))) setattr(pd.DataFrame, "to_frame", lambda self: self)
# if they don't exist. 'resnet50': dict( DEFAULT_KWARGS, **{ 'lr': 0.5, 'lr_scheduler_divide_every_n_epochs': 20, 'lr_scheduler_divisor': 5, 'lr_scheduler_type': 'WarmupAndExponentialDecayScheduler', }) } # Set any args that were not explicitly given by the user. default_value_dict = MODEL_SPECIFIC_DEFAULTS.get(FLAGS.model, DEFAULT_KWARGS) for arg, value in default_value_dict.items(): if getattr(FLAGS, arg) is None: setattr(FLAGS, arg, value) def get_model_property(key): default_model_property = { 'img_dim': 224, 'model_fn': getattr(torchvision.models, FLAGS.model) } model_properties = { 'inception_v3': { 'img_dim': 299, 'model_fn': lambda: torchvision.models.inception_v3(aux_logits=False) }, } model_fn = model_properties.get(FLAGS.model, default_model_property)[key] return model_fn
def Stop(self): setattr(self.module, self.target_name, self.old_target)
def __init__(self): RpcRequest.__init__(self, 'CCC', '2017-07-05', 'ListSurveys') if hasattr(self, "endpoint_map"): setattr(self, "endpoint_map", endpoint_data.getEndpointMap()) if hasattr(self, "endpoint_regional"): setattr(self, "endpoint_regional", endpoint_data.getEndpointRegional())
def __init__(self, icfg, tb, rx, tx, audio_tx, audio_rx, chanover, beeper): self.left = qtgui4.QWidget() self.right = qtgui4.QWidget() self.audio_disconnect_node = None self.tx_disconnect_node = None self.beeper = beeper self.chanover = chanover self.tb = tb self.rx = rx self.tx = tx self.audio_tx = audio_tx self.audio_rx = audio_rx self.active = False self.__connections = [] self.last_vol = 0.0 self.last_sq = 0.0 self.last_freq = 0.0 self.last_bw = 0.0 def change_volume(value): chanover.change_volume(value) self.update(self.rxcenter, self.txcenter, self.rxsps, self.txsps) self.key_changed = None self.last_vol = value #self.beeper() def change_squelch(value): chanover.change_squelch(value) self.key_changed = 'vol' self.update(self.rxcenter, self.txcenter, self.rxsps, self.txsps) self.key_changed = None self.last_sq = value #self.beeper() def change_frequency(value): chanover.change_center_freq(value) self.key_changed = 'freq' self.update(self.rxcenter, self.txcenter, self.rxsps, self.txsps) self.key_changed = None self.last_freq = value #self.beeper() def change_bw(value): chanover.change_width(value) self.key_changed = 'bw' self.update(self.rxcenter, self.txcenter, self.rxsps, self.txsps) self.key_changed = None self.last_bw = value #self.beeper() def change_nonspecific(key, value): self.key_changed = key self.update(self.rxcenter, self.txcenter, self.rxsps, self.txsps) self.key_changed = None setattr(self, 'last_%s' % key, value) #self.beeper() self.key_changed = None def __mf(k): return lambda v: change_nonspecific(k, v) els = [] for k in icfg: ecfg = icfg[k] args = {} for kk in ecfg: if kk != 'type': args[kk] = ecfg[kk] if k == 'vol': args['signal'] = change_volume elif k == 'sq': args['signal'] = change_squelch elif k == 'freq': args['signal'] = change_frequency elif k == 'bw': args['signal'] = change_bw else: args['signal'] = __mf(k) setattr(self, 'last_%s' % k, 0.0) qel = qlcdnumberadjustable.QLCDNumberAdjustable(**args) setattr(self, k, qel) els.append(qel) self.shiftsrc = None self.shifter = None self.decfilter = None self.amper = None self.rxtxstatus = QTXRXStatus() self.rxtxstatus.setMinimumSize(75, 55) els.insert(0, self.rxtxstatus) self.left.lay = quick_layout(self.left, els, horizontal=False)
def set_value(self, key, value=b''): if hasattr(self, key): #v = getattr(self,key,None) setattr(self, key, value) else: print('no', key)
def __setstate__(self, state): for k, v in zip(self.__slots__, state): setattr(self, k, v)
def _parse_hsp(self, root_hsp_frag_elem, query_id, hit_id): """Yield a generator object that transforms Hit_hsps XML elements into HSP objects (PRIVATE). :param root_hsp_frag_elem: the ``Hit_hsps`` tag :type root_hsp_frag_elem: XML element tag :param query_id: query ID :type query_id: string :param hit_id: hit ID :type hit_id: string """ # Hit_hsps DTD: # <!ELEMENT Hsp ( # Hsp_num, # Hsp_bit-score, # Hsp_score, # Hsp_evalue, # Hsp_query-from, # Hsp_query-to, # Hsp_hit-from, # Hsp_hit-to, # Hsp_pattern-from?, # Hsp_pattern-to?, # Hsp_query-frame?, # Hsp_hit-frame?, # Hsp_identity?, # Hsp_positive?, # Hsp_gaps?, # Hsp_align-len?, # Hsp_density?, # Hsp_qseq, # Hsp_hseq, # Hsp_midline?)> # if value is None, feed the loop below an empty list if root_hsp_frag_elem is None: root_hsp_frag_elem = [] for hsp_frag_elem in root_hsp_frag_elem: coords = {} # temporary container for coordinates frag = HSPFragment(hit_id, query_id) for key, val_info in _ELEM_FRAG.items(): value = hsp_frag_elem.findtext(key) caster = val_info[1] # adjust 'from' and 'to' coordinates to 0-based ones if value is not None: if key.endswith("-from") or key.endswith("-to"): # store coordinates for further processing coords[val_info[0]] = caster(value) continue # recast only if value is not intended to be str elif caster is not str: value = caster(value) setattr(frag, val_info[0], value) # set the similarity characters into aln_annotation dict frag.aln_annotation["similarity"] = hsp_frag_elem.findtext("Hsp_midline") # process coordinates # since 'x-from' could be bigger than 'x-to', we need to figure # out which one is smaller/bigger since 'x_start' is always smaller # than 'x_end' for coord_type in ("query", "hit", "pattern"): start_type = coord_type + "_start" end_type = coord_type + "_end" try: start = coords[start_type] end = coords[end_type] except KeyError: continue else: # convert to python range and setattr setattr(frag, start_type, min(start, end) - 1) setattr(frag, end_type, max(start, end)) # set alphabet, based on program prog = self._meta.get("program") if prog == "blastn": frag.alphabet = generic_dna elif prog in ["blastp", "blastx", "tblastn", "tblastx"]: frag.alphabet = generic_protein hsp = HSP([frag]) for key, val_info in _ELEM_HSP.items(): value = hsp_frag_elem.findtext(key) caster = val_info[1] if value is not None: if caster is not str: value = caster(value) setattr(hsp, val_info[0], value) # delete element after we finish parsing it hsp_frag_elem.clear() yield hsp
def _plot2d(plotfunc): """ Decorator for common 2d plotting logic Also adds the 2d plot method to class _PlotMethods """ commondoc = """ Parameters ---------- darray : DataArray Must be 2 dimensional, unless creating faceted plots x : string, optional Coordinate for x axis. If None use darray.dims[1] y : string, optional Coordinate for y axis. If None use darray.dims[0] figsize : tuple, optional A tuple (width, height) of the figure in inches. Mutually exclusive with ``size`` and ``ax``. aspect : scalar, optional Aspect ratio of plot, so that ``aspect * size`` gives the width in inches. Only used if a ``size`` is provided. size : scalar, optional If provided, create a new figure for the plot with the given size. Height (in inches) of each plot. See also: ``aspect``. ax : matplotlib axes object, optional Axis on which to plot this figure. By default, use the current axis. Mutually exclusive with ``size`` and ``figsize``. row : string, optional If passed, make row faceted plots on this dimension name col : string, optional If passed, make column faceted plots on this dimension name col_wrap : integer, optional Use together with ``col`` to wrap faceted plots xincrease : None, True, or False, optional Should the values on the x axes be increasing from left to right? if None, use the default for the matplotlib function yincrease : None, True, or False, optional Should the values on the y axes be increasing from top to bottom? if None, use the default for the matplotlib function add_colorbar : Boolean, optional Adds colorbar to axis add_labels : Boolean, optional Use xarray metadata to label axes vmin, vmax : floats, optional Values to anchor the colormap, otherwise they are inferred from the data and other keyword arguments. When a diverging dataset is inferred, setting one of these values will fix the other by symmetry around ``center``. Setting both values prevents use of a diverging colormap. If discrete levels are provided as an explicit list, both of these values are ignored. cmap : matplotlib colormap name or object, optional The mapping from data values to color space. If not provided, this will be either be ``viridis`` (if the function infers a sequential dataset) or ``RdBu_r`` (if the function infers a diverging dataset). When `Seaborn` is installed, ``cmap`` may also be a `seaborn` color palette. If ``cmap`` is seaborn color palette and the plot type is not ``contour`` or ``contourf``, ``levels`` must also be specified. colors : discrete colors to plot, optional A single color or a list of colors. If the plot type is not ``contour`` or ``contourf``, the ``levels`` argument is required. center : float, optional The value at which to center the colormap. Passing this value implies use of a diverging colormap. Setting it to ``False`` prevents use of a diverging colormap. robust : bool, optional If True and ``vmin`` or ``vmax`` are absent, the colormap range is computed with 2nd and 98th percentiles instead of the extreme values. extend : {'neither', 'both', 'min', 'max'}, optional How to draw arrows extending the colorbar beyond its limits. If not provided, extend is inferred from vmin, vmax and the data limits. levels : int or list-like object, optional Split the colormap (cmap) into discrete color intervals. If an integer is provided, "nice" levels are chosen based on the data range: this can imply that the final number of levels is not exactly the expected one. Setting ``vmin`` and/or ``vmax`` with ``levels=N`` is equivalent to setting ``levels=np.linspace(vmin, vmax, N)``. infer_intervals : bool, optional Only applies to pcolormesh. If True, the coordinate intervals are passed to pcolormesh. If False, the original coordinates are used (this can be useful for certain map projections). The default is to always infer intervals, unless the mesh is irregular and plotted on a map projection. subplot_kws : dict, optional Dictionary of keyword arguments for matplotlib subplots. Only applies to FacetGrid plotting. cbar_ax : matplotlib Axes, optional Axes in which to draw the colorbar. cbar_kwargs : dict, optional Dictionary of keyword arguments to pass to the colorbar. **kwargs : optional Additional arguments to wrapped matplotlib function Returns ------- artist : The same type of primitive artist that the wrapped matplotlib function returns """ # Build on the original docstring plotfunc.__doc__ = '\n'.join((plotfunc.__doc__, commondoc)) @functools.wraps(plotfunc) def newplotfunc(darray, x=None, y=None, figsize=None, size=None, aspect=None, ax=None, row=None, col=None, col_wrap=None, xincrease=True, yincrease=True, add_colorbar=None, add_labels=True, vmin=None, vmax=None, cmap=None, center=None, robust=False, extend=None, levels=None, infer_intervals=None, colors=None, subplot_kws=None, cbar_ax=None, cbar_kwargs=None, **kwargs): # All 2d plots in xarray share this function signature. # Method signature below should be consistent. # Decide on a default for the colorbar before facetgrids if add_colorbar is None: add_colorbar = plotfunc.__name__ != 'contour' # Handle facetgrids first if row or col: allargs = locals().copy() allargs.update(allargs.pop('kwargs')) # Need the decorated plotting function allargs['plotfunc'] = globals()[plotfunc.__name__] return _easy_facetgrid(**allargs) import matplotlib.pyplot as plt # colors is mutually exclusive with cmap if cmap and colors: raise ValueError("Can't specify both cmap and colors.") # colors is only valid when levels is supplied or the plot is of type # contour or contourf if colors and (('contour' not in plotfunc.__name__) and (not levels)): raise ValueError("Can only specify colors with contour or levels") # we should not be getting a list of colors in cmap anymore # is there a better way to do this test? if isinstance(cmap, (list, tuple)): warnings.warn( "Specifying a list of colors in cmap is deprecated. " "Use colors keyword instead.", DeprecationWarning, stacklevel=3) xlab, ylab = _infer_xy_labels(darray=darray, x=x, y=y) # better to pass the ndarrays directly to plotting functions xval = darray[xlab].values yval = darray[ylab].values zval = darray.to_masked_array(copy=False) # May need to transpose for correct x, y labels # xlab may be the name of a coord, we have to check for dim names if darray[xlab].dims[-1] == darray.dims[0]: zval = zval.T _ensure_plottable(xval, yval) if 'contour' in plotfunc.__name__ and levels is None: levels = 7 # this is the matplotlib default cmap_kwargs = { 'plot_data': zval.data, 'vmin': vmin, 'vmax': vmax, 'cmap': colors if colors else cmap, 'center': center, 'robust': robust, 'extend': extend, 'levels': levels, 'filled': plotfunc.__name__ != 'contour', } cmap_params = _determine_cmap_params(**cmap_kwargs) if 'contour' in plotfunc.__name__: # extend is a keyword argument only for contour and contourf, but # passing it to the colorbar is sufficient for imshow and # pcolormesh kwargs['extend'] = cmap_params['extend'] kwargs['levels'] = cmap_params['levels'] if 'pcolormesh' == plotfunc.__name__: kwargs['infer_intervals'] = infer_intervals # This allows the user to pass in a custom norm coming via kwargs kwargs.setdefault('norm', cmap_params['norm']) if 'imshow' == plotfunc.__name__ and isinstance(aspect, basestring): # forbid usage of mpl strings raise ValueError("plt.imshow's `aspect` kwarg is not available " "in xarray") ax = get_axis(figsize, size, aspect, ax) primitive = plotfunc(xval, yval, zval, ax=ax, cmap=cmap_params['cmap'], vmin=cmap_params['vmin'], vmax=cmap_params['vmax'], **kwargs) # Label the plot with metadata if add_labels: ax.set_xlabel(xlab) ax.set_ylabel(ylab) ax.set_title(darray._title_for_slice()) if add_colorbar: cbar_kwargs = {} if cbar_kwargs is None else dict(cbar_kwargs) cbar_kwargs.setdefault('extend', cmap_params['extend']) if cbar_ax is None: cbar_kwargs.setdefault('ax', ax) else: cbar_kwargs.setdefault('cax', cbar_ax) cbar = plt.colorbar(primitive, **cbar_kwargs) if darray.name and add_labels and 'label' not in cbar_kwargs: cbar.set_label(darray.name, rotation=90) elif cbar_ax is not None or cbar_kwargs is not None: # inform the user about keywords which aren't used raise ValueError("cbar_ax and cbar_kwargs can't be used with " "add_colorbar=False.") _update_axes_limits(ax, xincrease, yincrease) return primitive # For use as DataArray.plot.plotmethod @functools.wraps(newplotfunc) def plotmethod(_PlotMethods_obj, x=None, y=None, figsize=None, size=None, aspect=None, ax=None, row=None, col=None, col_wrap=None, xincrease=True, yincrease=True, add_colorbar=None, add_labels=True, vmin=None, vmax=None, cmap=None, colors=None, center=None, robust=False, extend=None, levels=None, infer_intervals=None, subplot_kws=None, cbar_ax=None, cbar_kwargs=None, **kwargs): """ The method should have the same signature as the function. This just makes the method work on Plotmethods objects, and passes all the other arguments straight through. """ allargs = locals() allargs['darray'] = _PlotMethods_obj._da allargs.update(kwargs) for arg in ['_PlotMethods_obj', 'newplotfunc', 'kwargs']: del allargs[arg] return newplotfunc(**allargs) # Add to class _PlotMethods setattr(_PlotMethods, plotmethod.__name__, plotmethod) return newplotfunc
def add_func_to_class(name, func): """Add a function to a class with a particular name.""" func.__name__ = name setattr(cls, name, func)
def __setattr__(self, attr, value): setattr(self.dbCursor, attr, value)
def _setup_device(self, ad, sim_conf_file, qxdm_log_mask_cfg=None): ad.qxdm_log = getattr(ad, "qxdm_log", self.qxdm_log) ad.sdm_log = getattr(ad, "sdm_log", self.sdm_log) if self.user_params.get("enable_connectivity_metrics", False): enable_connectivity_metrics(ad) if self.user_params.get("build_id_override", False): build_postfix = self.user_params.get("build_id_postfix", "LAB_TEST") build_id_override( ad, new_build_id=self.user_params.get("build_id_override_with", None), postfix=build_postfix) if self.enable_radio_log_on: enable_radio_log_on(ad) list_of_models = ["sdm", "msm", "kon", "lit"] if any(model in ad.model for model in list_of_models): phone_mode = "ssss" if hasattr(ad, "mtp_dsds"): phone_mode = "dsds" if ad.adb.getprop("persist.radio.multisim.config") != phone_mode: ad.adb.shell("setprop persist.radio.multisim.config %s" \ % phone_mode) reboot_device(ad) stop_qxdm_logger(ad) if ad.qxdm_log: qxdm_log_mask = getattr(ad, "qxdm_log_mask", None) if qxdm_log_mask_cfg: qxdm_mask_path = self.user_params.get("qxdm_log_path", DEFAULT_QXDM_LOG_PATH) ad.adb.shell("mkdir %s" % qxdm_mask_path) ad.log.info("Push %s to %s", qxdm_log_mask_cfg, qxdm_mask_path) ad.adb.push("%s %s" % (qxdm_log_mask_cfg, qxdm_mask_path)) mask_file_name = os.path.split(qxdm_log_mask_cfg)[-1] qxdm_log_mask = os.path.join(qxdm_mask_path, mask_file_name) set_qxdm_logger_command(ad, mask=qxdm_log_mask) start_qxdm_logger(ad, utils.get_current_epoch_time()) elif ad.sdm_log: start_sdm_logger(ad) else: disable_qxdm_logger(ad) if not unlock_sim(ad): raise signals.TestAbortClass("unable to unlock the SIM") # eSIM enablement if hasattr(ad, "fi_esim"): if not ensure_wifi_connected(self.log, ad, self.wifi_network_ssid, self.wifi_network_pass): ad.log.error("Failed to connect to wifi") if check_google_fi_activated(ad): ad.log.info("Google Fi is already Activated") else: install_googleaccountutil_apk(ad, self.account_util) add_google_account(ad) install_googlefi_apk(ad, self.fi_util) if not activate_google_fi_account(ad): ad.log.error("Failed to activate Fi") check_google_fi_activated(ad) if hasattr(ad, "dsds"): sim_mode = ad.droid.telephonyGetPhoneCount() if sim_mode == 1: ad.log.info("Phone in Single SIM Mode") if not phone_switch_to_msim_mode(ad): ad.log.error("Failed to switch to Dual SIM Mode") return False elif sim_mode == 2: ad.log.info("Phone already in Dual SIM Mode") if get_sim_state(ad) in (SIM_STATE_ABSENT, SIM_STATE_UNKNOWN): ad.log.info("Device has no or unknown SIM in it") # eSIM needs activation activate_esim_using_suw(ad) ensure_phone_idle(self.log, ad) elif self.user_params.get("Attenuator"): ad.log.info("Device in chamber room") ensure_phone_idle(self.log, ad) setup_droid_properties(self.log, ad, sim_conf_file) else: self.wait_for_sim_ready(ad) ensure_phone_default_state(self.log, ad) setup_droid_properties(self.log, ad, sim_conf_file) default_slot = getattr(ad, "default_slot", 0) if get_subid_from_slot_index(ad.log, ad, default_slot) != INVALID_SUB_ID: ad.log.info("Slot %s is the default slot.", default_slot) set_default_sub_for_all_services(ad, default_slot) else: ad.log.warning("Slot %s is NOT a valid slot. Slot %s will be used by default.", default_slot, 1-default_slot) set_default_sub_for_all_services(ad, 1-default_slot) # Activate WFC on Verizon, AT&T and Canada operators as per # b/33187374 & # b/122327716 activate_wfc_on_device(self.log, ad) # Sub ID setup initial_set_up_for_subid_infomation(self.log, ad) # If device is setup already, skip the following setup procedures if getattr(ad, "telephony_test_setup", None): return True try: ad.droid.wifiEnableVerboseLogging(WIFI_VERBOSE_LOGGING_ENABLED) except Exception: pass # Disable Emergency alerts # Set chrome browser start with no-first-run verification and # disable-fre. Give permission to read from and write to storage. for cmd in ("pm disable com.android.cellbroadcastreceiver", "pm grant com.android.chrome " "android.permission.READ_EXTERNAL_STORAGE", "pm grant com.android.chrome " "android.permission.WRITE_EXTERNAL_STORAGE", "rm /data/local/chrome-command-line", "am set-debug-app --persistent com.android.chrome", 'echo "chrome --no-default-browser-check --no-first-run ' '--disable-fre" > /data/local/tmp/chrome-command-line'): ad.adb.shell(cmd, ignore_status=True) # Curl for 2016/7 devices if not getattr(ad, "curl_capable", False): try: out = ad.adb.shell("/data/curl --version") if not out or "not found" in out: if int(ad.adb.getprop("ro.product.first_api_level")) >= 25: tel_data = self.user_params.get("tel_data", "tel_data") if isinstance(tel_data, list): tel_data = tel_data[0] curl_file_path = os.path.join(tel_data, "curl") if not os.path.isfile(curl_file_path): curl_file_path = os.path.join( self.user_params[Config.key_config_path.value], curl_file_path) if os.path.isfile(curl_file_path): ad.log.info("Pushing Curl to /data dir") ad.adb.push("%s /data" % (curl_file_path)) ad.adb.shell( "chmod 777 /data/curl", ignore_status=True) else: setattr(ad, "curl_capable", True) except Exception: ad.log.info("Failed to push curl on this device") # Ensure that a test class starts from a consistent state that # improves chances of valid network selection and facilitates # logging. try: if not set_phone_screen_on(self.log, ad): self.log.error("Failed to set phone screen-on time.") return False if not set_phone_silent_mode(self.log, ad): self.log.error("Failed to set phone silent mode.") return False ad.droid.telephonyAdjustPreciseCallStateListenLevel( PRECISE_CALL_STATE_LISTEN_LEVEL_FOREGROUND, True) ad.droid.telephonyAdjustPreciseCallStateListenLevel( PRECISE_CALL_STATE_LISTEN_LEVEL_RINGING, True) ad.droid.telephonyAdjustPreciseCallStateListenLevel( PRECISE_CALL_STATE_LISTEN_LEVEL_BACKGROUND, True) except Exception as e: self.log.error("Failure with %s", e) setattr(ad, "telephony_test_setup", True) return True
def setter(name, value): value.__name__ = name setattr(cls, name, value)