def _polished (self, attr, name, value, value_dict, essence, picky) : result = {} p = CAL.Period.from_string \ (value, add_year = self.add_year, future_p = self.future_p) if p is not None : finish = self._attr_value \ (attr, self.finish_attr, None, value_dict, essence) result [name] = pyk.text_type (p.start) if p.days > 1 and not finish : result [self.finish_attr] = pyk.text_type (p.finis) return result
def _polished(self, attr, name, value, value_dict, essence, picky): result = {} p = CAL.Period.from_string \ (value, add_year = self.add_year, future_p = self.future_p) if p is not None: finish = self._attr_value \ (attr, self.finish_attr, None, value_dict, essence) result[name] = pyk.text_type(p.start) if p.days > 1 and not finish: result[self.finish_attr] = pyk.text_type(p.finis) return result
def as_string(soc, value): result = "" if value is not None: result = pyk.text_type(value) if result.endswith(":00"): result = result[:-3] return result
def set_s_attr_value (self, obj, dict, name, val_dict) : result = None attr = obj.attr_prop (name) if name in dict : result = dict [name] if attr is not None and result is not None : try : result = attr.cooked (result) except Exception as exc : print \ ( "Error in `cooked` of `%s` for value `%s` [%s]" % (attr, result, obj) ) raise elif attr is not None or (name in self.attr_none) : result = self.kind.get_attr_value (obj, name) else : raise AttributeError \ ( "Invalid predicate `%s` references undefined attribute `%s`" "\n %s:" "\n %s" % (self.name, name, obj, self.assertion) ) val_dict [name] = result self.val_disp [name] = pyk.text_type (obj.FO (name, result)) return result
def as_string (soc, value) : result = "" if value is not None : result = pyk.text_type (value) if result.endswith (":00") : result = result [:-3] return result
def as_string(soc, value): if value is not None: if isinstance(value, datetime.date): return A_Date.as_string(value) else: return pyk.text_type(value) return ""
def b64digest (self, altchars = "_-", strip = False) : if isinstance (altchars, pyk.text_type) : altchars = pyk.encoded (altchars) result = base64.b64encode (self.digest (), altchars) if strip : result = result.rstrip (b"=") return pyk.text_type (result, "ASCII")
def set_s_attr_value(self, obj, dict, name, val_dict): result = None attr = obj.attr_prop(name) if name in dict: result = dict[name] if attr is not None and result is not None: try: result = attr.cooked(result) except Exception as exc: print \ ( "Error in `cooked` of `%s` for value `%s` [%s]" % (attr, result, obj) ) raise elif attr is not None or (name in self.attr_none): result = self.kind.get_attr_value(obj, name) else: raise AttributeError \ ( "Invalid predicate `%s` references undefined attribute `%s`" "\n %s:" "\n %s" % (self.name, name, obj, self.assertion) ) val_dict[name] = result self.val_disp[name] = pyk.text_type(obj.FO(name, result)) 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 as_string (soc, value) : if value is not None : if isinstance (value, datetime.date) : return A_Date.as_string (value) else : return pyk.text_type (value) return ""
def b64digest(self, altchars="_-", strip=False): if isinstance(altchars, pyk.text_type): altchars = pyk.encoded(altchars) result = base64.b64encode(self.digest(), altchars) if strip: result = result.rstrip(b"=") return pyk.text_type(result, "ASCII")
def __str__ (self) : if bool (self) : return pyk.text_type (self.value) else : return "<%s at %s: %s, %s, %s>" % \ ( self.__class__, id (self) , id (self.next), id (self.prev), self.value )
def type_name (cls, v) : t = type (v) n = t.__name__ r = cls.type_name_map.get (n, n) if r == "byte-string" and v.isalnum : r = "text-string" v = pyk.text_type (v, "latin1") return r, v
def __str__(self): if bool(self): return pyk.text_type(self.value) else: return "<%s at %s: %s, %s, %s>" % \ ( self.__class__, id (self) , id (self.next), id (self.prev), self.value )
def from_attr_tuple (soc, lower = None, upper = None, btype = None) : if btype is None : btype = soc.default_btype result = soc.P_Type (lower, upper, btype) try : return soc.set_defaults (lower, upper, btype, result) except ValueError as exc : raise MOM.Error.Attribute_Syntax \ (None, soc, result, pyk.text_type (exc))
def _polished (self, attr, name, value, value_dict, essence, picky) : result = {} unit_pat = self.unit_pat if unit_pat.match (value) : start = self._attr_value \ (attr, self.start_attr, None, value_dict, essence) if start : d = CAL.Date.from_string (start) P = getattr (CAL.Period, unit_pat.unit.capitalize ()) p = P.from_date (d) result [self.start_attr] = pyk.text_type (p.start) result [name] = pyk.text_type (p.finis) else : p = CAL.Period.from_string \ (value, add_year = self.add_year, future_p = self.future_p) if p is not None : result [name] = pyk.text_type (p.finis) return result
def _polished(self, attr, name, value, value_dict, essence, picky): result = {} unit_pat = self.unit_pat if unit_pat.match(value): start = self._attr_value \ (attr, self.start_attr, None, value_dict, essence) if start: d = CAL.Date.from_string(start) P = getattr(CAL.Period, unit_pat.unit.capitalize()) p = P.from_date(d) result[self.start_attr] = pyk.text_type(p.start) result[name] = pyk.text_type(p.finis) else: p = CAL.Period.from_string \ (value, add_year = self.add_year, future_p = self.future_p) if p is not None: result[name] = pyk.text_type(p.finis) return result
def fixed_booleans (qf) : if not isinstance (qf, pyk.string_types) : qf = pyk.text_type (qf) result = \ ( qf.replace ("WHERE 0 = 1", "WHERE false") .replace ("WHERE 1 = 1", "WHERE true") .replace ("= false", "= 0") .replace ("= true", "= 1") ) return result
def _attr_iter (self) : attr_values = \ ( [(a, getattr (self, a)) for a in self.attr_names] + sorted (pyk.iteritems (self.x_attrs)) ) if attr_values : translate = lambda a : self.attr_name_translate.get (a, a) for a, v in attr_values : if v is not None : k = translate (a) v = pyk.text_type (v).replace ("'", """) yield u'''%s="%s"''' % (k, v)
def _getter (self, obj) : if self._prefix : obj = getattr (TFL.Getter, self._prefix) (obj) key = self._postfix if hasattr (obj, "raw_attr") and key in obj.attributes : return obj.raw_attr (key) else : getter = getattr (TFL.Getter, key) result = getter (obj) if isinstance (obj, MOM.Entity) : result = pyk.text_type (result) return result
def _getter(self, obj): if self._prefix: obj = getattr(TFL.Getter, self._prefix)(obj) key = self._postfix if hasattr(obj, "raw_attr") and key in obj.attributes: return obj.raw_attr(key) else: getter = getattr(TFL.Getter, key) result = getter(obj) if isinstance(obj, MOM.Entity): result = pyk.text_type(result) return result
def diff(self, new_content): if self != new_content: old = pyk.text_type(self) new = pyk.decoded(new_content, *self.encodings) diffs = self._diffs \ (old, new, fromfile = self.file_name, tofile = "Result of test") diff_no = len(diffs) d_name = Filename(".diff", self.file_name).name with open(d_name, "wb") as f: f.write(pyk.encoded("\n".join(diffs))) return "%d difference%s (see %s)" % \ (diff_no, "" if diff_no == 1 else "s", d_name)
def diff (self, new_content) : if self != new_content : old = pyk.text_type (self) new = pyk.decoded (new_content, * self.encodings) diffs = self._diffs \ (old, new, fromfile = self.file_name, tofile = "Result of test") diff_no = len (diffs) d_name = Filename (".diff", self.file_name).name with open (d_name, "wb") as f : f.write (pyk.encoded ("\n".join (diffs))) return "%d difference%s (see %s)" % \ (diff_no, "" if diff_no == 1 else "s", d_name)
def __init__ (self, ** kw) : obj = kw ["obj"] if "name" not in kw : name = pyk.text_type (getattr (obj, "perma_name", None)) if name is None : name = getattr (obj, "name", obj.pid) kw ["name"] = TFL.Ascii.sanitized_filename (name) self.__super.__init__ (** kw) ### Get `short_title` and `title` from `obj` if "short_title" not in kw : self.short_title = self.__getattr__ ("short_title") if "title" not in kw : self.title = self.__getattr__ ("title")
def _gen (excs) : for exc in excs : try : cargo = exc.as_json_cargo except AttributeError : cargo = dict \ ( description = pyk.text_type (exc) , head = exc.__class__.__name__ ) if isinstance (cargo, (list, tuple)) : for c in cargo : yield c else : yield cargo
def __call__(self, resource, request, response): if not hasattr(request, "Error"): if self.message: ### Backwards compatibility with old-style Jinja templates try: request.Error = pyk.text_type(self.message) except Exception: request.Error = str(self.message) response.status_code = self.status_code self._add_response_body(resource, request, response) self._add_response_headers(resource, request, response) if self.cache_control: self._add_cache_control(resource, request, response) return response
def __call__(self, value): name = self.name.replace("_", "-") v = pyk.text_type(value).replace("_", "-") prefs = self.vp_map.get(value, ()) if prefs: values = [v] for p in prefs: values.append("-".join((p, v))) else: values = v result = {name: values} for p in self.prefixes: result["-".join((p, name))] = values return result
def __call__ (self, value) : name = self.name.replace ("_", "-") v = pyk.text_type (value).replace ("_", "-") prefs = self.vp_map.get (value, ()) if prefs : values = [v] for p in prefs : values.append ("-".join ((p, v))) else : values = v result = {name : values} for p in self.prefixes : result ["-".join ((p, name))] = values return result
def disgorge(self, head="", joiner="\n", tail=""): items = tuple(self._notifications) result = [] if items: result.append(head) result.append \ ( joiner.join ( pyk.text_type (s) for s in sorted (items, key = TFL.Getter.time) ) ) result.append(tail) self._notifications = [] return "".join(result)
def disgorge (self, head = "", joiner = "\n", tail = "") : items = tuple (self._notifications) result = [] if items : result.append (head) result.append \ ( joiner.join ( pyk.text_type (s) for s in sorted (items, key = TFL.Getter.time) ) ) result.append (tail) self._notifications = [] return "".join (result)
def __call__ (self, resource, request, response) : if not hasattr (request, "Error") : if self.message : ### Backwards compatibility with old-style Jinja templates try : request.Error = pyk.text_type (self.message) except Exception : request.Error = str (self.message) response.status_code = self.status_code self._add_response_body (resource, request, response) self._add_response_headers (resource, request, response) if self.cache_control : self._add_cache_control (resource, request, response) return response
def convert(cls, text): cleaner = TFL.HTML.Cleaner(text, "html.parser") comments = cleaner.remove_comments() if comments: raise ValueError \ ( _T ("HTML must not contain comments:\n%s") % ("\n ".join (comments), ) ) forbidden = cleaner.remove_tags(*cls.forbidden) if forbidden: raise ValueError \ ( _T ("HTML must not contain any of the tags:\n%s") % (" ".join (forbidden), ) ) return pyk.text_type(cleaner)
def convert (cls, text) : cleaner = TFL.HTML.Cleaner (text, "html.parser") comments = cleaner.remove_comments () if comments : raise ValueError \ ( _T ("HTML must not contain comments:\n%s") % ("\n ".join (comments), ) ) forbidden = cleaner.remove_tags (* cls.forbidden) if forbidden : raise ValueError \ ( _T ("HTML must not contain any of the tags:\n%s") % (" ".join (forbidden), ) ) return pyk.text_type (cleaner)
def _add_response_body(self, resource, request, response): with resource.LET(ignore_picky_accept=True): render = self.render_man(self, resource, request) if render.name == "HTML": root = resource.top Templateer = root.Templateer t_name = self.template_name if Templateer and t_name in Templateer.Template_Map: template = Templateer.get_template(t_name) context = Templateer.Context \ ( exception = self , fatal_exception = self if self.status_code >= 500 else None , page = resource , nav_page = resource , NAV = root , request = request , response = response , template = template ) with Templateer.GTW.LET(blackboard=dict()): body = template.render(context) else: desc = _T(self.description) body = \ ( ("%s: %s" % (desc, pyk.text_type (self.message))) if self.message else desc ) else: body = dict \ ( self._kw , description = self.description ) if self.message: body["message"] = pyk.text_type(self.message) render(request, response, body)
def _add_response_body (self, resource, request, response) : with resource.LET (ignore_picky_accept = True) : render = self.render_man (self, resource, request) if render.name == "HTML" : root = resource.top Templateer = root.Templateer t_name = self.template_name if Templateer and t_name in Templateer.Template_Map : template = Templateer.get_template (t_name) context = Templateer.Context \ ( exception = self , fatal_exception = self if self.status_code >= 500 else None , page = resource , nav_page = resource , NAV = root , request = request , response = response , template = template ) with Templateer.GTW.LET (blackboard = dict ()) : body = template.render (context) else : desc = _T (self.description) body = \ ( ("%s: %s" % (desc, pyk.text_type (self.message))) if self.message else desc ) else : body = dict \ ( self._kw , description = self.description ) if self.message : body ["message"] = pyk.text_type (self.message) render (request, response, body)
def _check_pid_gone(self, pid, E_Type, scope): lc = scope.query_changes(pid=pid).order_by(self._sort_key_cid_reverse).first() if lc is not None: user = _T("anonymous") if lc.user: try: user = scope.pid_query(lc.user) except Exception: user = lc.user else: if user.person: user = user.person user = pyk.text_type(user.FO) error = _T("%s `%s` doesn't exist anymore!") % (_T(E_Type.ui_name), pid) info = _T("It was deleted by user `%s` on %s") % (user, lc.time.strftime("%Y-%m-%d %H:%M")) raise self.Status.Gone(error, info=info)
def __init__(self, *args, **kw): roots = kw.pop("roots") self.__super.__init__(*args, **kw) self.roots = {} self.mount_errors = [] default = None for i, r in enumerate(roots): try: r.initialize(self.scope, "r%02d" % (i,)) except Exception as e: self.mount_errors.append(pyk.text_type(e)) else: if r.default: default = r self.roots[r.hash] = r if not default: default = roots[0] self.default_root = default
def _handle_script(self, cao): scope = self._handle_load(cao) if cao.load else None globs = self._handle_script_globals(cao=cao, scope=scope) for script_path in cao.argv: local = {} try: with open(script_path, "rb") as f: exec(f.read(), globs, local) except Exception as exc: head = _T("Script %s triggered exception" % (script_path, )) tail = " \n".join(pyk.text_type(exc).split("\n")) pyk.fprint(head) pyk.fprint(" ", tail) raise SystemExit(1) if cao.commit: scope.commit() scope.ems.compact() scope.destroy()
def set_c_attr_value (self, obj, dict, c_attr, val_dict) : attr, tail = c_attr.split (".", 1) result = self.set_s_attr_value (obj, dict, attr, val_dict) for a in tail.split (".") : if result is None : return None if hasattr (result, a) or (attr in self.attr_none) : result = getattr (result, a, None) else : raise AttributeError \ ( "Invalid predicate: references undefined attribute " "`%s'\n %s: %s" % (attr, obj, self.assertion) ) if result is not None : if tail : self.val_disp [c_attr] = pyk.text_type (obj.FO (c_attr, result)) return result
def _handle_script (self, cao) : scope = self._handle_load (cao) if cao.load else None globs = self._handle_script_globals (cao = cao, scope = scope) for script_path in cao.argv : local = {} try : with open (script_path, "rb") as f : exec (f.read (), globs, local) except Exception as exc : head = _T ("Script %s triggered exception" % (script_path, )) tail = " \n".join (pyk.text_type (exc).split ("\n")) pyk.fprint (head) pyk.fprint (" ", tail) raise SystemExit (1) if cao.commit : scope.commit () scope.ems.compact () scope.destroy ()
def as_string (soc, value) : if value is not None : if isinstance (value, datetime.timedelta) : r = [] if value.days : r.append ("%sd" % value.days) if value.seconds or value.microseconds : if r : r.append (" ") r.append ("%02d:" % (value.seconds // 3600)) r.append ("%02d:" % ((value.seconds % 3600) // 60)) r.append ("%02d" % (value.seconds % 60)) if value.microseconds : r.append (".%06d" % value.microseconds) return "".join (r) else : return pyk.text_type (value) return ""
def __init__(self, *args, **kw): roots = kw.pop("roots") self.__super.__init__(*args, **kw) self.roots = {} self.mount_errors = [] default = None for i, r in enumerate(roots): try: r.initialize(self.scope, "r%02d" % (i, )) except Exception as e: self.mount_errors.append(pyk.text_type(e)) else: if r.default: default = r self.roots[r.hash] = r if not default: default = roots[0] self.default_root = default
def set_c_attr_value(self, obj, dict, c_attr, val_dict): attr, tail = c_attr.split(".", 1) result = self.set_s_attr_value(obj, dict, attr, val_dict) for a in tail.split("."): if result is None: return None if hasattr(result, a) or (attr in self.attr_none): result = getattr(result, a, None) else: raise AttributeError \ ( "Invalid predicate: references undefined attribute " "`%s'\n %s: %s" % (attr, obj, self.assertion) ) if result is not None: if tail: self.val_disp[c_attr] = pyk.text_type(obj.FO(c_attr, result)) return result
def __init__ (self, ** kw) : ### Set `self.top` early because it's needed before initialized properly self.top = self.parent.top self.pop_to_self (kw, "ETM", prefix = "_") E_Type = self.E_Type name = kw.pop ("name", E_Type.ui_name) a = "a" ### Fool Babel extract short_title = kw.pop \ ( "short_title" , _T (name.capitalize () if name [0] >= a else name) ) title = kw.pop ("title", None) \ or self._default_title (E_Type, name, short_title) self.__super.__init__ \ ( name = TFL.Ascii.sanitized_filename (pyk.text_type (name)) , short_title = short_title , title = title , ** kw )
def _check_pid_gone (self, pid, E_Type, scope) : lc = scope.query_changes \ (pid = pid).order_by (self._sort_key_cid_reverse).first () if lc is not None : user = _T ("anonymous") if lc.user : try : user = scope.pid_query (lc.user) except Exception : user = lc.user else : if user.person : user = user.person user = pyk.text_type (user.FO) error = \ ( _T ("%s `%s` doesn't exist anymore!") % (_T (E_Type.ui_name), pid) ) info = \ ( _T ("It was deleted by user `%s` on %s") % (user, lc.time.strftime ("%Y-%m-%d %H:%M")) ) raise self.Status.Gone (error, info = info)
def _pbl_options (self, * opts) : return tuple (pyk.text_type (o) for o in opts)
def cooked (soc, value) : if value is not None : return soc._clean (pyk.text_type (value)) return value
def _str_int(x): return pyk.text_type(int(x))
def h_title(self): return pyk.text_type(self.owner or self.name)
def time(self): return pyk.text_type(self._instance.FO.time)
def date(self): return pyk.text_type(self._instance.FO.date)
def __str__ (self) : return pyk.text_type (self.soup)
def _m_add (cls, name, Table) : name = pyk.text_type (name) assert name not in Table, "Name clash: `%s` <-> `%s`" % \ (name, Table [name].__class__) Table [name] = cls
def _m_add(cls, name, Table): name = pyk.text_type(name) assert name not in Table, "Name clash: `%s` <-> `%s`" % \ (name, Table [name].__class__) Table[name] = cls