def __repr__(cls):
return "%s (%s, %s, %s)" % \
( cls.__class__.__name__
, portable_repr (cls.attributes)
, portable_repr (cls.assertion)
, portable_repr (cls.parameters)
)
def __repr__(cls):
return "%s (%s, %s, %s)" % (
cls.__class__.__name__,
portable_repr(cls.attributes),
portable_repr(cls.assertion),
portable_repr(cls.parameters),
)
def __repr__ (self) :
op = self.op.__name__
lhs, rhs = self.lhs, self.rhs
if self.reverse :
lhs, rhs = rhs, lhs
return "%s %s %s" % \
(portable_repr (lhs), self.op_map.get (op, op), portable_repr (rhs))
def __repr__ (self) :
op = self.op.__name__
lhs, rhs = self.lhs, self.rhs
if self.reverse :
lhs, rhs = rhs, lhs
return "%s %s %s" % \
(portable_repr (lhs), self.op_map.get (op, op), portable_repr (rhs))
def __repr__(self):
return pyk.reprify \
( "%s (%s, %s)"
% ( self.__class__.__name__
, portable_repr (self.message)
, portable_repr (self.time)
)
)
def __repr__(cls):
return '%s (%s, %s, %s, %s)' % \
( cls.__class__.__name__
, portable_repr (cls.bvar)
, portable_repr (cls.assertion)
, portable_repr (cls.seq)
, portable_repr (cls.description)
)
def _repr (self) :
result = \
["%s %s %s" % (self.kind, self.type_repr, portable_repr (self.epk))]
if self.old_attr :
result.append ("old-values = %s" % portable_repr (self.old_attr))
if self.new_attr :
result.append ("new-values = %s" % portable_repr (self.new_attr))
return ", ".join (result)
def __repr__(cls):
return "%s (%s, %s, %s, %s)" % (
cls.__class__.__name__,
portable_repr(cls.bvar),
portable_repr(cls.assertion),
portable_repr(cls.seq),
portable_repr(cls.description),
)
def __repr__ (self) :
return pyk.reprify \
( "%s (%s, %s)"
% ( self.__class__.__name__
, portable_repr (self.message)
, portable_repr (self.time)
)
)
def _repr(self):
result = \
["%s %s %s" % (self.kind, self.type_repr, portable_repr (self.epk))]
if self.old_attr:
result.append("old-values = %s" % portable_repr(self.old_attr))
if self.new_attr:
result.append("new-values = %s" % portable_repr(self.new_attr))
return ", ".join(result)
def _convert_element (self, key, value) :
if isinstance (value, (list, tuple)) :
if len (value) != 1 :
logging.warning \
( "Got multiple values for '%s', using '%s', ignoring: %s"
, key, portable_repr (value [0]), portable_repr (value [1:])
)
value = value [0]
return self._normalized (value)
def reprified(self):
v = self._formatted_values()
if v.startswith("#"):
v = portable_repr(v)
else:
v = v.replace("%", "")
alpha = self.alpha
args = (v, ) if alpha is None else (v, portable_repr(alpha))
return "%s (%s)" % (self.__class__.__name__, ", ".join(args))
def _convert_element(self, key, value):
if isinstance(value, (list, tuple)):
if len(value) != 1:
logging.warning \
( "Got multiple values for '%s', using '%s', ignoring: %s"
, key, portable_repr (value [0]), portable_repr (value [1:])
)
value = value[0]
return self._normalized(value)
def __repr__(self):
result = "%s: %s, %s" % \
( self.__class__.__name__
, portable_repr (self.data)
, portable_repr (self.secrets)
)
if self._invalid:
result = "%s\n %s" % (result, self._invalid)
return pyk.reprify(result)
def _auto_doc(cls, attrs, kw):
"""Auto-compute docstring for predicate over `attrs`."""
return \
( _ ("The attribute values for %s must be %s for each object")
% ( portable_repr (attrs) if len (attrs) > 1
else portable_repr (attrs [0])
, cls.Kind_Cls.typ
)
)
def _auto_doc (cls, attrs, kw) :
"""Auto-compute docstring for predicate over `attrs`."""
return \
( _ ("The attribute values for %s must be %s for each object")
% ( portable_repr (attrs) if len (attrs) > 1
else portable_repr (attrs [0])
, cls.Kind_Cls.typ
)
)
def __repr__ (self) :
result = "%s: %s, %s" % \
( self.__class__.__name__
, portable_repr (self.data)
, portable_repr (self.secrets)
)
if self._invalid :
result = "%s\n %s" % (result, self._invalid)
return pyk.reprify (result)
def reprified (self) :
v = self._formatted_values ()
if v.startswith ("#") :
v = portable_repr (v)
else :
v = v.replace ("%", "")
alpha = self.alpha
args = (v, ) if alpha is None else (v, portable_repr (alpha))
return "%s (%s)" % (self.__class__.__name__, ", ".join (args))
def string_repr (self, obj, limit = 70) :
buf = ['<span class="string">']
escaped = escape (pyk.decoded (obj))
a = portable_repr (escaped [:limit])
b = portable_repr (escaped [limit:])
if b != "''" :
buf.extend ((a [:-1], '<span class="extended">', b [1:], '</span>'))
else:
buf.append (a)
buf.append ('</span>')
return _add_subclass_info (''.join (buf), obj, pyk.string_types)
def from_json_cargo(cls, cargo, parent=None):
CN, attrs, children = cargo
try:
Class = cls[CN]
except KeyError:
raise TypeError \
( "Unknown Change class %s "
"for restoring change from json-cargo %s"
% (portable_repr (CN), portable_repr (cargo))
)
return cls._from_cargo \
(Class, attrs, children, cls.from_json_cargo, parent)
def formatted(self):
result = [portable_repr(self)]
sq = self.sa_query
cq = sq.compile()
params = dict(cq.params or {}, **self.bvar_man.bindings)
if params:
result.append("Parameters:")
result.extend \
( (" %-20s : %s" % (k, portable_repr (v)))
for k, v in sorted (pyk.iteritems (params))
)
return "\n".join(result)
def formatted (self) :
result = [portable_repr (self)]
sq = self.sa_query
cq = sq.compile ()
params = dict (cq.params or {}, ** self.bvar_man.bindings)
if params :
result.append ("Parameters:")
result.extend \
( (" %-20s : %s" % (k, portable_repr (v)))
for k, v in sorted (pyk.iteritems (params))
)
return "\n".join (result)
def from_json_cargo (cls, cargo, parent = None) :
CN, attrs, children = cargo
try :
Class = cls [CN]
except KeyError :
raise TypeError \
( "Unknown Change class %s "
"for restoring change from json-cargo %s"
% (portable_repr (CN), portable_repr (cargo))
)
return cls._from_cargo \
(Class, attrs, children, cls.from_json_cargo, parent)
def test_formatted_repr (obj, level = 0, compact = False, indent = " ") :
"""Return a formatted canonical string representation of `obj`.
"""
return "\n".join \
( portable_repr (line)
for line in formatted_repr.iter (obj, level, compact, seen = set ())
)
def as_text (self) :
attr = self.attribute
result = \
( _T ( "`%s` for : `%s`"
"\n expected type : %s"
"\n got value : %s"
)
% ( self.exc_str or _T ("Syntax error")
, portable_repr (attr)
, portable_repr (attr.typ)
, portable_repr (self.value)
)
)
if attr.syntax :
result = "\n".join ((result, _T (attr.syntax)))
return result
def _items_iter (obj, level, compact, seen) :
for k, v in sorted (pyk.iteritems (obj), key = SK) :
rk = portable_repr (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 formatted_column (c) :
tail = []
c_MOM_Kind = getattr (c, "MOM_Kind", None)
if c_MOM_Kind :
tail.append \
( "%s %s %s"
% ( c_MOM_Kind.__class__.__name__
, c_MOM_Kind.attr.typ
, getattr (c_MOM_Kind, "name", c_MOM_Kind)
)
)
else :
tail.append ("-" * 10)
if c.primary_key :
tail.append ("primary")
if c.foreign_keys :
tail.extend \
(formatted_foreign_key (fk) for fk in sorted (c.foreign_keys))
if c_MOM_Kind and isinstance (c_MOM_Kind.attr, MOM.Attr._A_Id_Entity_) :
tail.append (portable_repr (c.type))
try :
typ = str (c.type).capitalize ()
except Exception :
typ = c.type.__class__.__name__
return ("Column %-25s : %-20s %s" % (c.name, typ, " ".join (tail))).strip ()
def str_arg (self, args) :
for a in args :
try :
s = pyk.decoded (a)
except Exception as exc :
s = "%s --> %s" % (portable_repr (a), exc)
yield s
def str_arg (self, args) :
for a in args :
try :
s = pyk.decoded (a)
except Exception as exc :
s = "%s --> %s" % (portable_repr (a), exc)
yield s
def _items_iter (obj, level, compact, seen) :
for k, v in sorted (pyk.iteritems (obj), key = SK) :
rk = portable_repr (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_text (self) :
attr = self.attribute
result = \
( _T ( "`%s` for : `%s`"
"\n expected type : %s"
"\n got value : %s"
)
% ( self.exc_str or _T ("Syntax error")
, portable_repr (attr)
, portable_repr (attr.typ)
, portable_repr (self.value)
)
)
if attr.syntax :
result = "\n".join ((result, _T (attr.syntax)))
return result
def test_formatted_repr (obj, level = 0, compact = False, indent = " ") :
"""Return a formatted canonical string representation of `obj`.
"""
return "\n".join \
( portable_repr (line)
for line in formatted_repr.iter (obj, level, compact, seen = set ())
)
def formatted_column(c):
tail = []
c_MOM_Kind = getattr(c, "MOM_Kind", None)
if c_MOM_Kind:
tail.append \
( "%s %s %s"
% ( c_MOM_Kind.__class__.__name__
, c_MOM_Kind.attr.typ
, getattr (c_MOM_Kind, "name", c_MOM_Kind)
)
)
else:
tail.append("-" * 10)
if c.primary_key:
tail.append("primary")
if c.foreign_keys:
tail.extend \
(formatted_foreign_key (fk) for fk in sorted (c.foreign_keys))
if c_MOM_Kind and isinstance(c_MOM_Kind.attr, MOM.Attr._A_Id_Entity_):
tail.append(portable_repr(c.type))
try:
typ = str(c.type).capitalize()
except Exception:
typ = c.type.__class__.__name__
return ("Column %-25s : %-20s %s" % (c.name, typ, " ".join(tail))).strip()
def __repr__ (self) :
args = [("min", self.min), ("size", self.size)]
if self.offset :
args.append (("offset", self.offset))
return "%s (%s)" % \
( self.__class__.__name__
, ", ".join ("%s = %s" % (k, portable_repr (v)) for k, v in args)
)
def description (self) :
epk_values = zip \
(self.e_type.epk_sig, (portable_repr (x) for x in self.epk))
epk_bindings = self._formatted_bindings (epk_values)
kw_bindings = self._formatted_bindings (pyk.iteritems (self.kw))
return \
( _T ("Instead it got: (%s)")
% ", ".join (itertools.chain (epk_bindings, kw_bindings))
)
def __init__ (self, parent, ax, allow_duplicates = False) :
self.__super.__init__ (parent, [ax], allow_duplicates)
cols = self.cols
if len (cols) != 1 :
raise TypeError \
( "attr %s must result in a single column; got %s"
% (portable_repr (ax), cols)
)
self.col = cols [0]
def description (self) :
epk_values = zip \
(self.e_type.epk_sig, (portable_repr (x) for x in self.epk))
epk_bindings = self._formatted_bindings (epk_values)
kw_bindings = self._formatted_bindings (pyk.iteritems (self.kw))
return \
( _T ("Instead it got: (%s)")
% ", ".join (itertools.chain (epk_bindings, kw_bindings))
)
def __init__ (self, parent, ax, allow_duplicates = False) :
self.__super.__init__ (parent, [ax], allow_duplicates)
cols = self.cols
if len (cols) != 1 :
raise TypeError \
( "attr %s must result in a single column; got %s"
% (portable_repr (ax), cols)
)
self.col = cols [0]
def __init__ (self, entity, name, val, kind = "unknown", exc = None) :
if entity :
msg = \
( _T ("Can't set %s attribute %s.%s to %s")
% (_T (kind), entity.type_base_name, name, portable_repr (val))
)
else :
msg = \
( _T ("Can't set %s attribute %s to %s")
% (_T (kind), name, portable_repr (val))
)
if exc :
msg = "%s.\n %s" % (msg, exc)
self.args = (msg, )
self.entity = entity
self.kind = kind
self.attribute = name
self.attributes = (name, )
self.value = val
def formatted (qr) :
"""Return `qr` formatted as SQL."""
result, params = formatted_parts (qr)
if params :
fps = list \
( (" %-20s : %s" % (k, portable_repr (v)))
for k, v in sorted (pyk.iteritems (params))
)
result = "\n".join ([result, "Parameters:"] + fps)
return result
def _formatted_bindings (self, bindings = None) :
if bindings is None :
bindings = self.bindings
for k, v in bindings :
if isinstance (v, (list, tuple)) :
v = ", ".join \
("%s" % (portable_repr (pyk.decoded (x)), ) for x in v)
elif v is None or v == "''":
v = _T ("None")
yield "%s = %s" % (k, v)
def __init__ (self, entity, name, val, kind = "unknown", exc = None) :
if entity :
msg = \
( _T ("Can't set %s attribute %s.%s to %s")
% (_T (kind), entity.type_base_name, name, portable_repr (val))
)
else :
msg = \
( _T ("Can't set %s attribute %s to %s")
% (_T (kind), name, portable_repr (val))
)
if exc :
msg = "%s.\n %s" % (msg, exc)
self.args = (msg, )
self.entity = entity
self.kind = kind
self.attribute = name
self.attributes = (name, )
self.value = val
def formatted (qr) :
"""Return `qr` formatted as SQL."""
result, params = formatted_parts (qr)
if params :
fps = list \
( (" %-20s : %s" % (k, portable_repr (v)))
for k, v in sorted (pyk.iteritems (params))
)
result = "\n".join ([result, "Parameters:"] + fps)
return result
def _formatted_bindings (self, bindings = None) :
if bindings is None :
bindings = self.bindings
for k, v in bindings :
if isinstance (v, (list, tuple)) :
v = ", ".join \
("%s" % (portable_repr (pyk.decoded (x)), ) for x in v)
elif v is None or v == "''":
v = _T ("None")
yield "%s = %s" % (k, v)
def reprified (self) :
name = self.Pam.get (self.value.hex)
if name is not None :
alpha = self.alpha
args = (name, ) if alpha is None else (name, alpha)
return "%s (%s)" % \
( self.__class__.__name__
, ", ".join (portable_repr (a) for a in args)
)
else :
return self.__super.reprified ()
def reprified(self):
name = self.Pam.get(self.value.hex)
if name is not None:
alpha = self.alpha
args = (name, ) if alpha is None else (name, alpha)
return "%s (%s)" % \
( self.__class__.__name__
, ", ".join (portable_repr (a) for a in args)
)
else:
return self.__super.reprified()
def formatted_xqpi (qr) :
"""Return `qr` formatted as SQL with query parameters expanded inline."""
result, params = formatted_parts (qr)
if params :
r_dict = \
{ ":" + k : ("<$QP: %s>" % portable_repr (v))
for k, v in pyk.iteritems (params)
}
p_expander = Dict_Replacer (r_dict)
result = p_expander (result)
return result
def formatted_xqpi (qr) :
"""Return `qr` formatted as SQL with query parameters expanded inline."""
result, params = formatted_parts (qr)
if params :
r_dict = \
{ ":" + k : ("<$QP: %s>" % portable_repr (v))
for k, v in pyk.iteritems (params)
}
p_expander = Dict_Replacer (r_dict)
result = p_expander (result)
return result
def _resolve_request_attrs \
(self, resource, request, response, E_Type, attrs) :
allowed = set (a.name for a in E_Type.edit_attr)
invalids = tuple (k for k in attrs if k not in allowed)
if invalids :
raise ValueError \
( "Request contains invalid attribute names "
+ portable_repr (invalids)
)
self._resolve_nested_request_attrs \
(resource, request, response, E_Type, attrs)
def _handle_version_hash (self, cao) :
both = cao.database and cao.code
verbose = cao.verbose or both
apt, url = self.app_type_and_url (cao.db_url, cao.db_name)
dbv = apt.db_version_hash
fmt = "%(dbv)s"
if verbose :
dbv = portable_repr (dbv)
fmt = "%(kind)s = %(dbv)s"
if cao.code or not cao.database :
kind = "code_version_hash" if both else "dbv_hash"
print (fmt % dict (kind = kind, dbv = dbv))
if cao.database :
try :
db_man = self.DB_Man.connect (apt, url)
except MOM.Error.Incompatible_DB_Version as exc :
db_meta_data = exc.db_meta_data
else :
db_meta_data = db_man.db_meta_data
dbv = portable_repr (db_meta_data.dbv_hash)
print (fmt % dict (kind = "database_version_hash", dbv = dbv))
def _handle_version_hash (self, cao) :
both = cao.database and cao.code
verbose = cao.verbose or both
apt, url = self.app_type_and_url (cao.db_url, cao.db_name)
dbv = apt.db_version_hash
fmt = "%(dbv)s"
if verbose :
dbv = portable_repr (dbv)
fmt = "%(kind)s = %(dbv)s"
if cao.code or not cao.database :
kind = "code_version_hash" if both else "dbv_hash"
print (fmt % dict (kind = kind, dbv = dbv))
if cao.database :
try :
db_man = self.DB_Man.connect (apt, url)
except MOM.Error.Incompatible_DB_Version as exc :
db_meta_data = exc.db_meta_data
else :
db_meta_data = db_man.db_meta_data
dbv = portable_repr (db_meta_data.dbv_hash)
print (fmt % dict (kind = "database_version_hash", dbv = dbv))
def show_ref_map (T, name) :
map = getattr (T, name, None)
if map :
print (T.type_name)
print \
( " "
, "\n ".join
( sorted
( portable_repr ((c.type_name, sorted (eias)))
for c, eias in pyk.iteritems (map)
)
)
)
def show_ref_map(T, name):
map = getattr(T, name, None)
if map:
print(T.type_name)
print \
( " "
, "\n ".join
( sorted
( portable_repr ((c.type_name, sorted (eias)))
for c, eias in pyk.iteritems (map)
)
)
)
def _satisfied(self, obj, glob_dict, val_dict):
###+ the `gd` hackery is necessary for the `eval` of `self.attr_code`
gd = glob_dict.copy()
gd.update(val_dict)
###-
try:
seq = self._q_sequence(obj, gd, val_dict)
res = self._quantified(seq, obj, gd, val_dict)
except Exception as exc:
self.val_disp["*** Exception ***"] = portable_repr(exc)
self.error = self.Error_Type(obj, self)
else:
if self._is_correct(r for r in res if r):
self.error = None
else:
violators, violator_values = self._attr_val \
(obj, res, seq, gd, val_dict)
vs = violators
if "," in self.bvar:
vs = flattened(violators)
self._add_entities_to_extra_links(obj, vs)
self.error = self.Error_Type \
(obj, self, violators, violator_values)
return not self.error
def _satisfied (self, obj, glob_dict, val_dict) :
###+ the `gd` hackery is necessary for the `eval` of `self.attr_code`
gd = glob_dict.copy ()
gd.update (val_dict)
###-
try :
seq = self._q_sequence (obj, gd, val_dict)
res = self._quantified (seq, obj, gd, val_dict)
except Exception as exc :
self.val_disp ["*** Exception ***"] = portable_repr (exc)
self.error = self.Error_Type (obj, self)
else :
if self._is_correct (r for r in res if r) :
self.error = None
else :
violators, violator_values = self._attr_val \
(obj, res, seq, gd, val_dict)
vs = violators
if "," in self.bvar :
vs = flattened (violators)
self._add_entities_to_extra_links (obj, vs)
self.error = self.Error_Type \
(obj, self, violators, violator_values)
return not self.error
def __repr__(self):
return portable_repr(self)
def prepr (* args) :
print (* (portable_repr (a) for a in args))
def _show (it) :
from _TFL.portable_repr import portable_repr
print (portable_repr (list (it)))
def send (self, from_addr, to_addrs, msg, mail_opts = None, rcpt_opts = None) :
pyk.fprint \
( "Email via", self.mail_host, "from", from_addr, "to"
, portable_repr (to_addrs), "\n"
)
pyk.fprint (pyk.decoded (msg, self.charset))
