def add_task_factory(self,
name: str,
task_type: t.Type['Task'],
default_task_name: t.Optional[str] = None) -> None:
project = check_not_none(self.__project(), 'lost reference to project')
self.add(name,
TaskFactory(project, default_task_name or name, task_type))
def execute(
self,
selection: t.Union[None, str, t.List[str], Task, t.List[Task]] = None
) -> None:
root_project = check_not_none(self.root_project,
'no root project initialized')
root_project.finalize()
selected_tasks: t.Set[Task] = set()
if selection is None:
selected_tasks.update(
self.task_selector.select_default(root_project))
else:
if isinstance(selection, (str, Task)):
selection = t.cast(t.Union[t.List[str], t.List[Task]],
[selection])
for item in selection:
if isinstance(item, Task):
selected_tasks.add(item)
elif isinstance(item, str):
result_set = self.task_selector.select_tasks(
item, root_project)
if not result_set:
raise ValueError(
f'selector matched no tasks: {item!r}')
selected_tasks.update(result_set)
else:
raise TypeError(
f'expected str|Task, got {type(item).__name__}')
self.graph.add(*selected_tasks)
self.graph.ready()
self.executor.execute(self.graph)
def __call__(
self,
name: t.Union[str, ConfigureTaskCallback],
configure: t.Optional[ConfigureTaskCallback] = None) -> T_Task:
"""
Create a new instance of the task type.
"""
if not isinstance(name, str):
configure = name
name = None
project = check_not_none(self._project(), 'lost project reference')
task = project.task(name or self._default_name, self._task_type)
configure(task)
return task
def subtype(extends: t.Type,
name: str = None) -> t.Callable[[T_Type], T_Type]:
"""
Decorator for subtypes of the #@union-decorated type *extends*. The *extends* class must
use #union.Subtypes.Dynamic. If a *name* is specified, the class will also be decorated
with the #typeinfo annotation.
The decorated class _must_ be a subclass of the *extends* class, otherwise a #TypeError is
raised.
Example:
```py
@dataclass
@union.subtype(Person)
class Student(Person):
courses: t.Set[str]
```
"""
preconditions.check_instance_of(extends, type)
inst = preconditions.check_not_none(
get_annotation(extends, union, None),
lambda: f'{extends.__name__} is not annotated with @union')
subtypes = preconditions.check_instance_of(
inst.subtypes, DynamicSubtypes,
lambda: f'{extends.__name__} is not using union.Subtypes.Dynamic')
def decorator(subtype: T_Type) -> T_Type:
preconditions.check_subclass_of(subtype, extends)
if name is not None:
subtype = typeinfo(name)(subtype)
subtypes.add_type(typeinfo.get_name(subtype), subtype)
return subtype
return decorator
def project(self) -> 'Project':
return check_not_none(self._project(), 'lost project reference')
def parent(self) -> t.Optional['Project']:
if self._parent is not None:
return check_not_none(self._parent(), 'lost reference to parent')
return None
def context(self) -> 'Context':
return check_not_none(self._context(), 'lost reference to context')
def __repr__(self) -> str:
project = check_not_none(self.__project(), 'lost reference to project')
return f'Namespace(project={project.path!r}, name={self.__name__!r})'
def owner(self) -> t.Optional['HavingProperties']: return check_not_none(self._owner(), 'lost reference to origin') if self._owner is not None else None
