def __init__(self, conf=None): super(env, self).__init__() self._join = join = '.'.join self._conf = envz = environ if conf is not None: dumps = pickle.dumps b64enc = b64encode # populate os.environ for k, v in items(conf): for x, y in items(v): envz[join((k, x))] = b64enc(dumps(y)).decode('utf-8')
def templates(self, tempdict): ''' Sets inline text and attribute templates for child fields. :argument dict tempdict: Dictionary of templates ''' if isinstance(tempdict, dict): # make sure there are no more templates than there are fields if len(tempdict) <= len(self): self._templates = tempdict fielddict = self._fielddict XGroup = _XMLGroup for key, value in items(tempdict): item = fielddict[key] # handle groups if isinstance(item, XGroup): item.templates(value) # handle fields elif not hasattr(item, 'groupmark'): # check if text template is in dict try: item.template = value['text'] except KeyError: pass # check if attribute template is in dict try: item.atemplates(value['attrib']) except KeyError: pass # raise exception if more templates than fields else: raise TypeError('template count exceeds field count') else: raise TypeError('invalid source for templates')
def exhaustmap(mapping, call, filter=False, exception=StopIteration, _n=next): ''' call `next` on an iterator until it's exhausted @param mapping: a mapping to exhaust @param call: call to handle what survives the filter @param filter: a filter to apply to mapping (default: `None`) @param exception: exception sentinel (default: `StopIteration`) ''' subiter = ifilter(filter, items(mapping)) if filter else items(mapping) iterable = starmap(call, subiter) try: while True: _n(iterable) except exception: pass
def _setelement(self, tree): # set internal element. self.__name__ = _checkname(tree.attrib[self.mark]) # set internal element and backup tree self._tree, self._btree = tree, _copytree(tree) # make tree attribute dictionary a field attribute self._attrib, tattrib = tree.attrib, dict() # if inline text template in tree, assign it to template try: self.template = tree.text except TypeError: pass checkname_ = _checkname auto = self._auto mark = self.mark setattr_ = setattr cls = self.__class__ for attr, atext in items(self._attrib): # if attribute template text in template source, add to _tattrib if '$' in atext or '%' in atext: tattrib[attr] = atext # make XML attrs attributes of self if automagic on & not a mark if auto and attr != mark: name = checkname_(attr) # set new class as attribute of self's superclass setattr_(cls, name, _Attribute(attr, name)) # assign any attribute templates if tattrib: self.atemplates(tattrib)
def test_items(self): self.store['max'] = 3 self.store['min'] = 6 self.store['pow'] = 7 self.store.sync() slist = list(items(self.store)) self.assertEqual(('min', 6) in slist, True)
def items(self): loads = self.loads try: self._store.execute("SELECT data as i FROM shove") for k, v in items(self._store.fetchall()["i"]): yield k, loads(v, k) except psycopg2.ProgrammingError: self._conn.rollback()
def __iter__(self): cls = self.__class__ for key, value in items(self): # nested stuf of some sort if isinstance(value, cls): yield key, dict(iter(value)) # normal key, value pair else: yield key, value
def _copyetree(tree, builder): # copies an element to a different ElementTree implementation. element = builder(tree.tag, dict(items(tree.attrib))) element.tail, element.text = tree.tail, tree.text eappend = element.append copyetree = _copyetree for child in tree: eappend(copyetree(child, builder)) return element
def __getattr__(self, key, _getter=object.__getattribute__): try: return self[key] except KeyError: if key == 'iteritems': return items(self) elif key == 'iterkeys': return keys(self) elif key == 'itervalues': return values(self) return _getter(self, key)
def most_common(self, n=None): ''' list the n most common elements and their counts from the most common to the least If n is None, then list all element counts. ''' # Emulate Bag.sortedByCount from Smalltalk if n is None: return sorted(items(self), key=itemgetter(1), reverse=True) return heapq.nlargest(n, self.iteritems(), key=itemgetter(1))
def __getattr__(self, key, _getter=object.__getattribute__): try: if key == 'iteritems': return items(self) elif key == 'iterkeys': return keys(self) elif key == 'itervalues': return values(self) return _getter(self, key) except AttributeError: return self[key]
def inverse_lookup(value, this, default=None): ''' get attribute of an instance by value @param value: value to lookup as a key @param this: instance to check for attribute @param default: default key (default: None) ''' try: return itemgetter(value)(dict((v, k) for k, v in items(vars(this)))) except (TypeError, KeyError): return default
def update(self, attr): ''' Set internal element attributes with :class:`dict`. :argument dict attr: element attributes ''' if isinstance(attr, dict): _setattr = self._setattr for key, value in items(attr): _setattr(key, value) else: raise TypeError('invalid attribute source')
def __imod__(self, data): """ Substitutes text data into each field's template and the modified template (self) is returned. """ # get any templates try: self.templates(data.pop("templates")) except (AttributeError, KeyError): pass # get any substitutions try: self.__ipow__(data.pop("subs")) except (AttributeError, KeyError): pass # cache field and data length lself, length = len(self._fields), len(data) # if number of fields == number of items in data... if length == lself: fielddict = self._fielddict if isinstance(data, dict): for key, value in items(data): # if tuple, expand it try: fielddict[key].__ipow__(value) # if dictionary, substitute it except TypeError: fielddict[key].__imod__(value) elif isinstance(data, tuple): fields = self._fields # iterate with index and item through data for key, item in enumerate(data): # if item is a tuple, expand it try: fields[key].__ipow__(item) # if dictionary, substitute it except TypeError: fields[key].__imod__(item) else: raise TypeError(_exceptions[2]) # return self if no more items in data elif length == 0: return self # raise exception if too many items to match all fields elif length > lself: raise TypeError(_exceptions[3]) # raise exception if too few items to match all fields elif length < lself: raise TypeError(_exceptions[4]) return self
def __delitem__(self, key): # handle positional indexes try: # get field obj = self._fields[key] # get field name for name, element in items(self._fielddict): if element == obj: break # handle keys except TypeError: name = key # delete object attribute self.__delattr__(name)
def wrapper(*args, **kw): key = args if kw: key += tuple(sorted(items(kw))) try: result = cache.pop(key) except KeyError: result = this(*args, **kw) # purge least recently used cache entry if len(cache) >= maxsize: cache.popitem(0) # record recent use of this key cache[key] = result return result
def object_walk(this): ''' transform classes within an instance into a dictionary @param this: object ''' this_stuf = dict() for k, v in items(vars(this)): if not k.startswith('_'): if isclass(v): this_stuf[k] = object_walk(v) else: this_stuf[k] = v return this_stuf
def inverse_lookup(value, this, default=None): ''' get attribute of an instance by value @param value: value to lookup as a key @param this: instance to check for attribute @param default: default key (default: None) ''' try: return itemgetter(value)( dict((v, k) for k, v in items(vars(this))) ) except (TypeError, KeyError): return default
def __init__(self, context, stype, newkey, **options): self.context = context self._type = stype self._type_name = newkey self._socket = xs.socket(context._ctx, stype) options.update(context._options) _set = self._set rc = 0 for k, v in items(options): rc |= _set(k, v) self.last_rc = rc context.sockets[self.id] = self self.closed = False self.connections = OrderedDict() self.bindings = OrderedDict()
def _build(cls, iterable, _map=imap, _is=isinstance, _list=exhaust): kind = cls._map # add class to handle potential nested objects of the same class kw = kind() update = kw.update if _is(iterable, Mapping): update(kind(items(iterable))) elif _is(iterable, Sequence): # extract appropriate key-values from sequence def _coro(arg, update=update): try: update(arg) except (ValueError, TypeError): pass _list(_map(_coro, iterable)) return kw
def atemplates(self, attr): ''' Sets templates for the internal element's attributes. :argument attr: attribute template ''' if isinstance(attr, dict): tattrib = dict() # set template for each item in attrib dict Stemplate = _Stemplate for key, value in items(attr): # make string.template instance if delimiter '$' is found if '$' in value: tattrib[key] = Stemplate(value) # use standard Python format string if delimiter '%' found elif '%' in value: tattrib[key] = value # raise exception if no delimiter found else: raise TypeError(_exceptions[8]) # assign object attribute for attribute template dictionary self._tattrib.update(tattrib) else: raise TypeError(_exceptions[7])
return self.expr(that) if this is None else self._set(this) class either(bothbase): ''' descriptor that caches results of both instance- and class-level results ''' def __get__(self, this, that): if this is None: return setter(that, self.name, self.expr(that)) return self._set(this) class twoway(bothbase): '''descriptor that enables instance and class-level results''' def __get__(self, this, that): return self.expr(that) if this is None else self.method(this) lru_wrapped = lru get_or_default = getdefault __all__ = sorted(name for name, obj in items(locals()) if not any([ name.startswith('_'), ismodule(obj), ])) del ismodule
def reset(self): '''reset previously accessed `lazybase` attributes''' this = vars(self) t = lambda x, y: x in this and isinstance(y, lazybase) exhaustmap(items(vars(getcls(self))), delattr, t)
def __iter__(self): for k, v in items(self._all): yield k, v
class-level results ''' def __get__(self, this, that): return self.expr(that) if this is None else self._set(this) class either(bothbase): ''' descriptor that caches results of both instance- and class-level results ''' def __get__(self, this, that): if this is None: return setter(that, self.name, self.expr(that)) return self._set(this) class twoway(bothbase): '''descriptor that enables instance and class-level results''' def __get__(self, this, that): return self.expr(that) if this is None else self.method(this) lru_wrapped = lru get_or_default = getdefault __all__ = sorted(name for name, obj in items(locals()) if not any([ name.startswith('_'), ismodule(obj), ])) del ismodule