def _init_kw (self, kw) : kw_err = {} for k, v in pyk.iteritems (self.init_arg_defaults) : if not hasattr (self, k) : setattr (self, k, v) for k, v in pyk.iteritems (kw) : if k in self.init_arg_defaults : ### protect `%` characters hidden inside `v` to avoid ### ValueErrors during formatting if isinstance (v, pyk.string_types) : v = v.replace ("%", "%%") elif isinstance (v, (tuple, list, TFL.NO_List)) : vin = v v = [] for x in vin : if isinstance (x, pyk.string_types) : x = x.replace ("%", "%%") v.append (x) if k in self._autoconvert : v = self._autoconvert [k] (self, k, v) setattr (self, k, v) else : kw_err [k] = v if kw_err : print (self.__class__, self.init_arg_defaults) raise TypeError ("unexpected keyword arguments: %s" % kw_err)
def __init__ (self, site, request, url = url) : self.site = site self.request = request rtparm = 1 if url.endswith ('cgi') : rtparm = 2 if 'interfaces' in self.request or 'ips' in self.request : rt = Routes (site = site, url = url + '?post_routes=%s' % rtparm) dt = Details (site = site, url = url + '?post_olsr=1') self.version = rt.version interfaces = {} ips = {} base = 0 for count, (ip, ifname) in enumerate (pyk.iteritems (rt.ip_dev)) : i4 = Inet4 (ip, None, None, iface = ifname) # ignore interfaces with unroutable IPs if unroutable (i4.ip) : #print ("Unroutable: %s" % i4) continue ips [i4] = 1 iface = Interface (count, ifname, None) iface.is_wlan = False interfaces [ifname] = iface iface.append_inet4 (i4) base = count base += 1 for count, (ip, ifname) in enumerate (pyk.iteritems (dt.ip_dev)) : i4 = Inet4 (ip, None, None, iface = ifname) is_wlan = sum (x == 1.0 for x in dt.metric [ip]) != 3 #print ("ip", ip, dt.metric [ip]) if unroutable (i4.ip) : continue if i4 in ips : if ifname not in interfaces : iface = Interface (base + count, ifname, None) interfaces [ifname] = iface iface.append_inet4 (i4) else : iface = interfaces [ifname] if i4 not in iface.inet4 : #print ("Oops:", ifname, i4, iface.inet4 [0]) del iface.inet4 [0] iface.append_inet4 (i4) iface.is_wlan = is_wlan continue ips [i4] = 1 iface = Interface (base + count, ifname, None) iface.is_wlan = is_wlan interfaces [ifname] = iface iface.append_inet4 (i4) # check own ip n = 'unknown' i4 = Inet4 (self.request ['ip'], None, None, iface = n) assert i4 in ips self.request ['ips'] = ips self.request ['interfaces'] = interfaces self.request ['version'] = rt.version
def from_list (cls, medias, ** kw) : to_add = dict ((n, v) for n, v in pyk.iteritems (kw) if v) if len (medias) == 1 and not to_add : result = medias [0] else : result = \ CHJ.Media (children = medias) if (medias or to_add) else None for n, v in pyk.iteritems (to_add) : getattr (result, n).add (* v) return result
def _gen (ETW) : for k, q in sorted (pyk.iteritems (ETW.q_able_attrs)) : if not q.kind.show_in_ui : continue if k == q.attr.name : ### filter attribute-aliases yield str (q) if q.q_able_attrs : for k, q in sorted (pyk.iteritems (q.q_able_attrs)) : if not q.kind.show_in_ui : continue if not q.columns : yield str (q)
def __call__ (self, * args, ** kw) : _request = self._request _response = self._response for c in list (_request.cookies_to_delete) : self.clear_cookie (c) _request.cookies_to_delete.clear () for k, v in pyk.iteritems (self._auto_headers) : _response.add_header (k, v) for rel, (value, kw) in sorted (pyk.iteritems (self._links)) : _response.add_header ("link", value, rel = rel, ** kw) return _response.__call__ (* args, ** kw)
def _create_properties (self, e_type) : for n, prop_type in pyk.iteritems (self._own_names) : if prop_type is not None : self._add_prop (e_type, n, prop_type) base_props = {} for b in e_type.__bases__ [::-1] : bps = getattr (b, self._prop_map_name, {}) base_props.update (bps) for n, prop_type in pyk.iteritems (self._names) : if n not in self._own_names : ### Inherited property: include in `_prop_dict` and `_prop_kind` prop = base_props.get (n) if prop is not None : self._setup_prop (e_type, n, prop.kind, prop)
def _setup_exprs (self, exprs, kw) : self.exprs = [] add = self.exprs.append for x in exprs : if isinstance (x, dict) : for f, e in sorted (pyk.iteritems (x)) : add (Expression (f, e)) else : if isinstance (x, pyk.string_types) : x = (x, ) if not isinstance (x, Expression) : x = Expression (* x) add (x) for f, e in sorted (pyk.iteritems (kw)) : add (Expression (f, e))
def create_test_dict(self, test_spec, backends=None, bpt=1, combiner=None, ignore=set()): result = {} if backends is None: backends = sos.environ.get("GTW_test_backends", ("HPS:SQL")) if backends == "*": backends = sorted(self.Backend_Parameters) else: backends = list(p.strip() for p in backends.split(":")) if combiner is None: combiner = self.combiner if isinstance(ignore, pyk.string_types): ignore = set((ignore,)) elif not isinstance(ignore, set): ignore = set(ignore) if not isinstance(test_spec, dict): test_spec = {"": test_spec} for w in combiner((b for b in backends if b not in ignore), bpt): for name, code in pyk.iteritems(test_spec): key = "_".join(p for p in (name,) + w if p) bsd = dict(self._backend_spec(w)) test = "%s\n\n %s\n" % ( code % bsd, "\n ".join((">>> try :", "... Scaffold.reset ()", "... except Exception :", "... pass")), ) result[key] = test return result
def _record_iter (obj, level, compact, seen) : for k, v in sorted (pyk.iteritems (obj._kw), key = SK) : rk = pyk.text_type (k) it = formatted_repr.iter (v, level + 1, compact, seen) for x in formatted_repr._structure_iter \ (it, level, rk + " = ", "", "", nl_after_open = True) : yield x
def _items_iter (obj, level, compact, seen) : for k, v in sorted (pyk.iteritems (obj), key = SK) : rk = portable_repr (k) it = formatted_repr.iter (v, level + 1, compact, seen) for x in formatted_repr._structure_iter \ (it, level, rk + " : ", "", "", nl_after_open = True) : yield x
def __init__ (cls, name, bases, dct) : cls.__m_super.__init__ (name, bases, dct) bn = tuple (reversed ([getattr (b, "_nested_", {}) for b in bases])) cls._nested_ = _nested_ = ddict (* bn) Q_Root = TFL.Q_Exp.Q_Root for k, v in pyk.iteritems (dct) : cls._setup_prop (k, v, Q_Root, _nested_)
def col_values_from_cargo (self, pickle_cargos) : pickle_cargo = pickle_cargos [0] for name, kind_wrapper in pyk.iteritems (self.db_attrs) : attr_pc = pickle_cargo.get (name) if attr_pc is not None : for k, v in kind_wrapper.col_values_from_cargo (attr_pc) : yield k, v
def __str__ (self) : result = ["SQ [%s]" % (self.type_name)] if self._filters or self._kw : args = list (str (f) for f in self._filters) args.extend \ ( "%s = %r" % (k, v) for k, v in sorted (pyk.iteritems (self._kw)) ) result.append ("filter (%s)" % ", ".join (args)) if self._group_by : args = list (str (f) for f in self._group_by) result.append ("group_by (%s)" % ", ".join (args)) if self._distinct is not None : result.append ("distinct (%s)" % self._distinct) if self._order_by : args = list (str (f) for f in self._order_by) result.append ("order_by (%s)" % ", ".join (args)) if self._limit is not None : result.append ("limit (%s)" % (self._limit, )) if self._offset is not None : result.append ("limit (%s)" % (self._offset, )) if self._attr is not None : result.append ("attr (%s)" % (self._attr, )) if self._attrs : result.append ("attrs (%s)" % (self._attrs, )) sep = "\n ." if len (result) > 2 else "." return sep.join (result)
def _setup_QC (self, QC, col_map) : self.QC = QC QC.MOM_Wrapper = self col_map.update ((qn, QC) for qn in self.q_able_names) for k, akw in pyk.iteritems (self.q_able_attrs) : if k not in self.db_attrs : col_map [akw.name] = akw
def attr_filters \ ( soc, E_Type, request, data, scope , a_pat = None , default_op = "EQ" ) : filters = [] filters_q = [] map = TFL.mm_dict_mm_list () af_args = ichain \ ( soc.af_args_api (request.req_data_list, default_op) , soc.af_args_fif (data, a_pat, default_op) ) for fn, name, typ, tail, op, value in af_args : if typ : map [name] [typ].append ((tail, op, value)) else : f, fq = soc._setup_attr (E_Type, fn, name, op, value) filters.append (f) filters_q.append (fq) for name, t_map in pyk.iteritems (map) : if len (t_map) > 1 : raise ValueError \ ( "Got types %s instead of exactly one type" % (sorted (t_map), ) ) typ = first (t_map) nqr = soc.nested (scope, scope [typ], t_map [typ]) fs, fq = soc._setup_attr_pepk (E_Type, name, nqr) filters.extend (fs) filters_q.append (fq) return tuple (filters), tuple (filters_q)
def check_attr_conflicts (self, entity, initial_values) : result = False for name, acs in pyk.iteritems (self.attribute_changes) : attr = entity.attr_prop (name) ini = initial_values.get (name) result += acs.check_conflict (attr, entity, ini) return result
def __init__ (cls, name, bases, dct) : cls.__m_super.__init__ (name, bases, dct) for map_name in "op_map", "rop_map" : map = getattr (cls, map_name, None) if map : for k, v in list (pyk.iteritems (map)) : map.setdefault (normalized_op_name (k), v)
def _gen (self, ET, bindings) : a_doc = self._e_type_attr_doc dle = self._dl_element for k, v in sorted (pyk.iteritems (bindings)) : vs = a_doc (v, indent) for l in dle (":%s:" % k, * vs, indent = indent) : yield l
def destroy_all (cls) : """Destroy all scopes.""" for i, s in sorted (pyk.iteritems (Scope.Table), reverse = True) : try : s.destroy () except Exception : pass
def row_as_pickle_cargo (self, row, db_attrs = None) : result = TFL.defaultdict (tuple) if db_attrs is None : db_attrs = self.db_attrs for name, kind_wrapper in pyk.iteritems (db_attrs) : result [name] = kind_wrapper.row_as_pickle_cargo (row) return result
def undotted_dict (d, sep = ".") : """Return a dict with un-dotted keys. Dotted keys in `d` are converted to nested dictionaries with un-dotted keys in the result. >>> def show (d) : ... def gen (d) : ... for k, v in sorted (pyk.iteritems (d)) : ... if isinstance (v, dict) : ... v = show (v) ... yield "%r : %s" % (k, v) ... return "{%s}" % (", ".join (gen (d))) ... >>> show (undotted_dict({"a" : 1, "ab.b" : 2})) "{'a' : 1, 'ab' : {'b' : 2}}" >>> show (undotted_dict({"a" : 1, "ab.b" : 2, "ab.c.d" : 42})) "{'a' : 1, 'ab' : {'b' : 2, 'c' : {'d' : 42}}}" """ result = {} for k, v in sorted (pyk.iteritems (d)) : n = k target = result if sep in k : os, _, n = rsplit_hst (k, sep) for o in os.split (sep) : target = target.setdefault (o, {}) assert isinstance (target, dict), "Need a dict: %s, %s" % (o, k) target [n] = v return result
def __init__ (self, source, target, * args, ** kw) : self.pop_to_self (kw, * self._attr_names) if kw : raise TypeError \ ("Unknown arguments %s" % (sorted (pyk.iteritems (kw)))) self.source = source self.target = target
def Elem_Type \ ( elem_type , bases = None , front_args = () , rest_args = None , init_arg_defaults = {} , _autoconvert = {} , ** attributes ) : """Return a new subclass of XML.Element""" if bases is None : bases = (TFL.SDG.XML.Element, ) attr_names = [] front_dict = dict_from_list (front_args) init_arg_defaults = dict (init_arg_defaults) for k, v in pyk.iteritems (attributes) : init_arg_defaults [k] = v if not (k in front_dict or k == rest_args) : attr_names.append (k) return TFL.SDG.XML.Element.__class__ \ ( elem_type, bases , dict ( attr_names = tuple (sorted (attr_names)) , _autoconvert = _autoconvert , elem_type = elem_type , front_args = front_args , init_arg_defaults = init_arg_defaults , rest_args = rest_args , __module__ = TFL.Caller.globals () ["__name__"] ) )
def __init__ \ ( self , olsr_file , processes = 20 , N = 0 , timeout = 180 , ip_port = {} , debug = False , ** kw ) : self.__super.__init__ (**kw) olsr = get_olsr_container (olsr_file) self.olsr_nodes = {} assert len (olsr.topo.forward) for t in pyk.iterkeys (olsr.topo.forward) : self.olsr_nodes [t] = True for t in pyk.iterkeys (olsr.topo.reverse) : self.olsr_nodes [t] = True # limit to N elements if N : self.olsr_nodes = dict \ ((k, v) for k, v in islice (pyk.iteritems (self.olsr_nodes), N)) self.pool = Pool (processes = processes) self.mgr = Manager () self.result_dict = self.mgr.dict () self.timeout = timeout self.ip_port = ip_port self.debug = debug olsr_nodes = None if not debug : self.log.setLevel (INFO) self.log.debug ("Starting ...")
def averager (self) : result = self._averager if result is None : result = TFL.DRA.Averager () for i, f in pyk.iteritems (self.distribution) : result.add (i for k in range (f)) return result
def _fill_cache (self) : if self._cache is None : pred = self._criterion result = dict () sums = _Sum_Aggr_ () sum_col = None for row in self.iterable : key = pred (row) is_sum = getattr (row, "_IS_SUM", None) if is_sum is not None : sums [key] = is_sum (row) sum_col = getattr (row, "_SUM_CO", None) result [key] = row if sums : sum_fixed = [] for key, row in pyk.iteritems (result) : if sum_col is None : sum_fixed.append (sums [key]) else : sum_fixed.append \ ( row [:sum_col] + (sums [key], ) + row [sum_col + 1:] ) result = sum_fixed else : result = pyk.itervalues (result) if self._distinct and not self.iterable._distinct : result = self._distinct (result) self._cache = list (result)
def _fix_keys_dict_iter (dct) : for k, v in pyk.iteritems (dct) : if isinstance (k, (int, float)) : k = str (k).lower () ### `.lower` because `bool` elif k is None : k = "null" yield k, _fix_keys (v)
def compile (self, cmd) : for lang, files in pyk.iteritems (self.files_per_language) : for po_file_n in files : po_file = TFL.Babel.PO_File.load (po_file_n) if po_file.fuzzy and not cmd.use_fuzzy : print \ ( "Catalog %r is marked as fuzzy, skipping" % (po_file_n, ) ) continue for message, errors in po_file.catalog.check (): for error in errors : print \ ( "Error: %s:%d: %s" % (po_file_n, message.lineno, error) , file = sys.stderr ) if cmd.javascript : js_file_n = self._output_file_name (cmd, lang, po_file_n) print \ ("compiling catalog %r to %r" % (po_file_n, js_file_n)) po_file.generate_js (lang, js_file_n) else : mo_file_n = self._output_file_name \ (cmd, lang, po_file_n, suffix = cmd.file_suffix) print \ ("compiling catalog %r to %r" % (po_file_n, mo_file_n)) po_file.generate_mo (mo_file_n)
def _setup_all () : global __all__ _g = globals () _g.update (Type.Table) _g.update (M_Media.Nick) __all__ = tuple \ (k for (k, v) in pyk.iteritems (_g) if isinstance (v, (M_Media, Type)))
def satisfied (self, obj, attr_dict = {}) : """Checks if `obj' satisfies the predicate. `attr_dict' can provide values for `self.attributes'. If there is a `self.guard' the predicate is checked only if `self.guard' evaluates to true. """ glob_dict = obj.globals () if not self._guard_open (obj, attr_dict, glob_dict) : return True val_disp = self.val_disp = {} val_dict = self.val_dict = self._val_dict (obj, attr_dict) if not val_dict : return True for p in self.parameters : exc, val = self._eval_expr \ (p, obj, glob_dict, val_dict, "parameter") if val is None or exc is not None : return True val_disp [p] = val if val is None else ui_display (val) for b, expr in pyk.iteritems (self.bindings) : if callable (expr) : val = expr disp = "%s" % (ui_display (val), ) else : exc, val = self._eval_expr \ (expr, obj, glob_dict, val_dict, "binding") if exc is not None : return True disp = "%s << %s" % (ui_display (val), expr) val_dict [b] = val val_disp [b] = disp return self._satisfied (obj, glob_dict, val_dict)
def _gen(): if value is not None: for k, v in sorted(pyk.iteritems(value)): qk = getattr(q, k) qop = getattr(qk, self.base_op_key) r = qop(v) if r is not None: yield r
def _insert_kw(self, session, kw): db_attrs_o = self.db_attrs_o spk_name = self.spk_name ikw = dict \ ( (k, v) for k, v in pyk.iteritems (kw) if k == spk_name or k in db_attrs_o ) return ikw
def _restore(self, scope): cargo = self.new_attr try: self._modify(scope, cargo) except Exception as exc: print(exc) print(" ", self.pid, self.epk, sorted(pyk.iteritems(cargo))) raise
def setup_links(self): renderer = self.renderer entity = self.entity Link = renderer.Link link_map = self.link_map node_map = renderer.node_map for k, r in sorted(pyk.iteritems(entity.rel_map)): link_map[k] = Link(r, self, node_map[r.target.type_name])
def _formatted_kw(self, seen=None): if seen is None: seen = set([id(self)]) return ", ".join \ ( ( "%s = %s" % (k, portable_repr.call (v, seen)) for (k, v) in sorted (pyk.iteritems (self._kw)) ) )
def _find_entites(ref_map): for ET, attrs in pyk.iteritems(ref_map): if not ET.is_partial: QR = self.Q_Result(ET) query_args = TFL.Filter_Or \ (* (getattr (MOM.Q, a) == entity for a in attrs)) for e in QR.filter(query_args): yield e, attrs
def request_args_abs (self) : request_args = self.request_args relative_args = self.relative_args result = dict \ ( (k, v) for k, v in pyk.iteritems (request_args) if k not in relative_args ) return result
def _formatted_attrs(self, *args, **kw): for k, v in sorted(pyk.iteritems(self.init_arg_defaults)): a = getattr(self, k) if a != v: if str != str and isinstance(a, str): ### Python2: encode unicode to avoid `u`-prefix a = TFL.I18N.encode_o(a) yield "%s = %r" % (k, a)
def _setup_alias_attrs(self, ETW_alias, result): parent = result.eff parent_attrs = parent.db_attrs if parent is not result else {} result.db_attrs_o = result.db_attrs = dict \ ( ( k, v.alias (ETW_alias, outer = result, parent = parent_attrs.get (k)) ) for k, v in pyk.iteritems (self.db_attrs) ) result.q_able_attrs_o = result.q_able_attrs = dict(result.db_attrs) result.q_able_attrs.update \ ( ( k, v.alias (ETW_alias, outer = result, parent = parent_attrs.get (k)) ) for k, v in pyk.iteritems (self.q_able_attrs) if k not in result.db_attrs )
def _base_operator(cls): names = set(_order_operators + ("__cmp__", )) ops = cls.operators = dict() for name, func in pyk.iteritems(cls.__dict__): if name in names: func.__doc__ = getattr(object, name).__doc__ ops[name] = func return cls
def _mark_entities_for_reload(self, keep_zombies=False): ### dict will be modified for pid, e in tuple(pyk.iteritems(self._pid_map)): if isinstance(e, MOM._Id_Entity_Destroyed_Mixin_): if not keep_zombies: del self._pid_map[pid] elif not isinstance(e, MOM._Id_Entity_Reload_Mixin_): e.__class__ = e.__class__._RELOAD_E_TYPE
def __repr__ (self) : name = self.__class__.__name__ attrs = sorted \ ( (k.strip ("_"), v) for k, v in sorted (pyk.iteritems (self.__dict__)) ) return "%s (%s)" % \ (name, ", ".join (("%s = %s" % (k, v)) for k, v in attrs))
def q_able_attrs(self): result = dict(self.q_able_attrs_i) result.update(self.q_able_attrs_o) for k, v in tuple(pyk.iteritems(result)): for name in v.q_able_names: if name not in result: result[name] = v return result
def from_string (soc, s, obj = None) : if isinstance (s, dict) : RT = soc.P_Type kw = \ {k : RT.bound_from_string (v) for k, v in pyk.iteritems (s)} result = soc.from_attr_tuple (** kw) else : result = super (_A_Range_, soc).from_string (s, obj) return result
def bindings (self) : FO = self.FO return sorted \ ( (k, (pyk.decoded (FO (k, v)) if v is not None else v)) for (k, v) in itertools.chain ( (zip (self.e_type.epk_sig, self.epk)) , pyk.iteritems (self.kw) ) )
def _polished (self, attr, name, value, value_dict, essence, picky) : result = {} match = self.matcher.search (value) if match is not None : dct = match.groupdict () for k, v in pyk.iteritems (dct) : if v is not None : result [k] = v return result
def __call__(self, *args, **kw): self.pop_to_self(kw, "anchor", "offset") self.pop_to_self(kw, "label", prefix="_") if kw: raise TypeError \ ("Unknown arguments: %s" % (sorted (pyk.iteritems (kw)), )) for a in args: self._add(a) return self
def dict_let(dct, **kw): """Provide context with elements of dictionary `dct` temporary bound to values in `kw`. """ store = {} undef = TFL.Undef() for k, v in pyk.iteritems(kw): store[k] = dct.get(k, undef) try: for k, v in pyk.iteritems(kw): dct[k] = v yield finally: for k, v in pyk.iteritems(store): if v is undef: del dct[k] else: dct[k] = v
def _t_count(self, Type, seen=None): if seen is None: seen = set() result = self._counts[Type.type_name] for n, c in pyk.iteritems(Type.children): if n not in seen: seen.add(n) result += self._t_count(c, seen) return result
def _match_iter (self, col_iter, word, max_edits) : """Generate all words with a Levenshtein-distance <= max_edits to word.""" ### http://en.wikipedia.org/wiki/Levenshtein_distance ### http://stevehanov.ca/blog/index.php?id=114 row_1 = pyk.range (len (word) + 1) for char, node in pyk.iteritems (self.root.children) : for m in self._match_iter_inner \ (col_iter, word, max_edits, char, node, row_1) : yield m
def _field_iter(self, s): match = self.regexp.search(s) if match: for k, v in pyk.iteritems(match.groupdict()): if v is not None: yield k, v else: raise ValueError \ ("`%s` doesn't match `%s`" % (s, self.regexp._pattern.pattern))
def _gen(self, ets): def _sk(x): k, _ = x return -len(k), k ### longest first, deterministic for k, v in sorted(pyk.iteritems(ets), key=_sk): head = k.split("/")[0] if "/" in k else "" yield Regexp \ ("%s\[(?!%s\])" % (re.escape (head), re.escape (v)))
def _from_string_match_kw(cls, s, match): assert match kw = {} for k, v in pyk.iteritems(match.groupdict()): if v: if k == "month": v = cls.month_from_string(v) kw[k] = int(v) return kw
def _gen(q_able_attrs, level=0): for k, q in sorted(pyk.iteritems(q_able_attrs)): if not q.kind.show_in_ui: continue if k == q.attr.name: ### filter attribute-aliases yield "%s%-30s: %s" % (" " * level, k, ", ".join( q.q_able_names)) if q.q_able_attrs: yield from _gen(q.q_able_attrs, level + 1)
def db_attrs_i (self) : p = self.parent if p : et_attrs = self.e_type.attributes return dict \ ( (name, pw.Derived (self, et_attrs [name])) for name, pw in pyk.iteritems (p.db_attrs) ) return {}
def Op_Map(self): result = {} for k, v in pyk.iteritems(_Type_.Base_Op_Table): sym = _T(v.op_sym) result [k] = dict \ ( desc = _T (v.desc) , sym = sym ) return result
def description (self) : epk_values = zip \ (self.e_type.epk_sig, (portable_repr (x) for x in self.epk)) epk_bindings = self._formatted_bindings (epk_values) kw_bindings = self._formatted_bindings (pyk.iteritems (self.kw)) return \ ( _T ("Instead it got: (%s)") % ", ".join (itertools.chain (epk_bindings, kw_bindings)) )
def __str__(self): r = [] for k, v in pyk.iteritems(self.assignments): r.append("%(k)s = %(v)s" % locals()) for b in self.bridges: r.append("Bridge: %s" % str(b)) for i in self.interfaces: r.append(str(i)) return '\n'.join(r)
def _of_class(self, cls): name = repr(cls).split("'")[1] result = self._of_bases(cls) for k, v in pyk.iteritems(cls.__dict__): is_thunder = k.startswith("__") and k.endswith("__") is_super = k.endswith(("__super", "__c_super", "__m_super")) if not (is_thunder or is_super): result[k].append(name) return result
def _ (self) : d = {} for a in "indent_anchor", "indent_offset", "ht_width" : try : d [a] = self [a] except KeyError : pass return ", ".join \ ([("%s = %s" % (n, v)) for (n, v) in sorted (pyk.iteritems (d))])