.. _doot.control.tracker._interface:
  
===============================
doot.control.tracker._interface
===============================
  


.. py:module:: doot.control.tracker._interface

 






Type Aliases
------------

.. autoapisummary::

   doot.control.tracker._interface.Abstract



Enums
-----

.. autoapisummary::

   doot.control.tracker._interface.EdgeType_e
   doot.control.tracker._interface.ExecutionPolicy_e




Protocols
---------

.. autoapisummary::

   doot.control.tracker._interface.Registry_p
   doot.control.tracker._interface.Network_p
   doot.control.tracker._interface.Queue_p
   doot.control.tracker._interface.WorkflowTracker_p
   doot.control.tracker._interface.WorkflowTracker_i




Classes
-------
  


.. autoapisummary::

    doot.control.tracker._interface.SpecMeta_d
    doot.control.tracker._interface.ArtifactMeta_d
    doot.control.tracker._interface.Registry_d

Module Contents
===============

.. py:data:: Abstract
   :type:  TypeAlias
   :value: T



.. _doot.control.tracker._interface.EdgeType_e:
  


.. py:class:: EdgeType_e(*args, **kwds)

   Bases: :py:obj:`enum.Enum` 
  
   Enum describing the possible edges of the task tracker's task network


   .. py:attribute:: TASK

   .. py:attribute:: ARTIFACT_UP

   .. py:attribute:: ARTIFACT_DOWN

   .. py:attribute:: TASK_CROSS

   .. py:attribute:: ARTIFACT_CROSS

   .. py:attribute:: default

   
   .. py:method:: artifact_edge_set() -> set[EdgeType_e.artifact_edge_set.T]
      :classmethod:



 

.. _doot.control.tracker._interface.ExecutionPolicy_e:
  


.. py:class:: ExecutionPolicy_e(*args, **kwds)

   Bases: :py:obj:`enum.Enum` 
  
   How the task execution will be ordered
   PRIORITY : Priority Queue with retry, job expansion, dynamic walk of network.
   DEPTH    : No (priority,retry,jobs). basic DFS of the pre-run dependency network
   BREADTH  : No (priority,retry,jobs). basic BFS of the pre-run dependency-network



   .. py:attribute:: PRIORITY

   .. py:attribute:: DEPTH

   .. py:attribute:: BREADTH

   .. py:attribute:: default

 

.. _doot.control.tracker._interface.Registry_p:
  


.. py:class:: Registry_p

   Bases: :py:obj:`Protocol` 
  
   Base class for protocol classes.

   Protocol classes are defined as::

       class Proto(Protocol):
           def meth(self) -> int:
               ...

   Such classes are primarily used with static type checkers that recognize
   structural subtyping (static duck-typing).

   For example::

       class C:
           def meth(self) -> int:
               return 0

       def func(x: Proto) -> int:
           return x.meth()

       func(C())  # Passes static type check

   See PEP 544 for details. Protocol classes decorated with
   @typing.runtime_checkable act as simple-minded runtime protocols that check
   only the presence of given attributes, ignoring their type signatures.
   Protocol classes can be generic, they are defined as::

       class GenProto[T](Protocol):
           def meth(self) -> T:
               ...


   
   .. py:method:: register_spec(*specs: doot.workflow._interface.TaskSpec_i) -> None



   
   .. py:method:: instantiate_spec(name: Abstract[doot.workflow._interface.TaskName_p], *, force: jgdv.Maybe[bool | int] = None, extra: jgdv.Maybe[dict | jgdv.structs.chainguard.ChainGuard | bool] = None) -> jgdv.Maybe[Concrete[doot.workflow._interface.TaskName_p]]



   
   .. py:method:: instantiate_relation(rel: doot.workflow._interface.RelationSpec_i, *, control: Concrete[doot.workflow._interface.TaskName_p]) -> Concrete[doot.workflow._interface.TaskName_p]



   
   .. py:method:: make_task(name: Concrete[doot.workflow._interface.TaskName_p], *, task_obj: jgdv.Maybe[doot.workflow._interface.Task_i] = None, parent: jgdv.Maybe[Concrete[doot.workflow._interface.TaskName_p]] = None) -> Concrete[doot.workflow._interface.TaskName_p]



   
   .. py:method:: verify(*, strict: bool = True) -> bool



 

.. _doot.control.tracker._interface.Network_p:
  


