def __init__ (self, fct, counter_name = None) : self.fct = self.__func__ = fct self.__name__ = getattr (fct, "__name__", None) self.__doc__ = getattr (fct, "__doc__", None) self.changes = TFL.defaultdict (lambda : -1) self.result = TFL.defaultdict (lambda : None) if counter_name : self.counter_name = counter_name
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 __init__(self, markup, docstrings=True, *file_or_package_names): self._markups = markup self._mark_docstrings = docstrings self._translations = TFL.defaultdict(list) for file in self._filenames(file_or_package_names): for toknum, tokval, (sline, srow), (erow, ecol), line \ in tokenize.generate_tokens (file) : self._handle_tokens(toknum, tokval, sline)
def __init__ (self, attr_summary, is_dead) : self.attribute_changes = acs = TFL.defaultdict (Attr_Summary) if attr_summary : old = dict (attr_summary.old) if not is_dead : new = dict (attr_summary.new) else : n = None for a in set (itertools.chain (old, new)) : o = old.get (a) if not is_dead : n = new.get (a) acs [a].add (o, n)
def _from_string_match_kw(cls, s, match): assert match kw = TFL.defaultdict(int) mdct = match if isinstance (match, dict) \ else match.groupdict () for k, v in pyk.iteritems(mdct): if v: if k.startswith("sub"): n = k[3:] neg = "-" in match.group(n) f = float("%s0.%s" % (("-" if neg else ""), v)) if n == "days": h, m = divmod(f * 24 * 60, 60) m, s = divmod(m * 60, 60) kw["hours"] += int(h) kw["minutes"] += int(m) kw["seconds"] += int(s) elif n == "hours": m, s = divmod(int(f * 3600), 60) kw["minutes"] += int(m) kw["seconds"] += int(s) elif n == "minutes": s, us = divmod(int(f * 60 * 1e6), 1e6) kw["seconds"] += int(s) kw["microseconds"] += int(us) elif n == "seconds": ms, us = divmod(int(f * 1e6), 1000) kw["milliseconds"] += int(ms) kw["microseconds"] += int(us) elif n == "weeks": d, h = divmod(f * 7 * 24, 24) h, m = divmod(h * 60, 60) m, s = divmod(m * 60, 60) kw["days"] += int(d) kw["hours"] += int(h) kw["minutes"] += int(m) kw["seconds"] += int(s) elif n == "years": m = f * 12 d = abs(m - round(m)) if d > 0.05: raise ValueError \ ( "Fractional months are not allowed for " "%s: %s --> delta %s" % (cls.__name__, s, d) ) kw["months"] += int(round(m)) else: kw[k] += int(v) return kw
def NEW (cls, app_type, scope = None, ** _kw) : ems = TFL.Record\ ( max_cid = getattr (scope, "max_cid", 0) , max_pid = getattr (scope, "max_pid", 0) , max_surrs = getattr (scope, "max_surrs", TFL.defaultdict (int)) ) kw = dict (_kw) result = super (DB_Meta_Data, cls).NEW \ ( app_type, scope , max_cid = kw.pop ("max_cid", ems.max_cid) , max_pid = kw.pop ("max_pid", ems.max_pid) , max_surrs = kw.pop ("max_surrs", ems.max_surrs) , ** kw ) return result
def attribute_changes (self) : result = TFL.defaultdict (Attr_Summary) is_dead = self.is_dead new = None for c in self.changes : r = result if isinstance (c, MOM.SCM.Change.Attr_Composite) : r = result [c.attr_name] = Attr_C_Summary \ (result.get (c.attr_name), is_dead) for a in set (itertools.chain (c.old_attr, c.new_attr)) : old = c.old_attr.get (a) if not is_dead : new = c.new_attr.get (a) res = (result if a == "last_cid" else r) res [a].add (old, new) for a, ra in list (pyk.iteritems (result)) : if ra.old == ra.new : del result [a] return result
def _response_body_csv (self, resource, request, response) : def conv (s) : return pyk.as_str (s) boats = resource.obj.boats if not boats : return {} max_crew = max (len (b.crew) for b in boats) b_names = \ [ "registration_date" , "nation" , "sailnumber" , "boat_class" ] c_names = ["first_name", "last_name", "club", "oesv_no"] s_names = list (".".join (["skipper", c]) for c in c_names) s_len = len (s_names) w_names = list \ ( ".".join (["crew", str (i), c]) for i in range (1, max_crew+1) for c in c_names ) names = list (itertools.chain (b_names, s_names, w_names)) print ("*" * 5, max_crew, names) rows = [] result = dict (names = names, rows = rows) for b in boats : row = dict \ ( registration_date = b.FO.registration_date , nation = b.boat.FO.nation , sailnumber = b.boat.FO.sail_number , boat_class = b.boat.FO.b_class ) row.update (self._crew_attrs (s_names, b.skipper)) for i, c in enumerate (b.crew) : off = s_len * i row.update (self._crew_attrs (w_names [off:], c)) rows.append \ ( TFL.defaultdict (str, ((k, conv (v)) for k, v in row.items ())) ) return result
def probabilities(self): result = TFL.defaultdict(int) n = float(self.measurements) for i, f in pyk.iteritems(self.distribution): result[i] = f / n return result
def __init__(self, abscissa, *indices): self.abscissa = abscissa self.distribution = TFL.defaultdict(int) self.measurements = 0 self.invalid_values = 0 self.add(*indices)
def __init__(self, e_type): self.__super.__init__(e_type) self._attr_map = TFL.defaultdict(list) self.uniqueness = e_type.P_uniqueness + e_type.P_exclusion
def __init__(self, directories, lang=None, suffix=""): self.languages = set() self.directories = set() self.files_per_language = TFL.defaultdict(list) for d in directories: self._add_languages(d, set(lang), suffix)
def __init__(self, scope, db_url): self.__super.__init__(scope, db_url) self._counts = TFL.defaultdict(int) self.max_surrs = TFL.defaultdict(int) self._r_map = TFL.defaultdict(lambda: TFL.defaultdict(set)) self._tables = TFL.defaultdict(dict)
class CSS_Template(TFL.Meta.Object): """Models a css template and teh dependencies to parameter files.""" parameter_files = TFL.defaultdict(set) template_extension = ".css_template" templates = {} fix_percent_pat = re.compile("%([^(])") def __init__(self, template, parameter_file=None, css_file=None, polling=False): self.count = 0 self.polling = polling self.template = TFL.Filename \ (template, self.template_extension, absolute = True) self.css_file = TFL.Filename(css_file or ".css", self.template) self.pdict = {} if not os.path.isfile(self.template.name): raise ValueError("`%s` does not exist" % (self.template.name, )) self.templates[self.template.name] = self self.parameter_file = TFL.Filename \ (parameter_file or ".parameters", self.template) if os.path.isfile(self.parameter_file.name): self._update_dependencies() else: print("*** no parameter file for", self.template.name) self.parameter_file = None # end def __init__ def check_for_update(self): update = False if self.parameter_file: p_m_time = os.stat(self.parameter_file.name)[stat.ST_MTIME] update = p_m_time != self.p_m_time t_m_time = os.stat(self.template.name)[stat.ST_MTIME] update = update or (t_m_time != self.t_m_time) if update: self.create_css_file() # end def check_for_update def create_css_file(self, overrides={}): try: self.pdict = {} ### lets clear it again before we read everything self._update_dependencies() filename = self.template.name ct = open(filename).read() if self.polling: self.t_m_time = os.stat(filename)[stat.ST_MTIME] ct, _ = self.fix_percent_pat.subn \ (lambda m : "%%%s" % (m.group (0), ), ct) outf = open(self.css_file.name, "wb") outf.write(ct % Scope(globs=self.pdict, locls=overrides)) outf.close() print \ ( "[%04d] CSS file created `%s`" % (self.count, self.css_file.name, ) ) self.count += 1 except: traceback.print_exc() # end def create_css_file @classmethod def find_templates(cls, polling, directory, recursive=False): for file in os.listdir_full(directory): if os.path.isdir(file): if recursive: cls.find_templates(file, recursive=True) if file.endswith(".css_template") and not "#" in file: cls(file, polling=polling) # end def find_templates def _update_dependencies(self, filename=None): if filename is None: filename = self.parameter_file.name self.parameter_files[os.path.abspath(filename)].add(self) new_dir = TFL.Filename(filename).directory if new_dir: old_dir = os.getcwd() os.chdir(new_dir) if self.polling: self.p_m_time = os.stat(filename)[stat.ST_MTIME] execfile \ ( filename , dict ( R = TFL.Record , include = self._update_dependencies ) , self.pdict ) if new_dir: os.chdir(old_dir)
class _Manager_ (TFL.Meta.Object) : """Base class for entity managers.""" type_name = "XXX" Change_Summary = MOM.SCM.Summary Q_Result = TFL.Q_Result Q_Result_Composite = TFL.Q_Result_Composite lazy_load_p = False max_surrs = TFL.defaultdict (int) class Integrity_Error (Exception) : """Raised when `DBW` signals an integrity error.""" # end class Integrity_Error @property def db_meta_data (self) : return self.session.db_meta_data # end def db_meta_data @property def pcm (self) : return self.session.pcm # end def pcm @classmethod def connect (cls, scope, db_url) : self = cls (scope, db_url) self.session = self.DBW.connect_database (db_url, scope) return self # end def connect @classmethod def new (cls, scope, db_url) : self = cls (scope, db_url) self.session = self.DBW.create_database (db_url, scope) return self # end def new def __init__ (self, scope, db_url) : self.scope = scope self.db_url = db_url self.DBW = DBW = scope.app_type.DBW self.pm = DBW.Pid_Manager (self, db_url) scope.lazy_load_p = self.lazy_load_p self._reset_transaction () # end def __init__ def add (self, entity, pid = None) : e_type = entity.E_Type self._check_uniqueness (entity, e_type.uniqueness_ems) try : return self._add (entity, pid) except self.Integrity_Error as exc : self.rollback_pending_change () self._check_uniqueness (entity, e_type.uniqueness_dbw) ### if it wasn't a uniqueness constraint, ### re-raise the original exception raise # end def add def change_readonly (self, state) : self.session.change_readonly (state) self.commit () # end def change_readonly def close (self) : if self.uncommitted_changes : self.commit () self.session.close () # end def close def close_connections (self) : self.session.close_connections () # end def close_connections def commit (self) : if self.uncommitted_changes : self.session.commit () self._reset_transaction () # end def commit @TFL.Contextmanager def commit_context (self) : ### override as necessary, e.g., to lock tables in a database yield # end def commit_context def compact (self) : if self.uncommitted_changes : self.commit () self.session.compact () # end def compact def convert_creation_change (self, pid, ** kw) : """Convert creation-change for `pid` to passed values of `kw`""" cc = self.changes (pid = pid).one () ckw = dict \ ( (n, v) for n, v in ( (n, kw.pop (n, None)) for n in ("c_time", "c_user", "time", "user") ) if v is not None ) if kw : raise TypeError \ ( "Unknown arguments to convert_creation_change: %s" % (sorted (kw), ) ) cc.update (ckw) self.session._commit_creation_change (cc, kw) # end def convert_creation_change def count (self, Type, strict) : return self.query (Type, strict = strict).count () # end def count def exists (self, Type, epk) : epk_dict = dict (zip (Type.epk_sig, epk)) entities = self.query (Type).filter (** epk_dict) scope = self.scope result = list (getattr (scope, e.type_name) for e in entities) return result # end def exists def instance (self, Type, epk) : result = None epk_dict = dict (zip (Type.epk_sig, epk)) try : qr = self.query (Type, ** epk_dict) result = qr.one () except IndexError : pass else : if not isinstance (result, Type.Essence) : result = None return result # end def instance @subclass_responsibility def load_root (self) : """Redefine to load `root` of scope from database.""" # end def load_root def pid_query (self, pid, Type = None) : result = self.pm.query (int (pid)) if Type is not None and not isinstance (result, Type.Essence) : raise LookupError \ ( _T ("Pid `%r` is instance of type %s, not of type `%s`") % (pid, _T (result.ui_name), _T (Type.ui_name)) ) return result # end def pid_query def query (self, Type, * filters, ** kw) : root = Type.relevant_root strict = kw.pop ("strict", False) _query = self._query_single_root if root else self._query_multi_root result = _query (Type, strict) if filters or kw : result = result.filter (* filters, ** kw) if strict : result = result.filter (type_name = Type.type_name) return result # end def query def r_query (self, Type, rkw, * filters, ** kw) : return self.query (Type, * filters, ** dict (rkw, ** kw)) # end def r_query def register_change (self, change) : if change.parent is None : self.uncommitted_changes.add (change) change.register (self.scope) # end def register_change def register_scope (self) : """Redefine to store `guid` and `root`-info of scope in database.""" pass # end def register_scope def remove (self, entity) : self._removed_entities [entity.pid] = entity self._remove (entity) self.pm.retire (entity) entity.__class__ = entity.__class__._DESTROYED_E_TYPE # end def remove def restored (self, pid) : result = self._removed_entities.pop (pid, None) if result is not None : result.__class__ = result.E_Type return result # end def restored def rollback (self, keep_zombies = False) : with self.scope.temp_change_recorder (MOM.SCM.Ignorer) : self._rollback (keep_zombies) self._reset_transaction () # end def rollback def rollback_pending_change (self) : self.scope.rollback_pending_change () # end def rollback_pending_change def update (self, entity, change) : pass ### redefine as necessary in descendents # end def update @TFL.Contextmanager def save_point (self) : ### override if the backend supports savepoints yield # end def save_point @subclass_responsibility def _add (self, entity, pid = None) : pass # end def _add def _check_uniqueness (self, entity, uniqueness_predicates) : def _gen (entity, uniqueness_predicates) : for p in uniqueness_predicates : result = p.check_predicate (entity) if not result : yield result.error errors = list (_gen (entity, uniqueness_predicates)) if errors : raise MOM.Error.Invariants (errors) # end def _check_uniqueness @subclass_responsibility def _query_multi_root (self, Type, strict = False) : pass # end def _query_multi_root @subclass_responsibility def _query_single_root (self, Type, strict = False) : pass # end def _query_single_root @subclass_responsibility def _remove (self, entity) : pass # end def _remove def _reset_transaction (self) : self.uncommitted_changes = self.Change_Summary () self._removed_entities = {} # end def _reset_transaction def _rollback (self, keep_zombies) : self.session.rollback (keep_zombies) # end def _rollback def _rollback_uncommitted_changes (self) : scope = self.scope for c in reversed (self.uncommitted_changes) : if c.undoable : c.undo (scope) # end def _rollback_uncommitted_changes def __iter__ (self) : sk = TFL.Sorted_By ("pid") return itertools.chain \ (* ( self._query_single_root (r).order_by (sk) for r in self.scope.relevant_roots ) )
def _of_bases(self, cls): result = TFL.defaultdict(list) for b in reversed(cls.__bases__): for k, cs in pyk.iteritems(self.of_class(b)): result[k] = list(uniq(ichain(result[k], cs))) return result
def max_surrs(self): return TFL.defaultdict(int) ### XXX