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
