.. _jgdv._abstract.protocols.general:
   
    
================================
jgdv._abstract.protocols.general
================================
  

   
.. py:module:: jgdv._abstract.protocols.general

       
 

   
 

 

 
   
        

           

 
 

 
 

Protocols
---------

.. autoapisummary::

   jgdv._abstract.protocols.general.ActionGrouper_p
   jgdv._abstract.protocols.general.ArtifactStruct_p
   jgdv._abstract.protocols.general.Buildable_p
   jgdv._abstract.protocols.general.DILogger_p
   jgdv._abstract.protocols.general.ExecutableTask
   jgdv._abstract.protocols.general.Factory_p
   jgdv._abstract.protocols.general.FailHandler_p
   jgdv._abstract.protocols.general.InstantiableSpecification_p
   jgdv._abstract.protocols.general.Loader_p
   jgdv._abstract.protocols.general.Nameable_p
   jgdv._abstract.protocols.general.Persistent_p
   jgdv._abstract.protocols.general.SpecStruct_p
   jgdv._abstract.protocols.general.StubStruct_p
   jgdv._abstract.protocols.general.TomlStubber_p
   jgdv._abstract.protocols.general.UpToDate_p
   jgdv._abstract.protocols.general.Visitor_p

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

 
 

.. _jgdv._abstract.protocols.general.ActionGrouper_p:
   
.. py:class:: ActionGrouper_p
   
   Bases: :py:obj:`Protocol` 
     
   For things have multiple named groups of actions

   
      
   .. py:method:: get_group(name) -> <Unknown>
      


 
 
 

.. _jgdv._abstract.protocols.general.ArtifactStruct_p:
   
.. py:class:: ArtifactStruct_p
   
   Bases: :py:obj:`Protocol` 
     
   Base class for artifacts, for type matching

   
      
   .. py:method:: exists(*, data=None) -> <Unknown>
      


 
 
 

.. _jgdv._abstract.protocols.general.Buildable_p:
   
.. py:class:: Buildable_p
   
   Bases: :py:obj:`Protocol` 
     
   For things that need building, but don't have a separate factory
   TODO add type parameter

   
      
   .. py:method:: build(*args) -> <Unknown>
      :classmethod:
      


 
 
 

.. _jgdv._abstract.protocols.general.DILogger_p:
   
.. py:class:: DILogger_p
   
   Bases: :py:obj:`Protocol` 
     
   Protocol for classes with a dependency injectable logger

   
      
   .. py:method:: logger() -> <Unknown>
      


 
 
 

.. _jgdv._abstract.protocols.general.ExecutableTask:
   
.. py:class:: ExecutableTask
   
   Bases: :py:obj:`Protocol` 
     
   Runners pass off to Tasks/Jobs implementing this protocol
   instead of using their default logic

   
      
   .. py:method:: check_entry() -> <Unknown>
      


      
   .. py:method:: current_priority() -> <Unknown>
      


      
   .. py:method:: current_status() -> <Unknown>
      


      
   .. py:method:: decrement_priority() -> <Unknown>
      


      
   .. py:method:: execute() -> <Unknown>
      


      
   .. py:method:: execute_action() -> <Unknown>
      


      
   .. py:method:: execute_action_group(group_name) -> <Unknown>
      


      
   .. py:method:: expand() -> <Unknown>
      


      
   .. py:method:: force_status(status) -> <Unknown>
      


      
   .. py:method:: setup() -> <Unknown>
      


      
   .. py:method:: teardown() -> <Unknown>
      


 
 
 

.. _jgdv._abstract.protocols.general.Factory_p:
   
.. py:class:: Factory_p
   
   Bases: :py:obj:`Protocol` 
     
   Factory protocol: {type}.build

   
      
   .. py:method:: build(*args, **kwargs) -> <Unknown>
      :classmethod:
      


 
 
 

.. _jgdv._abstract.protocols.general.FailHandler_p:
   
.. py:class:: FailHandler_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:: handle_failure(err, *args, **kwargs) -> <Unknown>
      


 
 
 

.. _jgdv._abstract.protocols.general.InstantiableSpecification_p:
   
.. py:class:: InstantiableSpecification_p
   
   Bases: :py:obj:`Protocol` 
     
   A Specification that can be instantiated further

   
      
   .. py:method:: instantiate_onto(data) -> <Unknown>
      


      
   .. py:method:: make() -> <Unknown>
      


 
 
 

.. _jgdv._abstract.protocols.general.Loader_p:
   
.. py:class:: Loader_p
   
   Bases: :py:obj:`Protocol` 
     
   The protocol for something that will load something from the system, a file, etc
   TODO add a type parameter

   
      
   .. py:method:: load() -> <Unknown>
      


      
   .. py:method:: setup(extra_config) -> <Unknown>
      


 
 
 

.. _jgdv._abstract.protocols.general.Nameable_p:
   
.. py:class:: Nameable_p
   
   Bases: :py:obj:`Protocol` 
     
   The core protocol of something use as a name

   
 
 
 

.. _jgdv._abstract.protocols.general.Persistent_p:
   
.. py:class:: Persistent_p
   
   Bases: :py:obj:`Protocol` 
     
   A Protocol for persisting data

   
      
   .. py:method:: read(target) -> <Unknown>
      


      
   .. py:method:: write(target) -> <Unknown>
      


 
 
 

.. _jgdv._abstract.protocols.general.SpecStruct_p:
   
.. py:class:: SpecStruct_p
   
   Bases: :py:obj:`Protocol` 
     
   Base class for specs, for type matching

   
   .. py:property:: args
      :type: list


   .. py:property:: kwargs
      :type: dict


   .. py:property:: params
      :type: dict | ChainGuard


 
 
 

.. _jgdv._abstract.protocols.general.StubStruct_p:
   
.. py:class:: StubStruct_p
   
   Bases: :py:obj:`Protocol` 
     
   Base class for stubs, for type matching

   
      
   .. py:method:: to_toml() -> <Unknown>
      


 
 
 

.. _jgdv._abstract.protocols.general.TomlStubber_p:
   
.. py:class:: TomlStubber_p
   
   Bases: :py:obj:`Protocol` 
     
   Something that can be turned into toml

   
      
   .. py:method:: class_help() -> <Unknown>
      :classmethod:
      


      
   .. py:method:: stub_class(stub) -> <Unknown>
      :classmethod:
      


      
   .. py:method:: stub_instance(stub) -> <Unknown>
      


   .. py:property:: doc
      :type: list[str]


   .. py:property:: short_doc
      :type: str


 
 
 

.. _jgdv._abstract.protocols.general.UpToDate_p:
   
.. py:class:: UpToDate_p
   
   Bases: :py:obj:`Protocol` 
     
   For things (often artifacts) which might need to have actions done if they were created too long ago

   
      
   .. py:method:: is_stale(*, other = None) -> <Unknown>
      


 
 
 

.. _jgdv._abstract.protocols.general.Visitor_p:
   
.. py:class:: Visitor_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:: visit(**kwargs) -> <Unknown>