.. py:class:: Network_p

   Bases: :py:obj:`Protocol` 
  
   Base class for protocol classes.

   Protocol classes are defined as::

       class Proto(Protocol):
           def meth(self) -> int:
               ...

   Such classes are primarily used with static type checkers that recognize
   structural subtyping (static duck-typing).

   For example::

       class C:
           def meth(self) -> int:
               return 0

       def func(x: Proto) -> int:
           return x.meth()

       func(C())  # Passes static type check

   See PEP 544 for details. Protocol classes decorated with
   @typing.runtime_checkable act as simple-minded runtime protocols that check
   only the presence of given attributes, ignoring their type signatures.
   Protocol classes can be generic, they are defined as::

       class GenProto[T](Protocol):
           def meth(self) -> T:
               ...


   .. py:attribute:: _graph
      :type:  Any

   .. py:attribute:: _root_node
      :type:  doot.workflow._interface.TaskName_p

   .. py:attribute:: succ
      :type:  collections.abc.Mapping

   .. py:attribute:: pred
      :type:  collections.abc.Mapping

   .. py:attribute:: non_expanded
      :type:  set[doot.workflow._interface.TaskName_p | doot.workflow._interface.Artifact_i]

   
   .. py:method:: build_network(*, sources: jgdv.Maybe[Literal[True] | list[Concrete[doot.workflow._interface.TaskName_p] | doot.workflow._interface.Artifact_i]] = None) -> None



   
   .. py:method:: connect(left: Concrete[doot.workflow._interface.TaskName_p] | doot.workflow._interface.Artifact_i, right: jgdv.Maybe[Literal[False] | Concrete[doot.workflow._interface.TaskName_p] | doot.workflow._interface.Artifact_i] = None, **kwargs: Any) -> None



   
   .. py:method:: validate_network(*, strict: bool = True) -> bool



 

.. _doot.control.tracker._interface.Queue_p:
  


.. py:class:: Queue_p

   Bases: :py:obj:`Protocol` 
  
   Base class for protocol classes.

   Protocol classes are defined as::

       class Proto(Protocol):
           def meth(self) -> int:
               ...

   Such classes are primarily used with static type checkers that recognize
   structural subtyping (static duck-typing).

   For example::

       class C:
           def meth(self) -> int:
               return 0

       def func(x: Proto) -> int:
           return x.meth()

       func(C())  # Passes static type check

   See PEP 544 for details. Protocol classes decorated with
   @typing.runtime_checkable act as simple-minded runtime protocols that check
   only the presence of given attributes, ignoring their type signatures.
   Protocol classes can be generic, they are defined as::

       class GenProto[T](Protocol):
           def meth(self) -> T:
               ...


   .. py:attribute:: active_set
      :type:  set[doot.workflow._interface.TaskName_p | doot.workflow._interface.Artifact_i]

   
   .. py:method:: queue_entry(target: str | doot.workflow._interface.TaskName_p | doot.workflow._interface.Artifact_i, *, from_user: int | bool = False) -> jgdv.Maybe[Concrete[doot.workflow._interface.TaskName_p | doot.workflow._interface.Artifact_i]]



   
   .. py:method:: deque_entry(*, peek: bool = False) -> Concrete[doot.workflow._interface.TaskName_p] | doot.workflow._interface.Artifact_i



   
   .. py:method:: clear_queue() -> None



 

.. _doot.control.tracker._interface.WorkflowTracker_p:
  


.. py:class:: WorkflowTracker_p

   Bases: :py:obj:`Protocol` 
  
   Track tasks that have run, need to run, are running,
   and have failed.
   Does not execute anything itself


   .. py:property:: active
      :type: set[doot.workflow._interface.TaskName_p]


   .. py:property:: specs
      :type: dict[doot.workflow._interface.TaskName_p, SpecMeta_d]


   .. py:property:: artifacts
      :type: dict[doot.workflow._interface.Artifact_i, ArtifactMeta_d]


   .. py:property:: concrete
      :type: set[doot.workflow._interface.TaskName_p | doot.workflow._interface.Artifact_i]


   .. py:property:: abstract
      :type: set[doot.workflow._interface.TaskName_p | doot.workflow._interface.Artifact_i]


   .. py:property:: network
      :type: collections.abc.Mapping


   .. py:property:: is_valid
      :type: bool


   
   .. py:method:: register(*specs: doot.workflow._interface.TaskSpec_i | doot.workflow._interface.Artifact_i | doot.workflow._interface.DelayedSpec) -> None



   
   .. py:method:: queue(name: str | jgdv.Ident | Concrete[doot.workflow._interface.TaskSpec_i] | doot.workflow._interface.DelayedSpec, *, from_user: int | bool = False, status: jgdv.Maybe[doot.workflow._interface.TaskStatus_e] = None) -> jgdv.Maybe[Concrete[jgdv.Ident]]



   
   .. py:method:: build(*, sources: jgdv.Maybe[Literal[True] | list[Concrete[doot.workflow._interface.TaskName_p] | doot.workflow._interface.Artifact_i]] = None) -> None



   
   .. py:method:: plan(*, policy: jgdv.Maybe[ExecutionPolicy_e] = None) -> list[doot.workflow._interface.TaskName_p | doot.workflow._interface.Artifact_i]



   
   .. py:method:: next_for(target: jgdv.Maybe[str | Concrete[jgdv.Ident]] = None) -> jgdv.Maybe[doot.workflow._interface.Task_p | doot.workflow._interface.Artifact_i]



   
   .. py:method:: clear() -> None



   
   .. py:method:: _instantiate(name: Abstract[doot.workflow._interface.TaskName_p], *, extra: jgdv.Maybe[dict | jgdv.structs.chainguard.ChainGuard | bool] = None) -> jgdv.Maybe[Concrete[doot.workflow._interface.TaskName_p]]
                  _instantiate(rel: doot.workflow._interface.RelationSpec_i, *, control: Concrete[doot.workflow._interface.TaskName_p]) -> Concrete[doot.workflow._interface.TaskName_p]
                  _instantiate(name: Concrete[doot.workflow._interface.TaskName_p], **kwargs: Any) -> Concrete[doot.workflow._interface.TaskName_p]



   
   .. py:method:: _connect(left: Concrete[doot.workflow._interface.TaskName_p] | doot.workflow._interface.Artifact_i, right: jgdv.Maybe[Literal[False] | Concrete[doot.workflow._interface.TaskName_p] | doot.workflow._interface.Artifact_i] = None, **kwargs: Any) -> None



   
   .. py:method:: _dependency_states_of(focus: doot.workflow._interface.TaskName_p) -> list[tuple]



   
   .. py:method:: _successor_states_of(focus: doot.workflow._interface.TaskName_p) -> list[tuple]



 

