def satisfied(self, obj, attr_dict={}):
"""Checks if `obj' satisfies the predicate.
`attr_dict' can provide values for `self.attributes'.
If there is a `self.guard' the predicate is checked only if
`self.guard' evaluates to true.
"""
glob_dict = obj.globals()
if not self._guard_open(obj, attr_dict, glob_dict):
return True
val_disp = self.val_disp = {}
val_dict = self.val_dict = self._val_dict(obj, attr_dict)
if not val_dict:
return True
for p in self.parameters:
exc, val = self._eval_expr \
(p, obj, glob_dict, val_dict, "parameter")
if val is None or exc is not None:
return True
val_disp[p] = val if val is None else ui_display(val)
for b, expr in pyk.iteritems(self.bindings):
if callable(expr):
val = expr
disp = "%s" % (ui_display(val), )
else:
exc, val = self._eval_expr \
(expr, obj, glob_dict, val_dict, "binding")
if exc is not None:
return True
disp = "%s << %s" % (ui_display(val), expr)
val_dict[b] = val
val_disp[b] = disp
return self._satisfied(obj, glob_dict, val_dict)
def _add_header_maybe (self, email, name, value) :
if email.get (name, None) is None :
### just to be safe (del of non-existing key is a no-op)
del email [name]
if callable (value) :
value = value ()
email [name] = value
def satisfied (self, obj, attr_dict = {}) :
"""Checks if `obj' satisfies the predicate.
`attr_dict' can provide values for `self.attributes'.
If there is a `self.guard' the predicate is checked only if
`self.guard' evaluates to true.
"""
glob_dict = obj.globals ()
if not self._guard_open (obj, attr_dict, glob_dict) :
return True
val_disp = self.val_disp = {}
val_dict = self.val_dict = self._val_dict (obj, attr_dict)
if not val_dict :
return True
for p in self.parameters :
exc, val = self._eval_expr \
(p, obj, glob_dict, val_dict, "parameter")
if val is None or exc is not None :
return True
val_disp [p] = val if val is None else ui_display (val)
for b, expr in pyk.iteritems (self.bindings) :
if callable (expr) :
val = expr
disp = "%s" % (ui_display (val), )
else :
exc, val = self._eval_expr \
(expr, obj, glob_dict, val_dict, "binding")
if exc is not None :
return True
disp = "%s << %s" % (ui_display (val), expr)
val_dict [b] = val
val_disp [b] = disp
return self._satisfied (obj, glob_dict, val_dict)
def _json (self) :
result = self._result.json
if callable (result) :
try :
result = result ()
except Exception as exc :
result = {}
return result
def __call__ (self, obj, name) :
mapped = self._map.get (name, name)
if mapped is not None :
if callable (mapped) :
return mapped (obj)
else :
return getattr (obj, mapped)
raise AttributeError (name)
def _setup_prop(self, e_type, name, kind, prop):
self.__super._setup_prop(e_type, name, kind, prop)
if not (prop.electric or prop.is_primary):
self._user_attr.append(prop)
if prop.save_to_db and not prop.prop.is_partial:
self._db_attr.append(prop)
if callable(prop.sync):
self._syncable.append(prop)
def _json(self):
result = self._result.json
if callable(result):
try:
result = result()
except Exception as exc:
result = {}
return result
def __call__(self, obj, name):
mapped = self._map.get(name, name)
if mapped is not None:
if callable(mapped):
return mapped(obj)
else:
return getattr(obj, mapped)
raise AttributeError(name)
def _setup_prop (self, e_type, name, kind, prop) :
self.__super._setup_prop (e_type, name, kind, prop)
if not (prop.electric or prop.is_primary) :
self._user_attr.append (prop)
if prop.save_to_db and not prop.prop.is_partial :
self._db_attr.append (prop)
if callable (prop.sync) :
self._syncable.append (prop)
def _gen (self, names, E_Type) :
if E_Type is None :
E_Type = self.E_Type
_f = self._field
p_map = self._field_pred_map
for name in names :
pred = p_map.get (name)
if pred is None or (pred (self) if callable (pred) else pred) :
f = _f (name, E_Type)
yield f
def _field_type_callable (self, name, FT) :
M_Field = GTW.RST.TOP.MOM.Field.M_Field
result = FT
if callable (result) and not isinstance (result, M_Field) :
try :
result = result (self)
except (TypeError, ValueError, LookupError) :
logging.exception \
( "Evaluating callable "
"field-type-property %s %s failed"
% (name, result)
)
result = None
return result
def _setup_root(self, app_type, root_spec):
RT = self.Root_Type
if root_spec and RT:
if callable(root_spec):
result = root_spec(self)
if not isinstance(result, RT.Essence):
raise TypeError \
( "%s returned %s %r, expected %s"
% (root_spec, result.__class__, result, RT)
)
else:
result = RT(*root_spec)
self._register_root(result)
return result
def _setup_root (self, app_type, root_spec) :
RT = self.Root_Type
if root_spec and RT :
if callable (root_spec) :
result = root_spec (self)
if not isinstance (result, RT.Essence) :
raise TypeError \
( "%s returned %s %r, expected %s"
% (root_spec, result.__class__, result, RT)
)
else :
result = RT (* root_spec)
self._register_root (result)
return result
def check_attribute (self, obj, attr, value) :
result = []
attr_dict = {attr.name : value}
for pn in self.attr_map [attr] :
p = self.pred_dict.get (pn)
if p :
r = p.check_predicate (obj, attr_dict)
if not r :
result.append (r.error)
if callable (attr.check_syntax) :
try :
attr.check_syntax (obj, value)
except MOM.Error.Attribute_Syntax as exc :
result.append (exc)
return result
def check_attribute(self, obj, attr, value):
result = []
attr_dict = {attr.name: value}
for pn in self.attr_map[attr]:
p = self.pred_dict.get(pn)
if p:
r = p.check_predicate(obj, attr_dict)
if not r:
result.append(r.error)
if callable(attr.check_syntax):
try:
attr.check_syntax(obj, value)
except MOM.Error.Attribute_Syntax as exc:
result.append(exc)
return result
def _get_attr_ (self, name) :
try :
return self.__super.__getitem__ (name)
except (NameError, KeyError) :
if self.msg is not None :
key = name.lower ()
getter = getattr (self.__class__, "_get_%s" % key, None)
if callable (getter) :
return getter (self)
else :
result = self.msg._get_header_ (key, name)
if result is not None :
return decoded_header (result)
result = getattr (self.msg, name, None)
if result is not None :
return result
if self._defaults :
try :
return self._defaults [name]
except (NameError, KeyError) :
pass
raise self.Lookup_Error (name)
def _get_attr_(self, name):
try:
return self.__super.__getitem__(name)
except (NameError, KeyError):
if self.msg is not None:
key = name.lower()
getter = getattr(self.__class__, "_get_%s" % key, None)
if callable(getter):
return getter(self)
else:
result = self.msg._get_header_(key, name)
if result is not None:
return decoded_header(result)
result = getattr(self.msg, name, None)
if result is not None:
return result
if self._defaults:
try:
return self._defaults[name]
except (NameError, KeyError):
pass
raise self.Lookup_Error(name)
