def __new__(cls, *args, **kwargs):
attrs = getattr(OrderedDict(), '__dict__', {})
attrs.update(cls.__dict__)
obj = type(cls.__name__, cls.__bases__, attrs)
self = OrderedDict.__new__(obj, *args, **kwargs)
OrderedDict.__setattr__(self, '__dict__', self)
OrderedDict.__init__(self, *args, **kwargs)
return self
def __new__(cls, *args):
"""Create a new immutable GroupableOrderedDict."""
new = OrderedDict.__new__(cls)
OrderedDict.__init__(new)
if len(args) > 1:
raise TypeError('expected at most 1 arguments, got {}'
.format(len(args)))
ordering = []
values = args[0]
if values:
if isinstance(values, GroupableOrderedDict):
values = values.iteritems(with_order=False, repeated=True)
elif isinstance(values, dict):
if '__order__' in values:
order = values.pop('__order__')
tmp = []
c = Counter()
for key in order:
v = values[key]
if not isinstance(v, (tuple, list)):
if c[key] == 0:
tmp.append((key, v))
else:
raise Exception("Order and values don't match"
"on key {0} at position {1}"
.format(key, c[key]))
else:
tmp.append((key, v[c[key]]))
c[key] += 1
values = tmp
else:
values = iteritems(values)
for key, value in values:
if key not in new:
OrderedDict.__setitem__(new, key, [])
v = []
if isinstance(value, (tuple, list)):
for item in value:
v.append(item)
ordering.append(key)
else:
v.append(value)
ordering.append(key)
OrderedDict.__getitem__(new, key).extend(v)
# Immutable...
for key, value in dict.items(new):
OrderedDict.__setitem__(new, key, tuple(value))
OrderedDict.__setitem__(new, '__order__', tuple(ordering))
return new
def __new__(cls):
self = OrderedDict.__new__(cls)
if not hasattr(cls, 'Key'):
raise TypeError("Mapping classes must define an inner class called 'Key'")
if not hasattr(cls, 'Value'):
raise TypeError("Mapping classes must define an inner class called 'Value'")
if not (inspect.isclass(cls.Key) and issubclass(cls.Key, Scalar)):
raise TypeError("Inner class 'Key' must be a subclass of Scalar")
if not (inspect.isclass(cls.Value) and issubclass(cls.Value, BaseValue)):
raise TypeError("Inner class 'Value' must be a subclass of BaseValue")
return self
def __new__(cls,*args,**kwarg):
""" Creates a new Data() class
Assumptions:
N/A
Source:
N/A
Inputs:
N/A
Outputs:
N/A
Properties Used:
N/A
"""
# Make the new:
self = OrderedDict.__new__(cls)
if self.hasattr('_root'):
self._root
else:
root = [] # sentinel node
root[:] = [root, root, None]
dict.__setitem__(self,'_root',root)
dict.__setitem__(self,'_map' ,{})
# Use the base init
self.__init2()
# get base class list
klasses = self.get_bases()
# fill in defaults trunk to leaf
for klass in klasses[::-1]:
klass.__defaults__(self)
return self
def __new__(cls,*args,**kwarg):
""" Creates a new Data() class
Assumptions:
N/A
Source:
N/A
Inputs:
N/A
Outputs:
N/A
Properties Used:
N/A
"""
# Make the new:
self = OrderedDict.__new__(cls)
if hasattr(self,'_root'):
self._root
else:
root = [] # sentinel node
root[:] = [root, root, None]
dict.__setitem__(self,'_root',root)
dict.__setitem__(self,'_map' ,{})
# Use the base init
self.__init2()
# get base class list
klasses = self.get_bases()
# fill in defaults trunk to leaf
for klass in klasses[::-1]:
klass.__defaults__(self)
return self
def __new__(cls, *args, **kwarg):
# Make the new:
self = OrderedDict.__new__(cls)
if hasattr(self, '_root'):
self._root
else:
root = [] # sentinel node
root[:] = [root, root, None]
dict.__setitem__(self, '_root', root)
dict.__setitem__(self, '_map', {})
# Use the base init
self.__init2()
# get base class list
klasses = self.get_bases()
# fill in defaults trunk to leaf
for klass in klasses[::-1]:
klass.__defaults__(self)
return self
def __new__(cls, *args):
"""Create a new immutable GroupableOrderedDict."""
new = OrderedDict.__new__(cls)
OrderedDict.__init__(new)
if len(args) > 1:
raise TypeError('expected at most 1 arguments, got {}'.format(
len(args)))
ordering = []
values = args[0]
if values:
if isinstance(values, GroupableOrderedDict):
values = values.iteritems(with_order=False, repeated=True)
elif isinstance(values, dict):
if '__order__' in values:
order = values.pop('__order__')
tmp = []
c = Counter()
for key in order:
v = values[key]
if not isinstance(v, (tuple, list)):
if c[key] == 0:
tmp.append((key, v))
else:
raise Exception(
"Order and values don't match"
"on key {0} at position {1}".format(
key, c[key]))
else:
tmp.append((key, v[c[key]]))
c[key] += 1
values = tmp
else:
values = six.iteritems(values)
for key, value in values:
if key not in new:
OrderedDict.__setitem__(new, key, [])
v = []
if isinstance(value, (tuple, list)):
for item in value:
v.append(item)
ordering.append(key)
elif isinstance(value, dict):
if '__order__' in value:
value = GroupableOrderedDict(value)
v.append(value)
ordering.append(key)
else:
v.append(value)
ordering.append(key)
OrderedDict.__getitem__(new, key).extend(v)
# Immutable...
for key, value in dict.items(new):
OrderedDict.__setitem__(new, key, tuple(value))
OrderedDict.__setitem__(new, '__order__', tuple(ordering))
return new
def __new__(cls, *args, **kwargs):
__instance = OrderedDict.__new__(cls, *args, **kwargs)
__instance.__items = list()
__instance.__uniq_items = set()
return __instance
def __new__(cls):
if cls.__instance == None:
LOGGER.verbose('Creating ObjectBuilder singleton')
cls.__instance = OrderedDict.__new__(cls)
cls.__instance.name = "ObjectStorage"
return cls.__instance
