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, 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
