def reinitialize_with_args(self, *action_init_args, **action_init_kwargs):
check_and_raise(
self.init_func,
'Cannot initialize without an initialization function. Please provide an "init" key or a class on action_info',
KeyError)
self.init_result = self.init_func(*action_init_args, **action_init_kwargs)
if self.init_class:
self.func = self.init_result.run
def one_or_none(self) -> Optional[GraphObject]:
quantity = len(self.results)
check_and_raise(
quantity <= 1,
QuantityError(
f'Expected to have one or no objects. Has {quantity}'))
if self.results:
return next(iter(self.results))
else:
return None
def filter_by_relation(self, relation: Query) -> 'Query':
check_and_raise(relation.lazy)
def action(results: Iterable[GraphObject]):
new_results = []
for element in results:
if relation.execute(element).has_any():
new_results.append(element)
return new_results
if self.lazy:
self._calls.append(action)
else:
self.results = action(self.results)
return self
def __init__(self,
*action_run_args,
action_info: Union[ActionTemplate, dict, object],
name=None,
**action_run_kwargs):
if type(action_info) is not ActionTemplate:
check_and_raise(name, "parameter 'name' must be set when 'action_info' is not of type ActionTemplate",
NameError)
action_info = ActionTemplate.make(name=name, action_info=action_info)
self.name = action_info.name
self.func = action_info.func
self.run_args = action_run_args
self.run_kwargs = action_run_kwargs
self.init_result = action_info.init_result
self.task_info_getter = action_info.task_info_getter
def make(cls, *action_init_args, name, action_info: Union[dict, Callable],
**action_init_kwargs) -> 'ActionTemplate':
self = cls(name=name, func=None)
self.init_class = None
if type(action_info) is dict:
if 'class' in action_info:
self.init_class = action_info['class']
else:
check_and_raise('run' in action_info, 'action_info must contain a "run" key with a callable as value',
KeyError)
self.func = action_info['run']
if 'init' in action_info:
self.init_func = action_info['init']
if 'description' in action_info:
self.description = action_info['description']
self.task_info_getter = action_info.get('task_info', None)
elif inspect.isfunction(action_info) or inspect.isbuiltin(action_info):
self.func = action_info
else:
self.init_class = action_info
if hasattr(self.init_class, 'description'):
self.description = self.init_class.description
if self.init_class:
self.init_func = self.init_class
if self.init_func:
self.init_result = self.init_func(*action_init_args, **action_init_kwargs)
if self.init_class:
check_and_raise(hasattr(self.init_class, 'run'), 'action_info must contain a "run" attribute',
AttributeError)
self.func = self.init_result.run
return self
def ensure_type(
obj: Any,
_type: Union[Type[T], Union[Type, Tuple[Union[Type, None], ...]]],
output_type: Optional[Type[T]] = None,
exception: Union[BaseException, Type[BaseException]] = TypeError) -> T:
# if output_type is None:
# if isinstance(_type, Tuple):
# raise ValueError('output_type must be set when more than one type is given')
# else:
# output_type = _type
if isinstance(_type, tuple) and None in _type:
if obj is None:
return None
_type = tuple(t for t in _type if t is not None)
if isinstance(exception, BaseException): # is instance of exception
check_and_raise(isinstance(obj, _type), exception=exception)
else: # is class
exception_message = f"Object of type {type(obj)} does not match type {_type}"
check_and_raise(isinstance(obj, _type),
exception=exception(exception_message))
return cast(T, obj)
def ensure_zero(self):
quantity = len(self.results)
check_and_raise(
quantity == 0,
QuantityError(f'Expected to have no objects. Has {quantity}'))
def one(self) -> GraphObject:
quantity = len(self.results)
check_and_raise(
quantity == 1,
QuantityError(f'Expected to have one object. Has {quantity}'))
return next(iter(self.results))
def results(self, value: Iterable[GraphObject]):
check_and_raise(not self.lazy)
self._results = set(value)
def results(self):
check_and_raise(not self.lazy)
return self._results
def _get_real_index(self, index: int) -> int:
if index < 0:
index = len(self) + index
check_and_raise(0 <= index < len(self), IndexError)
return index
