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