def UnorderedIteratorMixin(class_name):
class UIM(object):
@classmethod
def __typesig__(cls, obj):
if isinstance(obj, cls):
return _UnorderedIteratorMixin(class_name, obj)
def __repr__(self):
return "%s%s" % (class_name, str(tuple(e for e in self)))
# We register each produced class anew
# If someone needs to unregister these classes, they should
# save a copy of it before including it in the class-definition:
#
# my_UIM = UnorderedIteratorMixin("FooClass")
# class FooClass(my_UIM):
# ...
#
# Alternatively, you could just look in FooClass.__bases__ later; whatever
register_type(UIM)
return UIM
def UnorderedIteratorMixin(class_name):
class UIM(object):
@classmethod
def __typesig__(cls, obj):
if isinstance(obj, cls):
return _UnorderedIteratorMixin(class_name, obj)
def __repr__(self):
return "%s%s" % (class_name, str(tuple(e for e in self)))
# We register each produced class anew
# If someone needs to unregister these classes, they should
# save a copy of it before including it in the class-definition:
#
# my_UIM = UnorderedIteratorMixin("FooClass")
# class FooClass(my_UIM):
# ...
#
# Alternatively, you could just look in FooClass.__bases__ later; whatever
register_type(UIM)
return UIM
### class MyClass(UnorderedIteratorMixin("MyClass")):
### blah blah blah
###
### This serves as a class factory, whose produced classes
### attempt to mask the fact they exist. Their purpose
### is to redirect __typesig__ calls to appropriate
### instances of _UnorderedIteratorMixin
def UnorderedIteratorMixin(class_name):
class UIM(object):
@classmethod
def __typesig__(cls, obj):
if isinstance(obj, cls):
return _UnorderedIteratorMixin(class_name, obj)
def __repr__(self):
return "%s%s" % (class_name, str(tuple(e for e in self)))
# We register each produced class anew
# If someone needs to unregister these classes, they should
# save a copy of it before including it in the class-definition:
#
# my_UIM = UnorderedIteratorMixin("FooClass")
# class FooClass(my_UIM):
# ...
#
# Alternatively, you could just look in FooClass.__bases__ later; whatever
register_type(UIM)
return UIM
register_type(_UnorderedIteratorMixin)
### blah blah blah
###
### This serves as a class factory, whose produced classes
### attempt to mask the fact they exist. Their purpose
### is to redirect __typesig__ calls to appropriate
### instances of _UnorderedIteratorMixin
def UnorderedIteratorMixin(class_name):
class UIM(object):
@classmethod
def __typesig__(cls, obj):
if isinstance(obj, cls):
return _UnorderedIteratorMixin(class_name, obj)
def __repr__(self):
return "%s%s" % (class_name, str(tuple(e for e in self)))
# We register each produced class anew
# If someone needs to unregister these classes, they should
# save a copy of it before including it in the class-definition:
#
# my_UIM = UnorderedIteratorMixin("FooClass")
# class FooClass(my_UIM):
# ...
#
# Alternatively, you could just look in FooClass.__bases__ later; whatever
register_type(UIM)
return UIM
register_type(_UnorderedIteratorMixin)
raise _TC_LengthError(len(to_check), 0)
for obj in to_check:
error = False
for type in self._types:
try:
check_type(type, func, obj)
except _TC_Exception:
error = True
continue
else:
error = False
break
if error:
raise _TC_KeyError(obj, _TC_TypeError(obj, self._type))
def __eq__(self, other):
if self.__class__ is not other.__class__:
return False
return self.type == other.type
def __hash__(self):
return hash(str(hash(self.__class__)) + str(hash(frozenset(self.type))))
@classmethod
def __typesig__(self, obj):
if isinstance(obj, set):
return Set(obj)
register_type(Set)
