def __init__(cls, *args, **kws): BasicMeta.__init__(cls, *args, **kws) local_defs = {} for k in _assume_defined: attrname = as_property(k) v = cls.__dict__.get(attrname, '') if isinstance(v, (bool, integer_types, type(None))): if v is not None: v = bool(v) local_defs[k] = v defs = {} for base in reversed(cls.__bases__): try: defs.update(base._explicit_class_assumptions) except AttributeError: pass defs.update(local_defs) cls._explicit_class_assumptions = defs cls.default_assumptions = StdFactKB(defs) cls._prop_handler = {} for k in _assume_defined: try: cls._prop_handler[k] = getattr(cls, '_eval_is_%s' % k) except AttributeError: pass # Put definite results directly into the class dict, for speed for k, v in cls.default_assumptions.items(): setattr(cls, as_property(k), v) # protection e.g. for Integer.is_even=F <- (Rational.is_integer=F) derived_from_bases = set() for base in cls.__bases__: try: derived_from_bases |= set(base.default_assumptions) except AttributeError: continue # not an assumption-aware class for fact in derived_from_bases - set(cls.default_assumptions): pname = as_property(fact) if pname not in cls.__dict__: setattr(cls, pname, make_property(fact)) # Finally, add any missing automagic property (e.g. for Basic) for fact in _assume_defined: pname = as_property(fact) if not hasattr(cls, pname): setattr(cls, pname, make_property(fact))
def __init__(cls, *args, **kws): BasicMeta.__init__(cls, *args, **kws) local_defs = {} for k in _assume_defined: attrname = as_property(k) v = cls.__dict__.get(attrname, "") if isinstance(v, (bool, int, type(None))): if v is not None: v = bool(v) local_defs[k] = v defs = {} for base in reversed(cls.__bases__): assumptions = getattr(base, "_explicit_class_assumptions", None) if assumptions is not None: defs.update(assumptions) defs.update(local_defs) cls._explicit_class_assumptions = defs cls.default_assumptions = StdFactKB(defs) cls._prop_handler = {} for k in _assume_defined: eval_is_meth = getattr(cls, "_eval_is_%s" % k, None) if eval_is_meth is not None: cls._prop_handler[k] = eval_is_meth # Put definite results directly into the class dict, for speed for k, v in cls.default_assumptions.items(): setattr(cls, as_property(k), v) # protection e.g. for Integer.is_even=F <- (Rational.is_integer=F) derived_from_bases = set() for base in cls.__bases__: default_assumptions = getattr(base, "default_assumptions", None) # is an assumption-aware class if default_assumptions is not None: derived_from_bases.update(default_assumptions) for fact in derived_from_bases - set(cls.default_assumptions): pname = as_property(fact) if pname not in cls.__dict__: setattr(cls, pname, make_property(fact)) # Finally, add any missing automagic property (e.g. for Basic) for fact in _assume_defined: pname = as_property(fact) if not hasattr(cls, pname): setattr(cls, pname, make_property(fact))
def __new__(mcl, name, latexname=None): if not latexname: latexname = name return BasicMeta.__new__(mcl, name + "Gate", (OneQubitGate, ), { 'gate_name': name, 'gate_name_latex': latexname })
def __init__(cls, *args, **kws): BasicMeta.__init__(cls, *args, **kws) cls_premises = {} for k in _assume_defined: attrname = as_property(k) v = cls.__dict__.get(attrname, '') if isinstance(v, (bool, int, long, type(None))): if v is not None: v = bool(v) cls_premises[k] = v cls._default_premises = {} for base in reversed(cls.__bases__): try: cls._default_premises.update(base._default_premises) except AttributeError: pass cls._default_premises.update(cls_premises) # deduce all consequences from default assumptions -- make it complete default_assumptions = _assume_rules.deduce_all_facts( cls._default_premises) # and store completed set into cls -- this way we'll avoid rededucing # extensions of class default assumptions each time on instance # creation -- we keep it prededuced already. for k, v in default_assumptions.iteritems(): setattr(cls, as_property(k), v) cls.default_assumptions = default_assumptions # protection e.g. for Initeger.is_even=F <- (Rational.is_integer=F) base_derived_premises = set() for base in cls.__bases__: try: base_derived_premises |= (set(base.default_assumptions) - set(base._default_premises)) except AttributeError: continue #not an assumption-aware class for fact in base_derived_premises: if as_property(fact) not in cls.__dict__: cls.add_property(fact) for fact in _assume_defined: if not hasattr(cls, as_property(fact)): cls.add_property(fact)
def __init__(cls, *args, **kws): BasicMeta.__init__(cls, *args, **kws) cls_premises = {} for k in _assume_defined: attrname = as_property(k) v = cls.__dict__.get(attrname, '') if isinstance(v, (bool, int, long, type(None))): if v is not None: v = bool(v) cls_premises[k] = v cls._default_premises = {} for base in reversed(cls.__bases__): try: cls._default_premises.update(base._default_premises) except AttributeError: pass cls._default_premises.update(cls_premises) # deduce all consequences from default assumptions -- make it complete default_assumptions = _assume_rules.deduce_all_facts(cls._default_premises) # and store completed set into cls -- this way we'll avoid rededucing # extensions of class default assumptions each time on instance # creation -- we keep it prededuced already. for k, v in default_assumptions.iteritems(): setattr(cls, as_property(k), v) cls.default_assumptions = default_assumptions # protection e.g. for Initeger.is_even=F <- (Rational.is_integer=F) base_derived_premises = set() for base in cls.__bases__: try: base_derived_premises |= (set(base.default_assumptions) - set(base._default_premises)) except AttributeError: continue #not an assumption-aware class for fact in base_derived_premises: if as_property(fact) not in cls.__dict__: cls.add_property(fact) for fact in _assume_defined: if not hasattr(cls, as_property(fact)): cls.add_property(fact)
def __new__(mcl, name, latexname=None): if not latexname: latexname = name return BasicMeta.__new__( mcl, name + "Gate", (OneQubitGate, ), { "gate_name": name, "gate_name_latex": latexname }, )
def __new__(mcl, name, latexname=None): if not latexname: latexname = name return BasicMeta.__new__(mcl, name + "Gate", (OneQubitGate,), {'gate_name': name, 'gate_name_latex': latexname})
def test_core_basic(): for c in (Atom, Atom(), Basic, Basic(), BasicMeta, BasicMeta("test"), BasicType, BasicType("test"), ClassRegistry, ClassRegistry(), SingletonRegistry, SingletonRegistry()): check(c)
def __le__(self, other): return BasicMeta.__le__(self.basic, other)
def __floordiv__(self, other): return BasicMeta.__floordiv__(self.basic, other)
def __truediv__(self, other): return BasicMeta.__truediv__(self.basic, other)
def __init__(self, *args, **kws): BasicMeta.__init__(self, *args, **kws) local_defs = {} for k in _assume_defined: attrname = as_property(k) v = self.__dict__.get(attrname, '') if isinstance(v, (bool, int, type(None))): if v is not None: v = bool(v) local_defs[k] = v defs = {} for base in reversed(self.__bases__): assumptions = getattr(base, '_explicit_class_assumptions', None) if assumptions is not None: defs.update(assumptions) defs.update(local_defs) self._explicit_class_assumptions = defs self.default_assumptions = StdFactKB(defs) self._prop_handler = {} for k in _assume_defined: eval_is_meth = getattr(self, '_eval_is_%s' % k, None) if eval_is_meth is not None: self._prop_handler[k] = eval_is_meth # Put definite results directly into the class dict, for speed for k, v in self.default_assumptions.items(): setattr(self, as_property(k), v) # protection e.g. for Integer.is_even=F <- (Rational.is_integer=F) derived_from_bases = set() for base in self.__bases__: default_assumptions = getattr(base, 'default_assumptions', None) # is an assumption-aware class if default_assumptions is not None: derived_from_bases.update(default_assumptions) for fact in derived_from_bases - set(self.default_assumptions): pname = as_property(fact) if pname not in self.__dict__: setattr(self, pname, make_property(fact)) # add any missing automagic property (e.g. for Basic) for fact in _assume_defined: pname = as_property(fact) if not hasattr(self, pname): setattr(self, pname, make_property(fact)) # Finally, add class name property for Basic and self, eg, Basic.is_CLASSNAME = None, and CLASSNAME.is_CLASSNAME = True pname = as_property(self.__name__) if pname not in self.__dict__: setattr(self, pname, True) # look in Method Resolution Order for base in reversed(self.__mro__): if not isinstance(base, ManagedProperties): continue assert base.__name__ == 'Basic', "self = %s, base = %s" % (self, base) if pname not in base.__dict__: setattr(base, pname, False) break