def _backend_reset (self) :
for apt in pyk.itervalues (MOM.App_Type.Table) :
for apt_d in pyk.itervalues (apt.derived) :
try :
SAW = apt_d._SAW
except AttributeError :
pass
else :
### reset caches to avoid sequence dependencies between
### different test cases
SAW.reset_cache ()
def _gen_roles (cls) :
for a in sorted \
( pyk.itervalues (cls._Attributes._names)
, key = TFL.Sorted_By ("rank", "name")
) :
if a is not None and issubclass (a, MOM.Attr.A_Link_Role) :
yield a
def update_etype(cls, e_type, app_type):
ETW = e_type._SAW
if ETW is not None:
if ETW.e_type is e_type:
sa_table = ETW.sa_table
if sa_table is None:
if e_type.is_relevant:
needs_table = not (e_type.is_partial or e_type.iea_type_restrictions)
if needs_table:
raise TypeError("Non-partial revelant type %s " "without a table?" % (e_type.type_name,))
### partial e_type with relevant_root
### fix children (the children's ETW refer to the first
### ancestor with a sa_table)
ETW.children = sorted(
(c._SAW for c in pyk.itervalues(e_type.children)), key=TFL.Getter.type_name
)
else:
unique = ETW.unique
unique_o = ETW.unique_o
if unique and unique == unique_o and not e_type.polymorphic_relevant_epk:
sa_table.append_constraint(SA.schema.UniqueConstraint(*unique))
e_type.P_uniqueness[0].ems_check = False
cls._add_check_constraints(e_type, ETW, sa_table)
cls._add_user_defined_indices(e_type, ETW, sa_table)
if e_type._Reload_Mixin_ is not None and not e_type.is_partial:
e_type._Reload_Mixin_.define_e_type(e_type, _Reload_Mixin_)
elif ETW.root_table is not None:
etw = e_type._SAW = cls.PNS.Partial_E_Type_Wrapper(e_type, ETW)
ETW.ATW.add(etw)
def _rrule_attrs(self):
for a in pyk.itervalues(self.attributes):
name = getattr(a, "rrule_name", None)
if name:
value = a.get_value(self)
if value is not None and value != []:
yield name, value
def record(self, Change, *args, **kw):
"""Record change of type `Change`."""
result = self._recorder(Change, *args, **kw)
self.total_changes += 1
if self.dependents:
self._recorder.update(pyk.itervalues(self.dependents))
return result
def _query_multi_root (self, Type, strict = False) :
tables = self._tables
return self.Q_Result_Composite \
( [ self.Q_Result (pyk.itervalues (tables [t]))
for t in Type.relevant_roots
]
)
def _rrule_attrs (self) :
for a in pyk.itervalues (self.attributes) :
name = getattr (a, "rrule_name", None)
if name :
value = a.get_value (self)
if value is not None and value != [] :
yield name, value
def show_root_table(apt, pred=pred):
sk = lambda x: (x.e_type.i_rank, )
for ETW in sorted(pyk.itervalues(apt._SAW.et_map), key=sk):
if not pred(ETW):
continue
T = ETW.e_type
print(("%-36s %s" % (T.type_name, ETW.root_table)).rstrip())
def all_links (self, obj_id) :
r_map = self._r_map
result = sorted \
( itertools.chain (* (rm [obj_id] for rm in pyk.itervalues (r_map)))
, key = self.scope.MOM.Id_Entity.sort_key_pm ()
)
return result
def verbose_repr(self):
r = [str(self)]
for v in pyk.itervalues(self.interfaces):
r.append(str(v))
for v in pyk.iterkeys(self.ips):
r.append(str(v))
return '\n'.join(r)
def record (self, Change, * args, ** kw) :
"""Record change of type `Change`."""
result = self._recorder (Change, * args, ** kw)
self.total_changes += 1
if self.dependents :
self._recorder.update (pyk.itervalues (self.dependents))
return result
def verbose_repr (self) :
r = [str (self)]
for v in pyk.itervalues (self.interfaces) :
r.append (str (v))
for v in pyk.iterkeys (self.ips) :
r.append (str (v))
return '\n'.join (r)
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 _gen_roles(cls):
for a in sorted \
( pyk.itervalues (cls._Attributes._names)
, key = TFL.Sorted_By ("rank", "name")
) :
if a is not None and issubclass(a, MOM.Attr.A_Link_Role):
yield a
def _setup_target_packages (self, pip) :
dc = self.delta_closure
path = TFL.sos.path
sep = TFL.sos.sep
self.pym_dict = pym_dict = {}
self.py_modules = pyms = []
self.py_packages = pyps = []
for pym in dc.pym_dict.values () :
for pyp in pym.pkg_chain () :
if pyp.rel_name not in dc.pym_dict :
dc._add (pyp)
for pym in pyk.itervalues (dc.pym_dict) :
pym.target_pkg = pym.pkg
pym.target_path = path.join \
(self.target_root, pym.pkg.replace (".", sep), pym.base_path)
pym.source_pns = self._pns_from_pkg (pym.pkg)
pym.target_pns = self._pns_from_pkg (pym.target_pkg)
if pym.is_package :
self._make_target_dir (pym)
pym.source_mod = pym.pkg
pym.target_mod = pym.target_pkg
pyps.append (pym)
else :
pym.source_mod = ".".join ((pym.pkg, pym.base_name))
pym.target_mod = ".".join ((pym.target_pkg, pym.base_name))
pyms.append (pym)
pym_dict [pym.source_mod] = pym
def show_attr_wrappers(apt, pred=pred):
def show(W, level=0):
qas = W.q_able_attrs_o
in0 = " " * (level + bool(level))
if qas:
in1 = in0 + " " * (level + 1 + (not level))
in2 = in1 + " "
print("%s%s" % (in0, W.type_name))
for name, aw in sorted(pyk.iteritems(qas)):
if not getattr(aw.kind, "show_in_ui", True): continue
amro = ", ".join(_kind_mro(aw.kind))
print \
( "%s%s : %s\n%s%s"
% (in1, aw.__class__.__name__, aw.kind, in2, amro)
)
if aw.q_able_attrs_o:
show(aw, level + 1)
elif W.e_type.relevant_root:
print("%s%s <-- %s" % (in0, W.type_name, W.parent.type_name))
sk = lambda x: (x.e_type.i_rank, )
for ETW in sorted(pyk.itervalues(apt._SAW.et_map), key=sk):
if not pred(ETW):
continue
show(ETW)
def _query_multi_root(self, Type, strict=False):
tables = self._tables
return self.Q_Result_Composite \
( [ self.Q_Result (pyk.itervalues (tables [t]))
for t in Type.relevant_roots
]
)
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 all_links(self, obj_id):
r_map = self._r_map
result = sorted \
( itertools.chain (* (rm [obj_id] for rm in pyk.itervalues (r_map)))
, key = self.scope.MOM.Id_Entity.sort_key_pm ()
)
return result
def show_root_table (apt, pred = pred) :
sk = lambda x : (x.e_type.i_rank, )
for ETW in sorted (pyk.itervalues (apt._SAW.et_map), key = sk):
if not pred (ETW) :
continue
T = ETW.e_type
print (("%-36s %s" % (T.type_name, ETW.root_table)).rstrip ())
def all_attribute_types (self) :
"""List of all attribute types used by the etypes of the application."""
result = set ()
for T in self._T_Extension :
if not T.is_partial :
for ak in pyk.itervalues (T.attributes) :
result.add (ak.attr)
return sorted (result, key = TFL.Sorted_By ("typ", "name"))
def _r_query_t (self, r_map, role, obj) :
i = role.role_index
return itertools.chain \
( r_map [role] [obj.pid]
, * ( r_map [c.Roles [i]] [obj.pid]
for c in pyk.itervalues (role.assoc.children)
)
)
def _r_query_t(self, r_map, role, obj):
i = role.role_index
return itertools.chain \
( r_map [role] [obj.pid]
, * ( r_map [c.Roles [i]] [obj.pid]
for c in pyk.itervalues (role.assoc.children)
)
)
def _query_single_root(self, Type, strict=False):
root = Type.relevant_root
tables = self._tables
result = pyk.itervalues(tables[root.type_name])
if root is not Type:
### filter siblings derived from same `relevant_root`
result = pyk.ifilter(lambda x: isinstance(x, Type), result)
return self.Q_Result(result)
def all_attribute_types(self):
"""List of all attribute types used by the etypes of the application."""
result = set()
for T in self._T_Extension:
if not T.is_partial:
for ak in pyk.itervalues(T.attributes):
result.add(ak.attr)
return sorted(result, key=TFL.Sorted_By("typ", "name"))
def _query_single_root (self, Type, strict = False) :
root = Type.relevant_root
tables = self._tables
result = pyk.itervalues (tables [root.type_name])
if root is not Type :
### filter siblings derived from same `relevant_root`
result = pyk.ifilter (lambda x : isinstance (x, Type), result)
return self.Q_Result (result)
def _sig_map_transitive(self, seen_etypes):
seen_etypes = ETC(dict(seen_etypes, **self.seen_refuse_e_types))
result = self.__super._sig_map_transitive(seen_etypes)
E_Types_AQ = self.E_Types_AQ
if E_Types_AQ:
for aq in pyk.itervalues(E_Types_AQ):
result.update(aq._sig_map_transitive(seen_etypes))
return result
def _sig_map_transitive (self, seen_etypes) :
seen_etypes = ETC (dict (seen_etypes, ** self.seen_refuse_e_types))
result = self.__super._sig_map_transitive (seen_etypes)
E_Types_AQ = self.E_Types_AQ
if E_Types_AQ :
for aq in pyk.itervalues (E_Types_AQ) :
result.update (aq._sig_map_transitive (seen_etypes))
return result
def as_json (self) :
d = dict (type = self.type, version = self.version)
iface = d ['interfaces'] = []
for i in pyk.itervalues (self.interfaces) :
iface.append (i.as_dict)
ips = d ['ips'] = []
for i in pyk.iterkeys (self.ips) :
ips.append (str (i))
return json.dumps (d)
def attrs (self) :
E_Type = self.E_Type
a_type = self.a_type
sk = TFL.Sorted_By ("rank", "name")
result = tuple \
( a for a in sorted (pyk.itervalues (E_Type.attributes), key = sk)
if isinstance (a.attr, a_type)
)
return result
def _m_create_role_children (cls) :
for role in uniq (cls._role_children_to_add) :
role = getattr (cls._Attributes, role)
children = sorted \
( pyk.itervalues (role.E_Type.children_np)
, key = TFL.Getter.i_rank
)
for c in children :
cls._m_create_role_child ((role.name, c))
def as_json(self):
d = dict(type=self.type, version=self.version)
iface = d['interfaces'] = []
for i in pyk.itervalues(self.interfaces):
iface.append(i.as_dict)
ips = d['ips'] = []
for i in pyk.iterkeys(self.ips):
ips.append(str(i))
return json.dumps(d)
def _m_create_role_children(cls):
for role in uniq(cls._role_children_to_add):
role = getattr(cls._Attributes, role)
children = sorted \
( pyk.itervalues (role.E_Type.children_np)
, key = TFL.Getter.i_rank
)
for c in children:
cls._m_create_role_child((role.name, c))
def attrs(self):
E_Type = self.E_Type
a_type = self.a_type
sk = TFL.Sorted_By("rank", "name")
result = tuple \
( a for a in sorted (pyk.itervalues (E_Type.attributes), key = sk)
if isinstance (a.attr, a_type)
)
return result
def render(self):
canvas = self.canvas
nodes = sorted(self.nodes, key=TFL.Getter.entity.type_name)
for n in nodes:
self.render_node(n, canvas)
link_sort_key = TFL.Sorted_By("relation.rid")
for n in nodes:
for l in sorted(pyk.itervalues(n.link_map), key=link_sort_key):
self.render_link(l, canvas)
def render (self) :
canvas = self.canvas
nodes = sorted (self.nodes, key = TFL.Getter.entity.type_name)
for n in nodes :
self.render_node (n, canvas)
link_sort_key = TFL.Sorted_By ("relation.rid")
for n in nodes :
for l in sorted (pyk.itervalues (n.link_map), key = link_sort_key) :
self.render_link (l, canvas)
def __init__ (self, site, request) :
self.site = site
self.request = request
if 'interfaces' in self.request or 'ips' in self.request :
st = Status (site = site)
conn = OLSR_Connections (site = site)
route = OLSR_Routes (site = site)
self.version = st.version
assert len (st.wlans) <= 1
interfaces = {}
ips = {}
count = 0
for gw, ifname in pyk.iteritems (route.iface_by_gw) :
ip, lq, nlq, etx = conn.neighbors [gw]
i4 = Inet4 (ip, None, None, iface = ifname)
ips [i4] = 1
is_wlan = True
if lq == nlq == etx == 1.0 :
is_wlan = False
if ifname in interfaces :
iface = interfaces [ifname]
if not iface.is_wlan and is_wlan :
iface.is_wlan = True
iface.wlan_info = st.wlans [0]
else :
iface = Interface (count, ifname, None)
iface.is_wlan = is_wlan
if is_wlan :
iface.wlan_info = st.wlans [0]
count += 1
interfaces [ifname] = iface
if i4 not in iface.inet4 :
iface.append_inet4 (i4)
wl_if = None
for iface in pyk.itervalues (interfaces) :
if iface.is_wlan :
if wl_if :
m = "Duplicate wlan: %s/%s" % (iface.name, wl_if.name)
raise ValueError (m)
wl_if = iface
# check own ip
n = 'unknown'
i4 = Inet4 (self.request ['ip'], None, None, iface = n)
if i4 not in ips :
assert n not in interfaces
iface = interfaces [n] = Interface (count, n, None)
iface.append_inet4 (i4)
iface.is_wlan = False
if not wl_if and st.wlans :
iface.is_wlan = True
iface.wlan_info = st.wlans [0]
ips [i4] = True
self.request ['ips'] = ips
self.request ['interfaces'] = interfaces
self.request ['version'] = st.version
def __init__ (self, site, request) :
self.site = site
self.request = request
if 'interfaces' in self.request or 'ips' in self.request :
st = Status (site = site)
conn = OLSR_Connections (site = site)
route = OLSR_Routes (site = site)
self.version = st.version
assert len (st.wlans) <= 1
interfaces = {}
ips = {}
count = 0
for gw, ifname in pyk.iteritems (route.iface_by_gw) :
ip, lq, nlq, etx = conn.neighbors [gw]
i4 = Inet4 (ip, None, None, iface = ifname)
ips [i4] = 1
is_wlan = True
if lq == nlq == etx == 1.0 :
is_wlan = False
if ifname in interfaces :
iface = interfaces [ifname]
if not iface.is_wlan and is_wlan :
iface.is_wlan = True
iface.wlan_info = st.wlans [0]
else :
iface = Interface (count, ifname, None)
iface.is_wlan = is_wlan
if is_wlan :
iface.wlan_info = st.wlans [0]
count += 1
interfaces [ifname] = iface
if i4 not in iface.inet4 :
iface.append_inet4 (i4)
wl_if = None
for iface in pyk.itervalues (interfaces) :
if iface.is_wlan :
if wl_if :
m = "Duplicate wlan: %s/%s" % (iface.name, wl_if.name)
raise ValueError (m)
wl_if = iface
# check own ip
n = 'unknown'
i4 = Inet4 (self.request ['ip'], None, None, iface = n)
if i4 not in ips :
assert n not in interfaces
iface = interfaces [n] = Interface (count, n, None)
iface.append_inet4 (i4)
iface.is_wlan = False
if not wl_if and st.wlans :
iface.is_wlan = True
iface.wlan_info = st.wlans [0]
ips [i4] = True
self.request ['ips'] = ips
self.request ['interfaces'] = interfaces
self.request ['version'] = st.version
def show_children (T, bi = " ", level = 0, seen = None) :
"""Display tree of children of essential type `T`."""
if seen is None :
seen = set ()
print ("%s%s" % (bi * level, T.type_name))
l1 = level + 1
for c in sorted (pyk.itervalues (T.children), key = TFL.Getter.i_rank) :
if c not in seen :
show_children (c, bi, l1, seen)
seen.add (c)
def watch_directories(pyinotify, timeout, overrides, *directories):
if pyinotify:
_watch_directories_pyinotify(pyinotify, overrides, *directories)
else:
import time
print("Polling fallback, interval %dms" % (timeout, ))
while True:
time.sleep(1000. / timeout)
for template in pyk.itervalues(CSS_Template.templates):
template.check_for_update()
def show_ancestors (apt, pred = pred) :
sk = lambda x : (x.e_type.i_rank, )
for ETW in sorted (pyk.itervalues (apt._SAW.et_map), key = sk) :
if not pred (ETW) :
continue
T = ETW.e_type
xs = ("%-36s" % (T.type_name), )
if ETW.ancestors :
xs += ("<" , " < ".join ("%-16s" % (a.type_name, ) for a in ETW.ancestors).rstrip ())
print (" ".join (xs).rstrip ())
def show_children(T, bi=" ", level=0, seen=None):
"""Display tree of children of essential type `T`."""
if seen is None:
seen = set()
print("%s%s" % (bi * level, T.type_name))
l1 = level + 1
for c in sorted(pyk.itervalues(T.children), key=TFL.Getter.i_rank):
if c not in seen:
show_children(c, bi, l1, seen)
seen.add(c)
def _response_body(self, resource, request, response):
req_data = request.req_data
result = dict()
tree = int(req_data.get("tree", "0"))
init = int(req_data.get("init", "0"))
volume, path_spec = resource.strip_volume(req_data["target"])
added = []
for file in pyk.itervalues(request.req_data.files):
added.append(volume.add(path_spec, file))
return dict(added=added)
def watch_directories (pyinotify, timeout, overrides, * directories) :
if pyinotify :
_watch_directories_pyinotify (pyinotify, overrides, * directories)
else :
import time
print ("Polling fallback, interval %dms" % (timeout, ))
while True :
time.sleep (1000. / timeout)
for template in pyk.itervalues (CSS_Template.templates) :
template.check_for_update ()
def _response_body(self, resource, request, response):
req_data = request.req_data
result = dict()
tree = int(req_data.get("tree", "0"))
init = int(req_data.get("init", "0"))
volume, path_spec = resource.strip_volume(req_data["target"])
added = []
for file in pyk.itervalues(request.req_data.files):
added.append(volume.add(path_spec, file))
return dict(added=added)
def show_ancestors(apt, pred=pred):
sk = lambda x: (x.e_type.i_rank, )
for ETW in sorted(pyk.itervalues(apt._SAW.et_map), key=sk):
if not pred(ETW):
continue
T = ETW.e_type
xs = ("%-36s" % (T.type_name), )
if ETW.ancestors:
xs += ("<", " < ".join("%-16s" % (a.type_name, )
for a in ETW.ancestors).rstrip())
print(" ".join(xs).rstrip())
def children_trans_iter(T, level=0, seen=None, sort_key=None):
if seen is None:
seen = set()
if sort_key is None:
sort_key = TFL.Getter.i_rank
yield T, level
for c in sorted(pyk.itervalues(T.children), key=sort_key):
if c not in seen:
seen.add(c)
for cc, l in children_trans_iter(c, level + 1, seen, sort_key):
yield cc, l
def children_trans_iter (T, level = 0, seen = None, sort_key = None) :
if seen is None :
seen = set ()
if sort_key is None :
sort_key = TFL.Getter.i_rank
yield T, level
for c in sorted (pyk.itervalues (T.children), key = sort_key) :
if c not in seen :
seen.add (c)
for cc, l in children_trans_iter (c, level + 1, seen, sort_key) :
yield cc, l
def has_child (self, child_name, transitive = True) :
"""Checks if this node or one of this childs has a node named
`child_name'.
"""
child_name = self._child_name (child_name)
for children in pyk.itervalues (self.children_groups) :
if child_name in children :
return children [child_name]
if transitive :
for c in self.children :
child = c.has_child (child_name, transitive = True)
if child is not None :
return child
def has_child(self, child_name, transitive=True):
"""Checks if this node or one of this childs has a node named
`child_name'.
"""
child_name = self._child_name(child_name)
for children in pyk.itervalues(self.children_groups):
if child_name in children:
return children[child_name]
if transitive:
for c in self.children:
child = c.has_child(child_name, transitive=True)
if child is not None:
return child
def _setup_attrs (self, e_type) :
attr_dict = self._attr_dict
for a in pyk.itervalues (attr_dict) :
for d in a.attr.auto_up_depends :
try :
x = attr_dict [d]
except KeyError :
pass
else :
x.dependent_attrs.add (a)
if isinstance (a.completer, MOM.Attr.Completer_Spec) :
a.attr.completer = a.completer (a, e_type)
if isinstance (a.polisher, MOM.Attr.Polisher._Polisher_) :
a.attr.polisher = a.polisher.Instance (a)
def show_qc_map (apt, pred = pred) :
def _show (QC, indent = 4) :
if QC.Map :
for k, v in sorted (pyk.iteritems (QC.Map)) :
print (("%-30s: %.80s" % (" " * indent + k, v)).rstrip ())
if isinstance (v, QC.__class__) :
_show (v, indent + 4)
sk = lambda x : (x.e_type.i_rank, )
for ETW in sorted (pyk.itervalues (apt._SAW.et_map), key = sk):
if not pred (ETW) :
continue
if ETW.sa_tables :
print (ETW)
_show (ETW.QC)
def __init__ (self, * args, ** kw) :
self.GTW = GTW = JNJ.GTW (self)
self.env = env = JNJ.Environment.HTML (* args, GTW = GTW, ** kw)
self.Template_Type = T = Template_E.New \
( "x"
, By_Path = {}
, Map = {}
, Media_Map = {}
, css_href_map = {}
, etag = None
)
self.Template_Map = T.Map
for t in sorted (pyk.itervalues (Template.Map), key = TFL.Getter.id) :
T.copy (env, t)
def _setup_attrs(self, e_type):
attr_dict = self._attr_dict
for a in pyk.itervalues(attr_dict):
for d in a.attr.auto_up_depends:
try:
x = attr_dict[d]
except KeyError:
pass
else:
x.dependent_attrs.add(a)
if isinstance(a.completer, MOM.Attr.Completer_Spec):
a.attr.completer = a.completer(a, e_type)
if isinstance(a.polisher, MOM.Attr.Polisher._Polisher_):
a.attr.polisher = a.polisher.Instance(a)
def show_selects(apt, name="select", pred=pred):
sk = lambda x: (x.e_type.i_rank, )
for ETW in sorted(pyk.itervalues(apt._SAW.et_map), key=sk):
if not pred(ETW):
continue
T = ETW.e_type
if ETW.has_relevant_tables:
second = "" if T.relevant_root is T \
else (T.relevant_root.type_name if T.relevant_root else "")
head = ("%s %s" % (T.type_name, second)).strip()
print \
( "%s%s" % (head, nl), " "
, fixed_booleans (formatted_select (ETW, name = name))
)
def __init__(self, *args, **kw):
self.GTW = GTW = JNJ.GTW(self)
self.env = env = JNJ.Environment.HTML(*args, GTW=GTW, **kw)
self.Template_Type = T = Template_E.New \
( "x"
, By_Path = {}
, Map = {}
, Media_Map = {}
, css_href_map = {}
, etag = None
)
self.Template_Map = T.Map
for t in sorted(pyk.itervalues(Template.Map), key=TFL.Getter.id):
T.copy(env, t)
def show_selects (apt, name = "select", pred = pred) :
sk = lambda x : (x.e_type.i_rank, )
for ETW in sorted (pyk.itervalues (apt._SAW.et_map), key = sk):
if not pred (ETW) :
continue
T = ETW.e_type
if ETW.has_relevant_tables :
second = "" if T.relevant_root is T \
else (T.relevant_root.type_name if T.relevant_root else "")
head = ("%s %s" % (T.type_name, second)).strip ()
print \
( "%s%s" % (head, nl), " "
, fixed_booleans (formatted_select (ETW, name = name))
)
def unit_changes(after, before, str_dates, unit, offset=0, limit=5):
"""Yield all elements of `str_dates` closest to `unit` changes."""
map = mm_list()
for d, sd in in_range(after, before, str_dates):
p1, p2 = d.periods[unit]
if offset:
p1 += offset
p2 += offset
p = p1 if (d - p1 < (p2 - p1) // 2) else (p2 + 1)
delta = (d - p).days
a_delta = abs(delta)
if a_delta <= limit:
map[p].append((a_delta, -sign(delta), sd))
result = list(min(v)[-1] for v in pyk.itervalues(map))
return sorted(result)
