def load_dict(self, d: dict):
data = build_argument_list(d.copy(),
self.__class__,
strict=False,
include_none_parameters=True)
t = typing.get_type_hints(self.__class__)
for name, type_ in t.items():
if name in data:
if inspect.isclass(type_) and issubclass(
type_,
(datetime, date)) and isinstance(data[name], str):
setattr(self, name, parse(data[name], ignoretz=True))
elif inspect.isclass(type_) and issubclass(
type_, ValueObject) and isinstance(data[name], type_):
existing = getattr(self, name)
if existing is None:
setattr(self, name, data[name])
elif name in d and isinstance(d[name], dict):
existing.load_dict(d[name])
else:
try:
if data[name] is not None and not isinstance(
data[name], type_):
setattr(self, name, type_(data[name]))
else:
setattr(self, name, data[name])
except TypeError:
setattr(self, name, data[name])
def run(self, app: CliApp):
self._app = app
params = {}
if app.description is not None:
params['description'] = app.description
self._parser = argparse.ArgumentParser(**params)
self._initialize()
args = self._parser.parse_args()
if args.verbose is True:
self._logger.set_level_to_info()
if args.debug is True:
self._logger.set_level_to_debug()
os.environ['ENV'] = args.env or 'local'
try:
target = args.target
except AttributeError:
target = None
if target is None:
self._parser.print_help()
return
message = self._message_cache[target]
instance = message(**build_argument_list(vars(args), message))
if issubclass(message, Command):
self.invoke(instance)
elif issubclass(message, Query):
self.request(instance)
def from_dict(cls, data: dict, map_: dict = None):
d = None
if map_ is not None:
d = data.copy()
for source, target in map_.items():
d[target] = d[source]
return cls(**build_argument_list(d or data, cls))
def _process_data(cls, data: dict):
t = typing.get_type_hints(cls)
for name, type_ in t.items():
if name.startswith('_'):
continue
if isinstance(type_, type(List)) and len(type_.__args__) == 1:
new_list = []
for item in data[name]:
nested_data = Entity._process_data(type_.__args__[0], item)
new_list.append(type_.__args__[0](
**build_argument_list(nested_data, type_.__args__[0])))
data[name] = new_list
else:
try:
if issubclass(type_, Entity):
data[name] = type_(
**build_argument_list(data[name], type_))
except TypeError:
pass
return data
def from_dict(cls, data: dict, map_: dict = None, skip: list = None):
if map_ is not None:
d = data.copy()
for source, target in map_.items():
if source in d:
d[target] = d[source]
data = d
if skip is not None:
d = data.copy()
for k in data.keys():
if k in skip:
del d[k]
data = d
return cls(**build_argument_list(data, cls))