def __getitem__(self, item, _ignore_default=False):
try:
return super(Box, self).__getitem__(item)
except KeyError as err:
if item == '_box_config':
raise BoxKeyError(
'_box_config should only exist as an attribute and is never defaulted'
) from None
if self._box_config['box_dots'] and isinstance(
item, str) and ('.' in item or '[' in item):
first_item, children = _parse_box_dots(item)
if first_item in self.keys():
if hasattr(self[first_item], '__getitem__'):
return self[first_item][children]
if self._box_config['conversion_box'] and item:
k = _conversion_checks(item, self.keys(), self._box_config)
if k:
return self.__getitem__(k)
if self._box_config['camel_killer_box'] and isinstance(item, str):
converted = _camel_killer(item)
if converted in self.keys():
return super(Box, self).__getitem__(converted)
if self._box_config['default_box'] and not _ignore_default:
return self.__get_default(item)
raise BoxKeyError(str(err)) from None
def __getitem__(self, item, _ignore_default=False):
try:
return super().__getitem__(item)
except KeyError as err:
if item == "_box_config":
raise BoxKeyError(
"_box_config should only exist as an attribute and is never defaulted"
) from None
if self._box_config["box_dots"] and isinstance(
item, str) and ("." in item or "[" in item):
try:
first_item, children = _parse_box_dots(self, item)
except BoxError:
if self._box_config["default_box"] and not _ignore_default:
return self.__get_default(item)
raise
if first_item in self.keys():
if hasattr(self[first_item], "__getitem__"):
return self[first_item][children]
if self._box_config["camel_killer_box"] and isinstance(item, str):
converted = _camel_killer(item)
if converted in self.keys():
return super().__getitem__(converted)
if self._box_config["default_box"] and not _ignore_default:
return self.__get_default(item)
raise BoxKeyError(str(err)) from None
def __getattr__(self, item):
try:
try:
value = self.__getitem__(item, _ignore_default=True)
except KeyError:
value = object.__getattribute__(self, item)
except AttributeError as err:
if item == '__getstate__':
raise BoxKeyError(item) from None
if item == '_box_config':
raise BoxError('_box_config key must exist') from None
kill_camel = self._box_config['camel_killer_box']
if self._box_config['conversion_box'] and item:
k = _conversion_checks(item, self.keys(), self._box_config)
if k:
return self.__getitem__(k)
if kill_camel:
for k in self.keys():
if item == _camel_killer(k):
return self.__getitem__(k)
if self._box_config['default_box']:
return self.__get_default(item)
raise BoxKeyError(str(err)) from None
else:
if item == '_box_config':
return value
# return self.__convert_and_store(item, value)
return value
def __getattr__(self, item):
try:
try:
value = self.__getitem__(item, _ignore_default=True)
except KeyError:
value = object.__getattribute__(self, item)
except AttributeError as err:
if item == "__getstate__":
raise BoxKeyError(item) from _exception_cause(err)
if item == "_box_config":
raise BoxError(
"_box_config key must exist") from _exception_cause(err)
if self._box_config["conversion_box"]:
safe_key = self._safe_attr(item)
if safe_key in self._box_config["__safe_keys"]:
return self.__getitem__(
self._box_config["__safe_keys"][safe_key])
if self._box_config["default_box"]:
if item.startswith("_") and item.endswith("_"):
raise BoxKeyError(
f"{item}: Does not exist and internal methods are never defaulted"
)
return self.__get_default(item, attr=True)
raise BoxKeyError(str(err)) from _exception_cause(err)
return value
def __getitem__(self, item, _ignore_default=False):
try:
return super().__getitem__(item)
except KeyError as err:
if item == "_box_config":
cause = _exception_cause(err)
raise BoxKeyError(
"_box_config should only exist as an attribute and is never defaulted"
) from cause
if self._box_config["box_dots"] and isinstance(
item, str) and ("." in item or "[" in item):
try:
first_item, children = _parse_box_dots(self, item)
except BoxError:
if self._box_config["default_box"] and not _ignore_default:
return self.__get_default(item)
raise BoxKeyError(str(item)) from _exception_cause(err)
if first_item in self.keys():
if hasattr(self[first_item], "__getitem__"):
return self[first_item][children]
if self._box_config["camel_killer_box"] and isinstance(item, str):
converted = _camel_killer(item)
if converted in self.keys():
return super().__getitem__(converted)
if self._box_config["default_box"] and not _ignore_default:
return self.__get_default(item)
raise BoxKeyError(str(err)) from _exception_cause(err)
except TypeError as err:
if isinstance(item, slice):
new_box = self._box_config["box_class"](**self.__box_config())
for x in list(super().keys())[item.start:item.stop:item.step]:
new_box[x] = self[x]
return new_box
raise BoxTypeError(str(err)) from _exception_cause(err)
def __getattr__(self, item):
try:
try:
value = self.__getitem__(item, _ignore_default=True)
except KeyError:
value = object.__getattribute__(self, item)
except AttributeError as err:
if item == '__getstate__':
raise BoxKeyError(item) from None
if item == '_box_config':
raise BoxError('_box_config key must exist') from None
if self._box_config['default_box']:
return self.__get_default(item)
raise BoxKeyError(str(err)) from None
return value
def append(self, p_object):
if isinstance(p_object, dict) and not self._is_intact_type(p_object):
try:
p_object = self.box_class(p_object, **self.box_options)
except AttributeError as err:
if 'box_class' in self.__dict__:
raise BoxKeyError(err)
elif isinstance(p_object, list) and not self._is_intact_type(p_object):
try:
p_object = (self if id(p_object) == self.box_org_ref else
BoxList(p_object, **self.box_options))
except AttributeError as err:
if 'box_org_ref' in self.__dict__:
raise BoxKeyError(err)
super(BoxList, self).append(p_object)
def __setattr__(self, key, value):
if key != '_box_config' and self._box_config[
'frozen_box'] and self._box_config['__created']:
raise BoxError('Box is frozen')
if key in self._protected_keys:
raise BoxKeyError(f'Key name "{key}" is protected')
if key == '_box_config':
return object.__setattr__(self, key, value)
value = self.__recast(key, value)
if key not in self.keys() and (self._box_config['conversion_box'] or
self._box_config['camel_killer_box']):
if self._box_config['conversion_box']:
k = _conversion_checks(key, self.keys(), self._box_config)
self[key if not k else k] = value
elif self._box_config['camel_killer_box']:
for each_key in self:
if key == _camel_killer(each_key):
self[each_key] = value
break
else:
self[_camel_killer(key)] = value
else:
self[key] = value
self.__convert_and_store(key, value)
self.__create_lineage()
def __delattr__(self, item):
if self._box_config["frozen_box"]:
raise BoxError("Box is frozen")
if item == "_box_config":
raise BoxError('"_box_config" is protected')
if item in self._protected_keys:
raise BoxKeyError(f'Key name "{item}" is protected')
try:
self.__delitem__(item)
except KeyError as err:
if self._box_config["conversion_box"]:
safe_key = self._safe_attr(item)
if safe_key in self._box_config["__safe_keys"]:
self.__delitem__(self._box_config["__safe_keys"][safe_key])
del self._box_config["__safe_keys"][safe_key]
return
raise BoxKeyError(str(err)) from None
def popitem(self):
if self._box_config["frozen_box"]:
raise BoxError("Box is frozen")
try:
key = next(self.__iter__())
except StopIteration:
raise BoxKeyError("Empty box") from None
return key, self.pop(key)
def __delattr__(self, item):
if self._box_config['frozen_box']:
raise BoxError('Box is frozen')
if item == '_box_config':
raise BoxError('"_box_config" is protected')
if item in self._protected_keys:
raise BoxKeyError(f'Key name "{item}" is protected')
self.__delitem__(item)
def __delattr__(self, item):
if self._box_config['frozen_box']:
raise BoxError('Box is frozen')
if item == '_box_config':
raise BoxError('"_box_config" is protected')
if item in self._protected_keys:
raise BoxKeyError(f'Key name "{item}" is protected')
try:
self.__delitem__(item)
except KeyError as err:
if self._box_config['conversion_box']:
safe_key = self._safe_attr(item)
if safe_key in self._box_config['__safe_keys']:
self.__delitem__(self._box_config['__safe_keys'][safe_key])
del self._box_config['__safe_keys'][safe_key]
return
raise BoxKeyError(err)
def _is_intact_type(self, obj):
try:
if self.box_options.get('box_intact_types') and isinstance(
obj, self.box_options['box_intact_types']):
return True
except AttributeError as err:
if 'box_options' in self.__dict__:
raise BoxKeyError(err)
return False
def __setattr__(self, key, value):
if key != '_box_config' and self._box_config[
'frozen_box'] and self._box_config['__created']:
raise BoxError('Box is frozen')
if key in self._protected_keys:
raise BoxKeyError(f'Key name "{key}" is protected')
if key == '_box_config':
return object.__setattr__(self, key, value)
value = self.__recast(key, value)
self.__setitem__(key, value)
def __getattr__(self, item):
try:
try:
value = self.__getitem__(item, _ignore_default=True)
except KeyError:
value = object.__getattribute__(self, item)
except AttributeError as err:
if item == "__getstate__":
raise BoxKeyError(item) from _exception_cause(err)
if item == "_box_config":
raise BoxError("_box_config key must exist") from _exception_cause(err)
if self._box_config["conversion_box"]:
safe_key = self._safe_attr(item)
if safe_key in self._box_config["__safe_keys"]:
return self.__getitem__(self._box_config["__safe_keys"][safe_key])
if self._box_config["default_box"]:
return self.__get_default(item, attr=True)
raise BoxKeyError(str(err)) from _exception_cause(err)
return value
def __setattr__(self, key, value):
if key != "_box_config" and self._box_config["frozen_box"] and self._box_config["__created"]:
raise BoxError("Box is frozen")
if key in self._protected_keys:
raise BoxKeyError(f'Key name "{key}" is protected')
if key == "_box_config":
return object.__setattr__(self, key, value)
safe_key = self._safe_attr(key)
if safe_key in self._box_config["__safe_keys"]:
key = self._box_config["__safe_keys"][safe_key]
self.__setitem__(key, value)
def __getitem__(self, item, _ignore_default=False):
try:
value = super(Box, self).__getitem__(item)
except KeyError as err:
if item == '_box_config':
raise BoxKeyError(
'_box_config should only exist as an attribute and is never defaulted'
) from None
if self._box_config['box_dots'] and isinstance(
item, str) and '.' in item:
first_item, children = item.split('.', 1)
if first_item in self.keys() and isinstance(
self[first_item], dict):
return self[first_item][children]
if self._box_config['default_box'] and not _ignore_default:
return self.__get_default(item)
raise BoxKeyError(str(err)) from None
else:
return value
def __delitem__(self, key):
if self._box_config["frozen_box"]:
raise BoxError("Box is frozen")
if (key not in self.keys() and self._box_config["box_dots"]
and isinstance(key, str) and ("." in key or "[" in key)):
try:
first_item, children = _parse_box_dots(self, key)
except BoxError:
raise BoxKeyError(str(key)) from None
if hasattr(self[first_item], "__delitem__"):
return self[first_item].__delitem__(children)
if key not in self.keys() and self._box_config["camel_killer_box"]:
if self._box_config["camel_killer_box"] and isinstance(key, str):
for each_key in self:
if _camel_killer(key) == each_key:
key = each_key
break
try:
super().__delitem__(key)
except KeyError as err:
raise BoxKeyError(str(err)) from _exception_cause(err)
def pop(self, key, *args):
if args:
if len(args) != 1:
raise BoxError(
'pop() takes only one optional argument "default"')
try:
item = self[key]
except KeyError:
return args[0]
else:
del self[key]
return item
try:
item = self[key]
except KeyError:
raise BoxKeyError('{0}'.format(key)) from None
else:
del self[key]
return item
def pop(self, key, *args):
if self._box_config["frozen_box"]:
raise BoxError("Box is frozen")
if args:
if len(args) != 1:
raise BoxError('pop() takes only one optional argument "default"')
try:
item = self[key]
except KeyError:
return args[0]
else:
del self[key]
return item
try:
item = self[key]
except KeyError:
raise BoxKeyError(f"{key}") from None
else:
del self[key]
return item
def pop(self, key, *args):
if args:
if len(args) != 1:
raise BoxError(
'pop() takes only one optional argument "default"')
try:
item = self[key]
except KeyError:
return args[0]
else:
del self[key]
if isinstance(item, Box):
item._box_config['__box_heritage'] = ()
return item
try:
item = self[key]
except KeyError:
raise BoxKeyError('{0}'.format(key)) from None
else:
del self[key]
if isinstance(item, Box):
item._box_config['__box_heritage'] = ()
return item
def __delitem__(self, key):
if self._box_config['frozen_box']:
raise BoxError('Box is frozen')
if key not in self.keys(
) and self._box_config['box_dots'] and isinstance(key,
str) and '.' in key:
first_item, children = key.split('.', 1)
if first_item in self.keys() and isinstance(
self[first_item], dict):
return self[first_item].__delitem__(children)
if key not in self.keys() and (self._box_config['conversion_box'] or
self._box_config['camel_killer_box']):
if self._box_config['conversion_box']:
k = _conversion_checks(key, self.keys(), self._box_config)
super(Box, self).__delitem__(key if not k else k)
elif self._box_config['camel_killer_box']:
for each_key in self:
if key == _camel_killer(each_key):
super(Box, self).__delitem__(each_key)
break
else:
raise BoxKeyError(f'Cannot find {key} to delete')
else:
super(Box, self).__delitem__(key)
def popitem(self):
try:
key = next(self.__iter__())
except StopIteration:
raise BoxKeyError('Empty box') from None
return key, self.pop(key)
