def matching_keys (self, abbr) :
"""Returns a list of all keys matching `abbr` if any."""
if abbr in self :
return [abbr]
elif isinstance (abbr, str) :
return TFL.matches (TFL.sorted (pyk.iterkeys (self)), abbr)
return []
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 Extract (dirname, template_file, config, cmd) :
absname = os.path.abspath (dirname)
po_file = TFL.Babel.PO_File \
( project = cmd.project
, version = cmd.version
, bugs_address = cmd.bugs_address
, copyright_holder = cmd.copyright_holder
, charset = cmd.charset
, width = cmd.width
, no_location = cmd.no_location
, omit_header = cmd.omit_header
, sort = cmd.sort
)
keywords = Default_Keywords.copy ()
keywords.update (dict (k, None) for k in cmd.keywords)
for root, dirnames, filenames in os.walk (absname) :
dirnames.sort ()
for filename in sorted (filenames) :
filename = os.path.relpath \
(os.path.join (root, filename).replace (os.sep, '/'), dirname)
try :
for method_name, pattern in config.patterns.items () :
if pathmatch (pattern, filename) :
for pattern in config.get_list \
("ignore_patterns", method_name, set (), True) :
if pathmatch (pattern, filename) :
raise Skip
filepath = os.path.join (absname, filename)
rfp = TFL.relative_to_python_path (filepath)
print ("Method `%-10s`: `%s" % (method_name, filename))
trans = config.get ("loaded_translations", method_name)
for lineno, message, comments, found_in in \
_extract_from_file \
( method_name
, filepath
, config
, cmd
, keywords
) :
fn = rfp
if found_in :
fn = TFL.relative_to_python_path (found_in)
if message not in trans :
po_file.add \
( message, None, [(fn, lineno)]
, auto_comments = comments
)
break
except Skip :
print ("Ignore : `%s" % (filename, ))
print ("Create template file", template_file, file = sys.stderr)
po_file.save (template_file)
def selected_type (self) :
result = self._selected_type
if TFL.is_undefined (result) :
outer = self._outer
if outer is not None :
result = self._selected_type = outer.selected_type
return result
def _e_type_attrs_q_able (self, ET) :
attrs = ET.q_able_no_edit
_own = ET._Attributes._own_names
result = []
if attrs :
heading = "Queryable attributes"
leader = None
own_attrs = [a for a in attrs if a.name in _own]
if len (attrs) > len (own_attrs) :
def _gen_parents (ET) :
for p in ET.parents :
if p.q_able_no_edit :
### filter out intermediate ancestors without
### q_able_no_edit attributes of their own
### --> refer to their parents instead
own = p._Attributes._own_names
if [a for a in p.q_able_no_edit if a.name in own] :
yield p
else :
for mp in _gen_parents (p) :
yield mp
parents = list (TFL.uniq (_gen_parents (ET)))
if parents :
leader = "For inherited %s see also %s" % \
( heading.lower ()
, ", ".join
( self._heading_ref (p, heading, p.type_name)
for p in parents
)
)
result = self._e_type_attrs \
( ET, own_attrs if leader else attrs, heading, leader
, electric = True
)
return result
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 templates_e (self) :
def _gen () :
yield self
if self.extends :
for e in self.extends.templates_e :
yield e
return tuple (TFL.uniq (_gen ()))
def consume (self, e_iter, c_iter, chunk_size, db_meta_data) :
assert sos.path.exists (self.x_uri.name), self.x_uri.name
assert not self.info.commits
assert not self.info.pending
assert not self.info.stores
db_uri = self.db_uri
x_name = self.x_uri.name
with TFL.lock_file (x_name) :
info = self.info
stores = info.stores = []
commits = info.commits = []
for i, cargo in enumerate (sliced (e_iter, chunk_size)) :
s_name = TFL.Filename ("by_pid_%d" % i, self.x_uri)
with open (s_name.name, "wb") as file :
pickle.dump (cargo, file, pyk.pickle_protocol)
stores.append (s_name.base_ext)
for cargo in sliced (c_iter, chunk_size) :
max_cid = cargo [-1] [1] ["cid"]
c_name = TFL.Filename ("%d.commit" % max_cid, self.x_uri)
with open (c_name.name, "wb") as file :
pickle.dump (cargo, file, pyk.pickle_protocol)
commits.append ((max_cid, c_name.base_ext))
info.max_cid = db_meta_data.max_cid
info.max_pid = db_meta_data.max_pid
self._save_info (info)
def js (self) :
"""Combined Javascript code required by media fragments that can be
loaded from a single file or included inline in a html <script>
element.
"""
env = self.env
encoding = env.encoding
handler = env.static_handler
media = self._Media_R
if handler and media :
def _gen (handler, encoding, scripts, media) :
for s in sorted (scripts, key = TFL.Getter.rank) :
p = handler.get_path (s.src)
if p :
with open (p, "rb") as file :
yield file.read ().decode (encoding)
else :
try :
src, p, _ = env.loader.get_source (env, s.src)
except Exception :
pass
else :
if p :
yield src
for s in sorted (media.script_files, key = TFL.Getter.rank) :
yield pyk.decoded (s.body, encoding)
result = "\n\n".join \
(TFL.uniq (_gen (handler, encoding, self.scripts_c, media)))
return result
def _new_delivery_box(self, d, prefix):
config = TFL.load_config_file(
sos.path.join(d, ".config.py"), dict(Maildir_Type=PMA.Maildir, Maildir_kw={}, PMA=PMA)
)
result = config["Maildir_Type"](d, prefix=prefix, **config["Maildir_kw"])
result.config = config
return result
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 import_module (path) :
fn = Filename (path)
mn = fn.base
md = fn.directory or "./"
with TFL.Context.list_push (sys.path, md, 0) :
result = TFL.import_module (mn)
result.__App_Tests_Dir__ = md
return result
def field_values (self, json) :
result = dict (json ["field_values"])
for e in self.elems :
if e.id not in result :
v = e.init
if e.readonly and v is not None and not TFL.is_undefined (v) :
result [e.id] = v
return result
def create (self) :
assert not sos.path.exists (self.db_uri.name), self.db_uri.name
assert not sos.path.exists (self.x_uri.name), self.x_uri.name
x_name = self.x_uri.name
with TFL.lock_file (x_name) :
sos.mkdir (x_name)
sos.system ("chmod go= %s" % x_name)
self._create_info ()
def js_on_ready (self) :
"""Combined Javascript code required by media fragments to be
executed when document is ready.
"""
media = self._Media
if media :
return sorted (TFL.uniq (media.js_on_ready), key = TFL.Getter.rank)
return ()
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 _get_name (self, pip) :
try :
sys_path = list (sys.path)
sys.path [0:0] = self.import_path
m = TFL.import_module ("%s.Version" % pip.pkg)
return m.Version.productid
finally :
sys.path = sys_path
def scripts (self) :
"""Scripts required by media fragments that need to be put into
separate <script src="..."> elements.
"""
media = self._Media
if media :
return tuple (TFL.uniq (media.scripts))
return ()
def _explanation (self, ** kw) :
if not self.explanation :
yield ""
return
yield "\\item \\textbf{Description:} \\\\"
format_prec = max (int (kw ["format_prec"]), 4)
wrapper = textwrap.TextWrapper (width = format_prec)
for l in wrapper.wrap (TFL.tex_quoted (self.explanation)) :
yield l
def entities_transitive (self, ems) :
def _gen (self, ems) :
for e in self.entities (ems) :
yield e
for iea in e.id_entity_attr :
v = iea.get_value (e)
if v is not None :
yield v
return TFL.uniq (_gen (self, ems))
def load_changes (self) :
assert sos.path.exists (self.x_uri.name), self.x_uri.name
info = self.info
x_uri = self.x_uri
with TFL.lock_file (x_uri.name) :
for (cid, name) in info.commits :
file_name = TFL.Filename (name, x_uri).name
for c in self._loaded_changes (file_name) :
pass ### `_loaded_changes` adds the changes to `self.cm`
self.cm.to_load = []
def produce_entities (self) :
assert sos.path.exists (self.x_uri.name), self.x_uri.name
assert not self.info.pending
info = self.info
x_uri = self.x_uri
with TFL.lock_file (x_uri.name) :
for s in info.stores :
with open (TFL.Filename (s, x_uri).name, "rb") as file :
for epc in pickle.load (file) :
yield epc
def _save_context (self, x_name, scope, info) :
Version = self.Version
with TFL.lock_file (x_name) :
self._check_sync_ro (info)
yield info
ems = scope.ems
info.max_cid = ems.max_cid
info.max_pid = ems.max_pid
info.max_surrs = ems.max_surrs
self._save_info (info)
def load_info (self) :
assert sos.path.exists (self.db_uri.name), self.db_uri.name
x_name = self.x_uri.name
with TFL.lock_file (x_name) :
if not sos.path.exists (x_name) :
sos.mkdir (x_name)
sos.system ("chmod go= %s" % x_name)
with contextlib.closing \
(self.ZF.ZipFile (self.db_uri.name, "r")) as zf :
zf.extractall (x_name)
self.info = self._load_info ()
def load_objects (self) :
assert sos.path.exists (self.x_uri.name), self.x_uri.name
info = self.info
x_uri = self.x_uri
with TFL.lock_file (x_uri.name) :
self.scope.db_errors = []
for s in info.stores :
self._load_store (TFL.Filename (s, x_uri).name)
for (cid, name) in info.pending :
self._load_pending (TFL.Filename (name, x_uri).name)
self.cm.to_load = [name for (cid, name) in info.commits]
def _temp_body (self) :
if self._tfn is None or not sos.path.isfile (self._tfn) :
dir = TFL.Filename \
( (self.filename or "").encode
(PMA.file_system_encoding, "ignore")
).directory
with TFL.open_tempfile (dir = dir, auto_remove = False) as \
(f, result) :
f.write (self.body)
self._tfn = result
return self._tfn
def _insert (self, other) :
key = self.key (other)
try :
larger = TFL.first (it for it in self if it.key > key)
except IndexError :
prev = self.tail
else :
prev = larger.prev
self.__super.insert (prev, other)
if self.mark.key > key :
self.rotate_prev (1)
def extends (self) :
env = self.env
pat = self._extend_pat
source = self.source
if source and pat.search (source) :
try :
path = TFL.r_eval (pat.name.strip (), ** self.env_globals)
except Exception :
pass
else :
return self.__class__ (env, path)
def _setup_lic_comps (self) :
pns_name = self.productnick
pkg_name = "_%s" % pns_name
pkg = sys.modules.get (pkg_name)
if pkg :
pns = getattr (pkg, pns_name)
try :
lp_module = TFL.import_module ("%s.Lic_Comps" % pkg_name)
except ImportError :
pass
else :
self.lic_comps.extend (getattr (lp_module, "list"))
def _gen () :
for match in pat.search_iter (source) :
try:
name = match.group ("name").strip ()
pathes = TFL.r_eval (name, ** self.env_globals)
except Exception :
pass
else :
if isinstance (pathes, pyk.string_types) :
pathes = [pathes]
for p in pathes :
yield self.__class__ (env, p)
def __init__ (self, file_name, ** kw) :
self.__super.__init__ \
( file_name = file_name
, name = kw.pop ("name", None) or TFL.Filename (file_name).base
, ** kw
)
def max_surrs(self):
return TFL.defaultdict(int) ### XXX
def _as_template_elem(self, seen_etypes):
result = dict(self._as_template_elem_inv, ui_name=self._ui_name_T)
return TFL.Record(**result)
if self.can_eval:
print(eval(self.code, glob_dct, loc_dct))
else:
exec(self.code, glob_dct, loc_dct)
# end def __call__
# end class Pycode_Compiler
def complete_command(line, glob_dct, loc_dct=None):
prefix, space, line = line.rpartition(" ")
d = dict(glob_dct)
d.update(loc_dct or {})
c = rlcompleter.Completer(d)
try:
c.complete(line, 0)
except Exception:
return None, None
match = "".join((prefix, space, common_head(c.matches)))
cands = ", ".join(sorted(s.split(".")[-1] for s in set(c.matches)))
return match, ("%s\n\n" % cands if cands else "")
# end def complete_command
if __name__ != "__main__":
TFL._Export("*")
### __END__ Py_Interpreter
lng2 = math.radians (p2.lon)
sin_lat1, cos_lat1 = math.sin (lat1), math.cos (lat1)
sin_lat2, cos_lat2 = math.sin (lat2), math.cos (lat2)
delta_lng = lng2 - lng1
cos_d_lng, sin_d_lng = math.cos (delta_lng), math.sin (delta_lng)
# We're correcting from floating point rounding errors on very-near
# and exact points here
central_angle = math.acos \
(min (1.0, sin_lat1 * sin_lat2 + cos_lat1 * cos_lat2 * cos_d_lng))
d = math.atan2 \
( math.sqrt
( (cos_lat2 * sin_d_lng) ** 2
+ (cos_lat1 * sin_lat2 - sin_lat1 * cos_lat2 * cos_d_lng) ** 2
)
, sin_lat1 * sin_lat2 + cos_lat1 * cos_lat2 * cos_d_lng
)
return self.radius * d
# end def distance
# end class Sphere
Earth = Sphere (6372795) ### Average radius of the earth in meters
if __name__ != "__main__" :
TFL._Export ("Sphere", "Earth")
### __END__ TFL.Sphere
def __init__(self, *iv_list):
self.iv_map = TFL.sorted(iv_list)
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__ (cls, name, bases, dict) :
cls.__m_super.__init__ (name, bases, dict)
if not hasattr (cls, "_") :
cls._ = TFL.Record ()
def change_info(self):
return TFL.Record(etag=self.top.App_Type.db_version_hash)
from Media_Parameters import Media_Parameters
Media_Parameters = Media_Parameters()
src_dir = sos.path.dirname(__file__)
web_root_dir = "//ffm.funkfeuer.at"
web_src_root = sos.path.abspath(src_dir)
base_template_dir = sos.path.dirname(_JNJ.__file__)
template_dirs = [src_dir, base_template_dir]
web_links = \
[ TFL.Record
( href = "http://guifi.net/en/"
, title = "Spanish open wireless network"
, short_title = "Guifi.net"
)
, TFL.Record
( href = "http://wlan-si.net/"
, title = "Slovenian open wireless network"
, short_title = "wlan-si"
)
]
def root_kw_args(cmd, **kw):
return dict \
( console_context = dict
( FFM = FFM
, GTW = GTW
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)
def _fixed_order_by_tuple (xs) :
if len (xs) == 1 :
return fixed_order_by (xs [0])
else :
return TFL.Sorted_By (* tuple (fixed_order_by (x) for x in xs))
res.append(self._one_tb_line(tb_line))
res.append("\n%s: %s\n" % (exc_name, exc_value))
return "\n".join(res)
# end def as_string
def _cut(self, s):
"""returns `s`, reduced by the first match of the cutter"""
if self.cutter:
s = self.cutter.sub("", s)
return s
# end def _cut
def _one_tb_line(self, line):
"""generate one traceback line (apply format string)"""
fn, number, function, text = line
fn = self._cut(fn)
return self.format_str % locals()
# end def _one_tb_line
# end class _Traceback_Printer_
Traceback_Printer = _Traceback_Printer_()
if __name__ != "__main__":
TFL._Export("_Traceback_Printer_", "Traceback_Printer")
### __END__ TFL.Traceback_Printer
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 file_name (self, cao, ext) :
fn = TFL.Filename ("." + ext, cao.name, default_dir = cao.dir)
return fn.name
# end def ungettext
def use(*lang):
Config.choice = (l, v) = choose(*lang)
Config.current = Config.Languages[l]
# end def use
_ = mark
def _T(s):
if s:
return ugettext(s)
return s
# end def _T
_Tn = ungettext
Name = _Name_()
if __name__ != "__main__":
TFL._Export_Module()
### __END__ TFL.I18N
def _sort_properties (self, e_type) :
for pk in pyk.itervalues (self._prop_kind) :
pk.sort (key = TFL.Sorted_By ("rank", "name"))
def __init__(self, source):
self.source = source = iter(source)
self._sentinel = self._succ = TFL.Undef("sentinel")
import _GTW._RST.Resource
import _GTW._RST.HTTP_Method
import _GTW._RST._MOM.Mixin
from _MOM.import_MOM import MOM, Q
from _TFL._Meta.Once_Property import Once_Property
from _TFL.Decorator import getattr_safe
from _TFL.pyk import pyk
import _TFL._Meta.Object
import _TFL.Undef
from posixpath import join as pp_join
_undef_arg = TFL.Undef ("arg")
@TFL.Add_Method (MOM.Attr._A_Id_Entity_)
def as_rest_cargo_raw \
(self, obj, method, resource, request, response, seen, getter, a_name) :
result = self.kind.get_value (obj)
if result is not None :
res_vet = resource.resource_from_e_type (result.type_name)
url = res_vet.href_obj (result)
if ( request.has_option ("closure")
and result.pid not in seen
and res_vet.allow_method (method, request.user)
) :
result = method._response_obj \
( resource, request, response, result, result.edit_attr, seen
, getter, a_name
class _SRM_Year_ (GTW.RST.TOP.MOM.Renderer_Mixin, _Ancestor.Year) :
_real_name = "Year"
dir_template_name = "regatta_calendar"
Entity = Regatta_Event
head_line_format = _ ("Regatta Events %(year)s")
list_display = \
( "ui_date_short"
, "regatta_kinds"
, "regatta_classes"
, "event_link"
)
regattas = Alias_Property ("object_entries")
skip_etag = True
sort_key = TFL.Sorted_By ("date.start", "perma_name")
_field_class_map = dict \
( ui_date_short = "align-right"
)
_field_type_map = dict \
( event_link = Q.Field_Event_Link
, regatta_classes = Q.Field_Regatta_Classes
, regatta_kinds = Q.Field_Regatta_Kinds
)
class Field_Event_Link (GTW.RST.TOP.MOM.Field.HTML_Link) :
attr_name = "desc"
@property ### depends on currently selected language (I18N/L10N)
@getattr_safe
def ui_name (self) :
return _T ("Regatta")
# end def ui_name
def _as_html_href (self, o, renderer) :
resource = self.resource
href = resource.href_display (o)
return href
# end def _as_html_href
def _as_html_value (self, o, renderer) :
return o.desc
# end def _as_html_value
# end class Field_Event_Link
class Field_Regatta_Classes (GTW.RST.TOP.MOM.Field.HTML_Link_Set) :
attr_name = "regattas"
@property ### depends on currently selected language (I18N/L10N)
@getattr_safe
def ui_name (self) :
return _T ("Class")
# end def ui_name
def _as_html_href (self, o, renderer) :
resource = self.resource
regatta = self._value_getter (o)
href = resource.href_regatta (regatta) \
if not regatta.is_cancelled else ""
return href
# end def _as_html_href
def _as_html_value (self, o, renderer) :
regatta = self._value_getter (o)
return regatta.name.replace (" ", " ")
# end def _as_html_value
# end class Field_Regatta_Classes
class Field_Regatta_Kinds (GTW.RST.TOP.MOM.Field.AQ) :
attr_name = "regattas"
@property ### depends on currently selected language (I18N/L10N)
@getattr_safe
def ui_name (self) :
return _T ("Kind")
# end def ui_name
def as_html (self, o, renderer) :
regattas = sorted (self._value_getter (o), key = Q.name)
canc = _T ("Is cancelled")
return "<br>".join \
((r.kind if not r.is_cancelled else canc) for r in regattas)
# end def as_html
# end class Field_Regatta_Kinds
class _SRM_Year_Renderer_ (GTW.RST.TOP.MOM.Renderer.E_Type) :
_real_name = "Renderer"
template_module = "ETR_table_regatta"
Renderer = _SRM_Year_Renderer_ # end class
@property ### depends on currently selected language (I18N/L10N)
def head_line (self) :
return self.head_line_format % TFL.Caller.Object_Scope (self)
class UI_Spec(object):
"""UI specification for E_Types defined by GTW.OMP.PAP"""
property_include_rev_refs = \
("persons", "companies", "associations")
subject_include_rev_refs = \
("addresses", "emails", "phones")
Address = dict \
( list_display = ("zip", "city", "street", "desc")
, MF3_Form_Spec = dict
( include_rev_refs = ("gps", ) + property_include_rev_refs
)
, sort_key = TFL.Sorted_By ( "zip", "street")
)
Adhoc_Group = dict \
(
)
Association = dict \
( list_display = ("name", "short_name", "lifetime")
, MF3_Form_Spec = dict
( include_rev_refs = subject_include_rev_refs
)
)
Company = dict \
( list_display = ("name", "short_name", "lifetime")
, MF3_Form_Spec = dict
( include_rev_refs = subject_include_rev_refs
)
)
Company_1P = dict \
( list_display =
( "ui_display", "short_name", "lifetime")
, MF3_Form_Spec = dict
( include_rev_refs = subject_include_rev_refs
)
)
Email = dict \
( list_display = ("ui_display", "desc")
, MF3_Form_Spec = dict
( include_rev_refs = property_include_rev_refs
)
)
IM_Handle = dict \
( list_display = ("ui_display", "desc")
, MF3_Form_Spec = dict
( include_rev_refs = property_include_rev_refs
)
)
Nickname = dict \
( list_display = ("ui_display", "desc")
, MF3_Form_Spec = dict
( include_rev_refs = property_include_rev_refs
)
)
Person = dict \
( list_display =
( "last_name", "first_name", "middle_name", "title"
, "lifetime", "sex"
)
, MF3_Form_Spec = dict
( include_rev_refs =
(subject_include_rev_refs + ("im_handles", "accounts"))
)
)
Phone = dict \
( list_display = ("ui_display", "desc")
, MF3_Form_Spec = dict
( include_rev_refs = property_include_rev_refs
)
)
Url = dict \
( list_display = ("ui_display", "desc")
, MF3_Form_Spec = dict
( include_rev_refs = property_include_rev_refs
)
)
Address_Position = dict \
(
)
Company_has_Address = dict \
(
)
Company_has_Email = dict \
(
)
Company_has_Phone = dict \
(
)
Company_has_Url = dict \
(
)
Company_has_VAT_IDN = dict \
( list_display = ("left.ui_display", "vin")
)
Id_Entity_permits_Group = dict \
(
)
Person_has_Account = dict \
(
)
Person_has_Address = dict \
(
)
Person_has_Email = dict \
(
)
Person_has_IM_Handle = dict \
(
)
Person_has_Nickname = dict \
(
)
Person_has_Phone = dict \
(
)
Person_has_Url = dict \
(
)
Person_has_VAT_IDN = dict \
( list_display = ("left.ui_display", "vin")
)
Person_in_Group = dict \
( sort_key = TFL.Sorted_By ("pid") ### XXX remove this
)
Subject_has_Property = dict \
(
)
class Field__Crew_Club (GTW.RST.TOP.MOM.Field.Id_Entity_Set) :
attr_name = "_crew"
attr_names = ("club", )
sort_key = TFL.Sorted_By ("key", "pid")
orig_f.is_classmethod = cors is classmethod
wrapper = decorator(orig_f)
decorated = cors(wrapper)
_update_wrapper(wrapper, orig_f)
else:
decorated = decorator(f)
_update_wrapper(decorated, f)
return decorated
_update_wrapper(wrapper, decorator)
return wrapper
# end def Decorator
_AR_undefined = TFL.Undef("return-value")
def Annotated(RETURN=_AR_undefined, **kw):
"""Add dictionary `func_annotations` containing elements of `kw` and
value of `RETURN` bound to key `return` as proposed by
http://www.python.org/dev/peps/pep-3107/.
Each key of `kw` must be the name of an argument of the function to be
annotated::
>>> from _TFL.portable_repr import portable_repr
>>> @TFL.Annotated (bar = "Arg 1", baz = 42)
... def foo (bar, baz) : pass
...
>>> portable_repr (foo.func_annotations)
class Field__Crew_MNA_Number (GTW.RST.TOP.MOM.Field.Id_Entity_Set) :
attr_name = "_crew"
attr_names = ("mna_number", )
sort_key = TFL.Sorted_By ("key", "pid")
def load_entries (file_name) :
with open (file_name) as f :
return TFL.r_eval (f.read (), ** eval_scope ())
class Field__Crew_Person (GTW.RST.TOP.MOM.Field.Id_Entity_Set) :
attr_name = "_crew"
attr_names = ("_crew_person_set", )
sort_key = TFL.Sorted_By ("key", "pid")
>>> lower = Method.lower
>>> print (lower ("abCDe"))
abcde
>>> with expect_except (AttributeError) :
... lower (1)
AttributeError: 'int' object has no attribute 'lower'
"""
def __getattr__(self, name):
def _(this, *args, **kw):
return getattr(this, name)(*args, **kw)
_.__name__ = name
return _
# end def __getattr__
# end class _Method_
Getter = _Getter_()
Method = _Method_()
__doc__ = """
.. moduleauthor:: Christian Tanzer <*****@*****.**>
"""
if __name__ != "__main__":
TFL._Export("Getter", "Method")
### __END__ TFL.Accessor
def E_Type (self) :
result = self.scope.SRM.Boat_in_Regatta.E_Type
### XXX change MOM rev-ref autogeneration to do this automatically
result.attr_prop ("race_results").attr.sort_key = TFL.Sorted_By ("race")
return result
>>> print (ui_display ("a"))
a
>>> print (ui_display (u"a"))
a
For types with no specific implementation, ``ui_display`` returns the
``portable_repr``:
>>> import datetime
>>> d = datetime.date (2014, 2, 6)
>>> print (ui_display (d))
datetime.date(2014, 2, 6)
Adding an implementation for a specific type is easy enough, though::
>>> @ui_display.add_type (datetime.date)
... def _ui_display_date (obj) :
... return str (obj)
>>> print (ui_display (d))
2014-02-06
"""
if __name__ != "__main__":
TFL._Export("ui_display")
### __END__ TFL.ui_display
class Aggregator (GTW.RST.MOM.Mixin, _Ancestor) :
"""Page aggregating the most recent instances of one or more E_Types."""
css_class = "news-clip"
page_template_name = "e_type_aggregator"
query_limit = 25
sort_key = TFL.Sorted_By ("-date.start", "-prio")
static_p = True
_exclude_robots = False
_old_objects = None
class Aggregator_GET (_Ancestor.GET) :
_real_name = "GET"
def _render_context (self, resource, request, response, ** kw) :
return self.__super._render_context \
( resource, request, response
, calendar = resource.calendar
, clips = resource.clips
, random_picture = None
if resource.clips else resource.random_picture
, ** kw
)
# end def _render_context
GET = Aggregator_GET # end class
class Instance (TFL.Meta.Object) :
def __init__ (self, obj, parent) :
self.obj = obj
self.parent = parent
self.top = parent.top
self.FO = GTW.FO (obj, parent.top.encoding)
# end def __init__
def __getattr__ (self, name) :
if name.startswith ("__") and name.endswith ("__") :
### Placate inspect.unwrap of Python 3.5,
### which accesses `__wrapped__` and eventually throws
### `ValueError`
return getattr (self.__super, name)
if name == "link_to" :
top = self.top
result = getattr (self.obj, name, None)
if not result :
left = getattr (self.obj, "left", None)
if left is not None :
result = top.obj_href (left)
if result :
page = top.resource_from_href (result)
result = page.permalink
else :
result = getattr (self.FO, name)
return result
# end def __getattr__
# end class Instance
def __init__ (self, ** kw) :
kw ["_ETMS"] = kw.pop ("ETMS")
self.__super.__init__ (** kw)
# end def __init__
@Once_Property
@getattr_safe
def calendar (self) :
return getattr (self.top.SC, "Cal", None)
# end def calendar
@Once_Property
@getattr_safe
def change_query_filters (self) :
return (Q.type_name.IN (sorted (self.change_query_types)), )
# end def change_query_filters
@Once_Property
@getattr_safe
def change_query_types (self) :
result = set ()
for ETM in self.ETMS :
E_Type = ETM.E_Type
result.update (self._change_query_types (E_Type))
return result
# end def change_query_types
@property
@getattr_safe
def clips (self) :
objects = self.objects
if self._old_objects is not objects :
self._clips = \
[self.Instance (obj = o, parent = self) for o in objects]
if objects :
self._old_objects = objects
return self._clips
# end def clips
@Once_Property
@getattr_safe
def ETMS (self) :
result = []
for etm in self._kw ["_ETMS"] :
if isinstance (etm, pyk.string_types) :
etm = self.top.scope [etm]
result.append (etm)
return result
# end def ETMS
@Once_Property
@getattr_safe
def query_filters_s (self) :
return self.__super.query_filters_s + (Q.date.alive, )
# end def query_filters_s
@Once_Property
@getattr_safe
def Random_Picture (self) :
return getattr (self.top.SC, "Random_Picture", None)
# end def Random_Picture
@property
@getattr_safe
def random_picture (self) :
RP = self.Random_Picture
if RP is not None :
return RP.picture.left
# end def random_picture
def query (self) :
qs = []
ql = self.query_limit
sk = self.sort_key
for ETM in self.ETMS :
q = ETM.query (* self.query_filters, sort_key = sk)
if ql :
q = q.limit (ql)
qs.append (q)
result = TFL.Q_Result_Composite (qs, order_by = sk)
if ql :
result.limit (ql)
return result
