.. _doot.control.tracker.registry:
  
=============================
doot.control.tracker.registry
=============================
  


.. py:module:: doot.control.tracker.registry

 






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

.. autoapisummary::

   doot.control.tracker.registry.Abstract







Classes
-------
  


.. autoapisummary::

    doot.control.tracker.registry._Registration_m
    doot.control.tracker.registry._Instantiation_m
    doot.control.tracker.registry._Verification_m
    doot.control.tracker.registry.TrackRegistry

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

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



.. doot.control.tracker.registry._Registration_m:
  


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

   Bases: :py:obj:`doot.control.tracker._interface.Registry_d` 
  

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


      Register task specs, abstract or concrete

      Does *not* handle any taskspec generation logic



   
   .. py:method:: _register_artifact(art: doot.workflow._interface.Artifact_i, *tasks: doot.workflow._interface.TaskName_p, relation: jgdv.Maybe[doot.workflow._interface.RelationMeta_e] = None) -> None



   
   .. py:method:: _register_spec_artifacts(spec: doot.workflow._interface.TaskSpec_i) -> None


      Register the artifacts a spec produces



   
   .. py:method:: _register_blocking_relations(spec: doot.workflow._interface.TaskSpec_i) -> None


      a Task[required_for=[x,y,z] blocks x,y,z,
      but if you just look at x,y,z, you can't know that.
      This is the reverse mapping to allow for that




   
   .. py:method:: _register_delayed_blockers(spec: doot.workflow._interface.TaskSpec_i) -> None



   
   .. py:method:: _register_late_injection(task: doot.workflow._interface.TaskName_p, inject: doot.workflow._interface.InjectSpec_i, parent: doot.workflow._interface.TaskName_p) -> None


      Register an injection to run on task initialisation,
      using the state injection's from its parent



   
   .. py:method:: _register_implicit_tasks(spec: doot.workflow._interface.TaskSpec_i) -> None



 

.. doot.control.tracker.registry._Instantiation_m:
  


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

   Bases: :py:obj:`doot.control.tracker._interface.Registry_d` 
  

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


      Convert an Asbtract Spec into a Concrete Spec,
        Reuses a existing concrete spec if possible.

      If force=True, forces a new instance to be made
      if force=False, blocks new instances from being made



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


      find a matching relation according to constraints,
          or create a new instance if theres no constraints/no match

      returns the concrete TaskName_p of the instanced target of the relation



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


      Build a Concrete Spec's Task object, then register it
      if a task_obj is provided, store that instead

      return the name of the task



   
   .. py:method:: _instantiate_implicit_tasks(name: doot.workflow._interface.TaskName_p) -> None



 

.. doot.control.tracker.registry._Verification_m:
  


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

   Bases: :py:obj:`doot.control.tracker._interface.Registry_d` 
  

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



 

.. _doot.control.tracker.registry.TrackRegistry:
  


.. py:class:: TrackRegistry(*args, **kwargs)

   Bases: :py:obj:`doot.control.tracker._interface.Registry_d` 
  
   Stores and manipulates specs, tasks, and artifacts


   .. py:attribute:: _delayed_blockers

   
   .. py:method:: get_status(target: Concrete[doot.workflow._interface.TaskName_p | doot.workflow._interface.Artifact_i]) -> tuple[doot.workflow._interface.TaskStatus_e | doot.workflow._interface.ArtifactStatus_e, int]


      Get the status of a target or artifact



   
   .. py:method:: set_status(target: Concrete[doot.workflow._interface.TaskName_p | doot.workflow._interface.Artifact_i], status: doot.workflow._interface.TaskStatus_e | doot.workflow._interface.ArtifactStatus_e) -> bool


      update the state of a task in the dependency graph
      Returns True on status update,
      False on no task or artifact to update.