.. _doot.control.tracker._interface.WorkflowTracker_i:
  


.. py:class:: WorkflowTracker_i

   Bases: :py:obj:`WorkflowTracker_p`, :py:obj:`Protocol` 
  
   Track tasks that have run, need to run, are running,
   and have failed.
   Does not execute anything itself


   .. py:attribute:: _root_node
      :type:  doot.workflow._interface.TaskName_p

   .. py:attribute:: _factory
      :type:  doot.workflow._interface.TaskFactory_p

   .. py:attribute:: _subfactory
      :type:  doot.workflow._interface.SubTaskFactory_p

   .. py:attribute:: _declare_priority
      :type:  int

   .. py:attribute:: _min_priority
      :type:  int

 

.. _doot.control.tracker._interface.SpecMeta_d:
  


.. py:class:: SpecMeta_d(*, spec: doot.workflow._interface.TaskSpec_i)

 
   Registry data for a spec.
   When spec is abstract, related are the concrete instantiations
   when spec is concrete, related are the implicit subtasks

   blocked_by are the dependencies not mentioned in the spec
   injection_source is the injection to run just before executing the task
   injection_targets are tasks that block this task cleaning up


   .. py:attribute:: spec
      :type:  doot.workflow._interface.TaskSpec_i

   .. py:attribute:: task
      :type:  doot.workflow._interface.Task_p | doot.workflow._interface.TaskStatus_e

   .. py:attribute:: related
      :type:  set[doot.workflow._interface.TaskName_p]

   .. py:attribute:: blocked_by
      :type:  set[doot.workflow._interface.TaskName_p | doot.workflow._interface.Artifact_i]

   .. py:attribute:: injection_source
      :type:  jgdv.Maybe[tuple[doot.workflow._interface.TaskName_p, doot.workflow._interface.InjectSpec_i]]

   .. py:attribute:: injection_targets
      :type:  set[doot.workflow._interface.TaskName_p]

 

.. _doot.control.tracker._interface.ArtifactMeta_d:
  


.. py:class:: ArtifactMeta_d(*, artifact: doot.workflow._interface.Artifact_i)

 

   .. py:attribute:: artifact
      :type:  doot.workflow._interface.Artifact_i

   .. py:attribute:: blocked_by
      :type:  set[doot.workflow._interface.TaskName_p | doot.workflow._interface.Artifact_i]

   .. py:attribute:: builders
      :type:  set[doot.workflow._interface.TaskName_p]

   .. py:attribute:: consumers
      :type:  set[doot.workflow._interface.TaskName_p]

 

.. _doot.control.tracker._interface.Registry_d:
  


.. py:class:: Registry_d(*, tracker: WorkflowTracker_p)

 

   .. py:attribute:: _tracker
      :type:  WorkflowTracker_p

   .. py:attribute:: specs
      :type:  dict[doot.workflow._interface.TaskName_p, SpecMeta_d]

   .. py:attribute:: artifacts
      :type:  dict[doot.workflow._interface.Artifact_i, ArtifactMeta_d]

   .. py:attribute:: abstract
      :type:  set[Abstract[doot.workflow._interface.TaskName_p] | doot.workflow._interface.Artifact_i]

   .. py:attribute:: concrete
      :type:  set[Abstract[doot.workflow._interface.TaskName_p] | doot.workflow._interface.Artifact_i]