Merge pull request #5 from ezmsg-org/dev

Minor docs fix and bump ezmsg dependency

Author: cboulay

docs/source/_templates/autosummary/module.rst

@@ -1,6 +1,7 @@
 {{ fullname | escape | underline}}
 
 .. automodule:: {{ fullname }}
+   :no-members:
 
    {% block attributes %}
    {% if attributes %}

pyproject.toml

@@ -12,7 +12,7 @@ readme = "README.md"
 requires-python = ">=3.10"
 dynamic = ["version"]
 dependencies = [
-  "ezmsg[axisarray]>=3.7.2",
+  "ezmsg[axisarray]>=3.7.3",
   "typing-extensions>=4.0.0",
 ]
 

src/ezmsg/baseproc/composite.py

@@ -171,21 +171,23 @@ class CompositeProcessor(
     typing.Generic[SettingsType, MessageInType, MessageOutType],
 ):
     """
-    A processor that chains multiple processor together in a feedforward non-branching graph.
+    A processor that chains multiple processors together in a feedforward non-branching graph.
     The individual processors may be stateless or stateful. The last processor may be a consumer,
-    otherwise processors must be transformers. Use CompositeProducer if you want the first
-    processor to be a producer. Concrete subclasses must implement `_initialize_processors`.
-    Optionally override `_reset_state` if you want adaptive state behaviour.
-    Example implementation:
-
-    class CustomCompositeProcessor(CompositeProcessor[CustomSettings, AxisArray, AxisArray]):
-        @staticmethod
-        def _initialize_processors(settings: CustomSettings) -> dict[str, BaseProcessor]:
-            return {
-                "stateful_transformer": CustomStatefulProducer(**settings),
-                "transformer": CustomTransformer(**settings),
-            }
-    Where **settings should be replaced with initialisation arguments for each processor.
+    otherwise processors must be transformers. Use ``CompositeProducer`` if you want the first
+    processor to be a producer. Concrete subclasses must implement ``_initialize_processors``.
+    Optionally override ``_reset_state`` if you want adaptive state behaviour.
+
+    Example implementation::
+
+        class CustomCompositeProcessor(CompositeProcessor[CustomSettings, AxisArray, AxisArray]):
+            @staticmethod
+            def _initialize_processors(settings: CustomSettings) -> dict[str, BaseProcessor]:
+                return {
+                    "stateful_transformer": CustomStatefulProducer(**settings),
+                    "transformer": CustomTransformer(**settings),
+                }
+
+    Where ``**settings`` should be replaced with initialisation arguments for each processor.
     """
 
     def __init__(self, *args, **kwargs) -> None:

src/ezmsg/baseproc/processor.py

@@ -45,11 +45,12 @@ class BaseProcessor(ABC, typing.Generic[SettingsType, MessageInType, MessageOutT
     """
     Base class for processors. You probably do not want to inherit from this class directly.
     Refer instead to the more specific base classes.
-      * Use :obj:`BaseConsumer` or :obj:`BaseTransformer` for ops that return a result or not, respectively.
-      * Use :obj:`BaseStatefulProcessor` and its children for operations that require state.
 
-    Note that `BaseProcessor` and its children are sync by default. If you need async by defualt, then
-    override the async methods and call them from the sync methods. Look to `BaseProducer` for examples of
+    * Use :obj:`BaseConsumer` or :obj:`BaseTransformer` for ops that return a result or not, respectively.
+    * Use :obj:`BaseStatefulProcessor` and its children for operations that require state.
+
+    Note that ``BaseProcessor`` and its children are sync by default. If you need async by default, then
+    override the async methods and call them from the sync methods. Look to ``BaseProducer`` for examples of
     calling async methods from sync methods.
     """
 

src/ezmsg/baseproc/units.py

@@ -179,24 +179,27 @@ class BaseTransformerUnit(
 ):
     """
     Base class for transformer units -- i.e. units that transform input messages into output messages.
-    Implement a new Unit as follows:
 
-    class CustomUnit(BaseTransformerUnit[
-        CustomTransformerSettings,    # SettingsType
-        AxisArray,                    # MessageInType
-        AxisArray,                    # MessageOutType
-        CustomTransformer,            # TransformerType
-    ]):
-        SETTINGS = CustomTransformerSettings
+    Implement a new Unit as follows::
+
+        class CustomUnit(BaseTransformerUnit[
+            CustomTransformerSettings,    # SettingsType
+            AxisArray,                    # MessageInType
+            AxisArray,                    # MessageOutType
+            CustomTransformer,            # TransformerType
+        ]):
+            SETTINGS = CustomTransformerSettings
 
     ... that's all!
 
-    Where CustomTransformerSettings and CustomTransformer are custom implementations of:
-    - ez.Settings for settings
+    Where ``CustomTransformerSettings`` and ``CustomTransformer`` are custom implementations of:
+
+    - ``ez.Settings`` for settings
     - One of these transformer types:
-      * BaseTransformer
-      * BaseStatefulTransformer
-      * CompositeProcessor
+
+      - ``BaseTransformer``
+      - ``BaseStatefulTransformer``
+      - ``CompositeProcessor``
     """
 
     INPUT_SIGNAL = ez.InputStream(MessageInType)

src/ezmsg/baseproc/util/typeresolution.py

@@ -50,17 +50,23 @@ def resolve_typevar(cls: type, target_typevar: typing.TypeVar) -> type:
 def check_message_type_compatibility(type1: TypeLike, type2: TypeLike) -> bool:
     """
     Check if two types are compatible for message passing.
+
     Returns True if:
+
     - Both are None/NoneType
     - Either is typing.Any
-    - type1 is a subclass of type2, which includes
-        - type1 and type2 are concrete types and type1 is a subclass of type2
-        - type1 is None/NoneType and type2 is typing.Optional, or
-        - type1 is subtype of the non-None inner type of type2 if type2 is Optional
+    - type1 is a subclass of type2, which includes:
+
+      - type1 and type2 are concrete types and type1 is a subclass of type2
+      - type1 is None/NoneType and type2 is typing.Optional, or
+      - type1 is subtype of the non-None inner type of type2 if type2 is Optional
+
     - type1 is a Union/Optional type and all inner types are compatible with type2
+
     Args:
         type1: First type to compare
         type2: Second type to compare
+
     Returns:
         bool: True if the types are compatible, False otherwise
     """