ezmsg-baseproc 1.2.0__tar.gz → 1.3.0__tar.gz

{ezmsg_baseproc-1.2.0 → ezmsg_baseproc-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ezmsg-baseproc
-Version: 1.2.0
+Version: 1.3.0
 Summary: Base processor classes and protocols for ezmsg signal processing pipelines
 Author-email: Griffin Milsap <griffin.milsap@gmail.com>, Preston Peranich <pperanich@gmail.com>, Chadwick Boulay <chadwick.boulay@gmail.com>, Kyle McGraw <kmcgraw@blackrockneuro.com>
 License-Expression: MIT

{ezmsg_baseproc-1.2.0 → ezmsg_baseproc-1.3.0}/docs/source/guides/ProcessorsBase.md

@@ -80,9 +80,9 @@ do not inherit from `BaseStatefulProcessor` and `BaseStatefulProducer`. They acc
 | 3   | `BaseConsumerUnit`             | 1       | `ConsumerType`             |
 | 4   | `BaseTransformerUnit`          | 1       | `TransformerType`          |
 | 5   | `BaseAdaptiveTransformerUnit`  | 1       | `AdaptiveTransformerType`  |
-| 6   | `BaseClockDrivenProducerUnit`  | 1       | `ClockDrivenProducerType`  |
+| 6   | `BaseClockDrivenUnit`  | 1       | `ClockDrivenProducerType`  |
 
-Note, it is strongly recommended to use `BaseConsumerUnit`, `BaseTransformerUnit`, `BaseAdaptiveTransformerUnit`, or `BaseClockDrivenProducerUnit` for implementing concrete subclasses rather than `BaseProcessorUnit`.
+Note, it is strongly recommended to use `BaseConsumerUnit`, `BaseTransformerUnit`, `BaseAdaptiveTransformerUnit`, or `BaseClockDrivenUnit` for implementing concrete subclasses rather than `BaseProcessorUnit`.
 
 
 ## Implementing a custom standalone processor

{ezmsg_baseproc-1.2.0 → ezmsg_baseproc-1.3.0}/docs/source/guides/how-tos/processors/clockdriven.rst

@@ -42,7 +42,7 @@ Here's a complete example of a sine wave generator:
 
     from ezmsg.baseproc import (
         BaseClockDrivenProducer,
-        BaseClockDrivenProducerUnit,
+        BaseClockDrivenUnit,
         ClockDrivenSettings,
         ClockDrivenState,
         processor_state,
@@ -124,7 +124,7 @@ Here's a complete example of a sine wave generator:
 
 
     class SinGeneratorUnit(
-        BaseClockDrivenProducerUnit[SinGeneratorSettings, SinGenerator]
+        BaseClockDrivenUnit[SinGeneratorSettings, SinGenerator]
     ):
         """
         ezmsg Unit wrapper for SinGenerator.

{ezmsg_baseproc-1.2.0 → ezmsg_baseproc-1.3.0}/src/ezmsg/baseproc/__init__.py

@@ -82,7 +82,7 @@ from .stateful import (
 from .units import (
     AdaptiveTransformerType,
     BaseAdaptiveTransformerUnit,
-    BaseClockDrivenProducerUnit,
+    BaseClockDrivenUnit,
     BaseConsumerUnit,
     BaseProcessorUnit,
     BaseProducerUnit,
@@ -158,7 +158,7 @@ __all__ = [
     "BaseConsumerUnit",
     "BaseTransformerUnit",
     "BaseAdaptiveTransformerUnit",
-    "BaseClockDrivenProducerUnit",
+    "BaseClockDrivenUnit",
     "GenAxisArray",
     # Type resolution helpers
     "get_base_producer_type",

{ezmsg_baseproc-1.2.0 → ezmsg_baseproc-1.3.0}/src/ezmsg/baseproc/__version__.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.2.0'
-__version_tuple__ = version_tuple = (1, 2, 0)
+__version__ = version = '1.3.0'
+__version_tuple__ = version_tuple = (1, 3, 0)
 
 __commit_id__ = commit_id = None

{ezmsg_baseproc-1.2.0 → ezmsg_baseproc-1.3.0}/src/ezmsg/baseproc/counter.py

@@ -9,7 +9,7 @@ from .clockdriven import (
     ClockDrivenState,
 )
 from .protocols import processor_state
-from .units import BaseClockDrivenProducerUnit
+from .units import BaseClockDrivenUnit
 
 
 class CounterSettings(ClockDrivenSettings):
@@ -57,7 +57,7 @@ class CounterTransformer(BaseClockDrivenProducer[CounterSettings, CounterTransfo
         )
 
 
-class Counter(BaseClockDrivenProducerUnit[CounterSettings, CounterTransformer]):
+class Counter(BaseClockDrivenUnit[CounterSettings, CounterTransformer]):
     """
     Transforms clock ticks into monotonically increasing counter values as AxisArray.
 

{ezmsg_baseproc-1.2.0 → ezmsg_baseproc-1.3.0}/src/ezmsg/baseproc/protocols.py

@@ -5,8 +5,7 @@ import typing
 from dataclasses import dataclass
 
 import ezmsg.core as ez
-
-from .util.message import SampleMessage
+from ezmsg.util.messages.axisarray import AxisArray
 
 # --- Processor state decorator ---
 processor_state = functools.partial(dataclass, unsafe_hash=True, frozen=False, init=False)
@@ -138,7 +137,7 @@ class StatefulTransformer(
 
 
 class AdaptiveTransformer(StatefulTransformer, typing.Protocol):
-    def partial_fit(self, message: SampleMessage) -> None:
+    def partial_fit(self, message: AxisArray) -> None:
         """Update transformer state using labeled training data.
 
         This method should update the internal state/parameters of the transformer
@@ -146,4 +145,4 @@ class AdaptiveTransformer(StatefulTransformer, typing.Protocol):
         """
         ...
 
-    async def apartial_fit(self, message: SampleMessage) -> None: ...
+    async def apartial_fit(self, message: AxisArray) -> None: ...

{ezmsg_baseproc-1.2.0 → ezmsg_baseproc-1.3.0}/src/ezmsg/baseproc/stateful.py

@@ -4,6 +4,9 @@ import pickle
 import typing
 from abc import ABC, abstractmethod
 
+from ezmsg.util.messages.axisarray import AxisArray
+from ezmsg.util.messages.util import replace
+
 from .processor import (
     BaseProcessor,
     BaseProducer,
@@ -256,7 +259,7 @@ class BaseStatefulTransformer(
 class BaseAdaptiveTransformer(
     BaseStatefulTransformer[
         SettingsType,
-        MessageInType | SampleMessage,
+        MessageInType,
         MessageOutType | None,
         StateType,
     ],
@@ -264,30 +267,41 @@ class BaseAdaptiveTransformer(
     typing.Generic[SettingsType, MessageInType, MessageOutType, StateType],
 ):
     @abstractmethod
-    def partial_fit(self, message: SampleMessage) -> None: ...
+    def partial_fit(self, message: AxisArray) -> None: ...
 
-    async def apartial_fit(self, message: SampleMessage) -> None:
+    async def apartial_fit(self, message: AxisArray) -> None:
         """Override me if you need async partial fitting."""
         return self.partial_fit(message)
 
-    def __call__(self, message: MessageInType | SampleMessage) -> MessageOutType | None:
+    def __call__(self, message: MessageInType) -> MessageOutType | None:
         """
         Adapt transformer with training data (and optionally labels)
-        in SampleMessage
+        in AxisArray with attrs["trigger"].
 
         Args:
-            message: An instance of SampleMessage with optional
-             labels (y) in message.trigger.value.data and
-             data (X) in message.sample.data
+            message: An AxisArray with optional trigger in attrs["trigger"],
+             containing labels (y) in attrs["trigger"].value and
+             data (X) in message.data
 
         Returns: None
         """
         if is_sample_message(message):
+            if isinstance(message, SampleMessage):
+                # Auto-convert old format → new format
+                message = replace(
+                    message.sample,
+                    attrs={**message.sample.attrs, "trigger": message.trigger},
+                )
             return self.partial_fit(message)
         return super().__call__(message)
 
-    async def __acall__(self, message: MessageInType | SampleMessage) -> MessageOutType | None:
+    async def __acall__(self, message: MessageInType) -> MessageOutType | None:
         if is_sample_message(message):
+            if isinstance(message, SampleMessage):
+                message = replace(
+                    message.sample,
+                    attrs={**message.sample.attrs, "trigger": message.trigger},
+                )
             return await self.apartial_fit(message)
         return await super().__acall__(message)
 

{ezmsg_baseproc-1.2.0 → ezmsg_baseproc-1.3.0}/src/ezmsg/baseproc/units.py

@@ -3,10 +3,10 @@
 import math
 import traceback
 import typing
+import warnings
 from abc import ABC, abstractmethod
 
 import ezmsg.core as ez
-from ezmsg.util.generator import GenState
 from ezmsg.util.messages.axisarray import AxisArray, LinearAxis
 
 from .clockdriven import BaseClockDrivenProducer
@@ -14,7 +14,6 @@ from .composite import CompositeProcessor
 from .processor import BaseConsumer, BaseProducer, BaseTransformer
 from .protocols import MessageInType, MessageOutType, SettingsType
 from .stateful import BaseAdaptiveTransformer, BaseStatefulConsumer, BaseStatefulTransformer
-from .util.message import SampleMessage
 from .util.profile import profile_subpub
 from .util.typeresolution import resolve_typevar
 
@@ -223,7 +222,7 @@ class BaseAdaptiveTransformerUnit(
     ABC,
     typing.Generic[SettingsType, MessageInType, MessageOutType, AdaptiveTransformerType],
 ):
-    INPUT_SAMPLE = ez.InputStream(SampleMessage)
+    INPUT_SAMPLE = ez.InputStream(AxisArray)
     INPUT_SIGNAL = ez.InputStream(MessageInType)
     OUTPUT_SIGNAL = ez.OutputStream(MessageOutType)
 
@@ -242,11 +241,11 @@ class BaseAdaptiveTransformerUnit(
             yield self.OUTPUT_SIGNAL, result
 
     @ez.subscriber(INPUT_SAMPLE)
-    async def on_sample(self, msg: SampleMessage) -> None:
+    async def on_sample(self, msg: AxisArray) -> None:
         await self.processor.apartial_fit(msg)
 
 
-class BaseClockDrivenProducerUnit(
+class BaseClockDrivenUnit(
     BaseProcessorUnit[SettingsType],
     ABC,
     typing.Generic[SettingsType, ClockDrivenProducerType],
@@ -260,7 +259,7 @@ class BaseClockDrivenProducerUnit(
 
     Implement a new Unit as follows::
 
-        class SinGeneratorUnit(BaseClockDrivenProducerUnit[
+        class SinGeneratorUnit(BaseClockDrivenUnit[
             SinGeneratorSettings,     # SettingsType (must extend ClockDrivenSettings)
             SinProducer,              # ClockDrivenProducerType
         ]):
@@ -287,10 +286,42 @@ class BaseClockDrivenProducerUnit(
             yield self.OUTPUT_SIGNAL, result
 
 
-# Legacy class
+class GenState(ez.State):
+    """
+    .. deprecated::
+        ``GenState`` is deprecated. Define a local state class or use
+        ``ezmsg.baseproc`` processor classes instead.
+    """
+
+    gen: typing.Generator[typing.Any, typing.Any, None]
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        warnings.warn(
+            "GenState is deprecated. Define a local state class instead of subclassing GenState.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+
 class GenAxisArray(ez.Unit):
+    """
+    .. deprecated::
+        ``GenAxisArray`` is deprecated. Use ``BaseTransformerUnit`` or
+        ``BaseAdaptiveTransformerUnit`` from ``ezmsg.baseproc`` instead.
+    """
+
     STATE = GenState
 
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        warnings.warn(
+            "GenAxisArray is deprecated. Use BaseTransformerUnit or "
+            "BaseAdaptiveTransformerUnit from ezmsg.baseproc instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
     INPUT_SIGNAL = ez.InputStream(AxisArray)
     OUTPUT_SIGNAL = ez.OutputStream(AxisArray)
     INPUT_SETTINGS = ez.InputStream(ez.Settings)

{ezmsg_baseproc-1.2.0 → ezmsg_baseproc-1.3.0}/src/ezmsg/baseproc/util/message.py

@@ -1,5 +1,6 @@
 import time
 import typing
+import warnings
 from dataclasses import dataclass, field
 
 from ezmsg.util.messages.axisarray import AxisArray
@@ -19,13 +20,28 @@ class SampleTriggerMessage:
 
 @dataclass
 class SampleMessage:
+    """
+    .. deprecated::
+        ``SampleMessage`` is deprecated. Use ``AxisArray`` with
+        ``attrs={"trigger": SampleTriggerMessage(...)}`` instead.
+    """
+
     trigger: SampleTriggerMessage
     """The time, window, and value (if any) associated with the trigger."""
 
     sample: AxisArray
     """The data sampled around the trigger."""
 
+    def __post_init__(self):
+        warnings.warn(
+            "SampleMessage is deprecated. Use AxisArray with " "attrs={'trigger': SampleTriggerMessage(...)} instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
 
-def is_sample_message(message: typing.Any) -> typing.TypeGuard[SampleMessage]:
-    """Check if the message is a SampleMessage."""
-    return hasattr(message, "trigger")
+def is_sample_message(message: typing.Any) -> bool:
+    """Detect old SampleMessage OR new AxisArray-with-trigger."""
+    if isinstance(message, SampleMessage):
+        return True
+    return isinstance(message, AxisArray) and "trigger" in getattr(message, "attrs", {})

ezmsg_baseproc-1.3.0/tests/conftest.py

@@ -0,0 +1,18 @@
+"""pytest configuration for ezmsg-baseproc tests."""
+
+import os
+import sys
+
+import pytest
+
+# Add tests directory to path so 'tests.helpers' can be imported
+_tests_dir = os.path.dirname(__file__)
+_parent_dir = os.path.dirname(_tests_dir)
+if _parent_dir not in sys.path:
+    sys.path.insert(0, _parent_dir)
+
+
+@pytest.fixture
+def test_name(request):
+    """Provide the test name to test functions."""
+    return request.node.name

ezmsg_baseproc-1.3.0/tests/helpers/util.py

@@ -0,0 +1,24 @@
+import os
+import tempfile
+from pathlib import Path
+
+
+def get_test_fn(test_name: str | None = None, extension: str = "txt") -> Path:
+    """PYTEST compatible temporary test file creator"""
+
+    # Get current test name if we can..
+    if test_name is None:
+        test_name = os.environ.get("PYTEST_CURRENT_TEST")
+        if test_name is not None:
+            test_name = test_name.split(":")[-1].split(" ")[0]
+        else:
+            test_name = __name__
+
+    file_path = Path(tempfile.gettempdir())
+    file_path = file_path / Path(f"{test_name}.{extension}")
+
+    # Create the file
+    with open(file_path, "w"):
+        pass
+
+    return file_path

{ezmsg_baseproc-1.2.0 → ezmsg_baseproc-1.3.0}/tests/test_baseproc.py

@@ -3,11 +3,11 @@
 import dataclasses
 import pickle
 from types import NoneType
-from typing import Any, Generator
-from unittest.mock import MagicMock
+from typing import Any
 
+import numpy as np
 import pytest
-from ezmsg.util.generator import consumer
+from ezmsg.util.messages.axisarray import AxisArray
 
 from ezmsg.baseproc import (
     BaseAdaptiveTransformer,
@@ -22,7 +22,7 @@ from ezmsg.baseproc import (
     BaseTransformer,
     CompositeProcessor,
     CompositeProducer,
-    SampleMessage,
+    SampleTriggerMessage,
     _get_base_processor_message_in_type,
     _get_base_processor_message_out_type,
     _get_base_processor_settings_type,
@@ -136,11 +136,11 @@ class MockAdaptiveTransformer(BaseAdaptiveTransformer[MockSettings, MockMessageA
     def _reset_state(self, message: MockMessageA) -> None:
         self._state.iterations = 0
 
-    def _process(self, message: MockMessageA | SampleMessage) -> MockMessageB:
+    def _process(self, message: MockMessageA) -> MockMessageB:
         self._state.iterations += 1
         return MockMessageB()
 
-    def partial_fit(self, message: SampleMessage) -> None:
+    def partial_fit(self, message: AxisArray) -> None:
         self._state.iterations += 1
 
 
@@ -251,18 +251,18 @@ class ChainedCompositeProcessorWithDeepProcessors(CompositeProcessor[MockSetting
         }
 
 
-@consumer
-def mock_generator() -> Generator[MockMessageA, MockMessageA, None]:
-    """A mock generator function for testing purposes."""
-    while True:
-        yield MockMessageA()
+class MockGeneratorTransformer(BaseTransformer[MockSettings, MockMessageA, MockMessageA]):
+    """A mock transformer replacing the legacy @consumer generator."""
+
+    def _process(self, message: MockMessageA) -> MockMessageA:
+        return MockMessageA()
 
 
 class MockGeneratorCompositeProcessor(CompositeProcessor[MockSettings, MockMessageA, MockMessageB]):
     @staticmethod
     def _initialize_processors(settings):
         return {
-            "generator": mock_generator(),
+            "generator": MockGeneratorTransformer(settings=settings),
             "stateful_processor": MockStatefulProcessor(settings=settings),
         }
 
@@ -333,27 +333,26 @@ class ChainedCompositeProducerWithDeepProcessors(CompositeProducer[MockSettings,
         }
 
 
-@consumer
-def mock_producer_generator() -> Generator[MockMessageA, None, None]:
-    """A mock generator function for testing purposes."""
-    while True:
-        yield MockMessageA()
+class MockGeneratorProducer(BaseProducer[MockSettings, MockMessageA]):
+    """A mock producer replacing the legacy @consumer producer generator."""
+
+    async def _produce(self) -> MockMessageA:
+        return MockMessageA()
+
 
+class MockGeneratorPassthroughTransformer(BaseTransformer[MockSettings, MockMessageA, MockMessageA]):
+    """A mock transformer replacing the legacy unprimed generator."""
 
-def mock_generator_unprimed() -> Generator[MockMessageA, MockMessageA, None]:
-    """A mock generator function for testing purposes."""
-    output = MockMessageA()
-    while True:
-        input = yield output
-        output = input or output
+    def _process(self, message: MockMessageA) -> MockMessageA:
+        return message or MockMessageA()
 
 
 class MockGeneratorCompositeProducer(CompositeProducer[MockSettings, MockMessageB]):
     @staticmethod
     def _initialize_processors(settings):
         return {
-            "generator": mock_producer_generator(),
-            "mock_generator_unprimed": mock_generator_unprimed(),
+            "generator": MockGeneratorProducer(settings=settings),
+            "mock_generator_passthrough": MockGeneratorPassthroughTransformer(settings=settings),
             "stateful_processor": MockStatefulProcessor(settings=settings),
         }
 
@@ -758,10 +757,13 @@ class TestBaseStatefulTransformer:
         assert new_state[0].iterations == 1
 
 
-# Mock SampleMessage for testing BaseAdaptiveTransformer
+# Helper to create an AxisArray with trigger in attrs for testing BaseAdaptiveTransformer
 def mock_sample_message():
-    sample_message = MagicMock(spec=SampleMessage)
-    return sample_message
+    return AxisArray(
+        data=np.zeros((1, 1)),
+        dims=["time", "ch"],
+        attrs={"trigger": SampleTriggerMessage()},
+    )
 
 
 class TestBaseAdaptiveTransformer:
@@ -778,9 +780,7 @@ class TestBaseAdaptiveTransformer:
 
     def test_call_with_sample_message(self):
         transformer = MockAdaptiveTransformer()
-        # Create a sample message with a trigger attribute
         sample_msg = mock_sample_message()
-        setattr(sample_msg, "trigger", None)
         result = transformer(sample_msg)
         assert result is None  # partial_fit returns None
         assert transformer.state.iterations == 1

ezmsg_baseproc-1.3.0/tests/test_clock_counter_system.py

@@ -0,0 +1,229 @@
+"""Integration tests for Clock and Counter ezmsg systems."""
+
+import math
+import os
+from dataclasses import field
+
+import ezmsg.core as ez
+import numpy as np
+import pytest
+from ezmsg.util.messagecodec import message_log
+from ezmsg.util.messagelogger import MessageLogger, MessageLoggerSettings
+from ezmsg.util.messages.axisarray import AxisArray
+from ezmsg.util.terminate import TerminateOnTotal, TerminateOnTotalSettings
+
+from ezmsg.baseproc import (
+    Clock,
+    ClockSettings,
+    Counter,
+    CounterSettings,
+)
+from tests.helpers.util import get_test_fn
+
+
+class ClockTestSystemSettings(ez.Settings):
+    clock_settings: ClockSettings
+    log_settings: MessageLoggerSettings
+    term_settings: TerminateOnTotalSettings = field(default_factory=TerminateOnTotalSettings)
+
+
+class ClockTestSystem(ez.Collection):
+    SETTINGS = ClockTestSystemSettings
+
+    CLOCK = Clock()
+    LOG = MessageLogger()
+    TERM = TerminateOnTotal()
+
+    def configure(self) -> None:
+        self.CLOCK.apply_settings(self.SETTINGS.clock_settings)
+        self.LOG.apply_settings(self.SETTINGS.log_settings)
+        self.TERM.apply_settings(self.SETTINGS.term_settings)
+
+    def network(self) -> ez.NetworkDefinition:
+        return (
+            (self.CLOCK.OUTPUT_SIGNAL, self.LOG.INPUT_MESSAGE),
+            (self.LOG.OUTPUT_MESSAGE, self.TERM.INPUT_MESSAGE),
+        )
+
+
+@pytest.mark.parametrize("dispatch_rate", [math.inf, 2.0, 20.0])
+def test_clock_system(
+    dispatch_rate: float,
+    test_name: str | None = None,
+):
+    run_time = 1.0
+    n_target = 100 if math.isinf(dispatch_rate) else int(np.ceil(dispatch_rate * run_time))
+    test_filename = get_test_fn(test_name)
+    ez.logger.info(test_filename)
+    settings = ClockTestSystemSettings(
+        clock_settings=ClockSettings(dispatch_rate=dispatch_rate),
+        log_settings=MessageLoggerSettings(output=test_filename),
+        term_settings=TerminateOnTotalSettings(total=n_target),
+    )
+    system = ClockTestSystem(settings)
+    ez.run(SYSTEM=system)
+
+    # Collect result
+    messages = list(message_log(test_filename))
+    os.remove(test_filename)
+
+    # Clock produces LinearAxis with gain and offset
+    assert all(isinstance(m, AxisArray.LinearAxis) for m in messages)
+    assert len(messages) >= n_target
+
+
+class CounterTestSystemSettings(ez.Settings):
+    clock_settings: ClockSettings
+    counter_settings: CounterSettings
+    log_settings: MessageLoggerSettings
+    term_settings: TerminateOnTotalSettings = field(default_factory=TerminateOnTotalSettings)
+
+
+class CounterTestSystem(ez.Collection):
+    """Counter must be driven by Clock in the new architecture."""
+
+    SETTINGS = CounterTestSystemSettings
+
+    CLOCK = Clock()
+    COUNTER = Counter()
+    LOG = MessageLogger()
+    TERM = TerminateOnTotal()
+
+    def configure(self) -> None:
+        self.CLOCK.apply_settings(self.SETTINGS.clock_settings)
+        self.COUNTER.apply_settings(self.SETTINGS.counter_settings)
+        self.LOG.apply_settings(self.SETTINGS.log_settings)
+        self.TERM.apply_settings(self.SETTINGS.term_settings)
+
+    def network(self) -> ez.NetworkDefinition:
+        return (
+            (self.CLOCK.OUTPUT_SIGNAL, self.COUNTER.INPUT_CLOCK),
+            (self.COUNTER.OUTPUT_SIGNAL, self.LOG.INPUT_MESSAGE),
+            (self.LOG.OUTPUT_MESSAGE, self.TERM.INPUT_MESSAGE),
+        )
+
+
+@pytest.mark.parametrize(
+    "n_time, fs, dispatch_rate, mod",
+    [
+        (1, 10.0, math.inf, None),  # AFAP mode
+        (20, 1000.0, 50.0, None),  # Realtime mode (50 Hz dispatch = 20 samples/tick @ 1000 Hz)
+        (1, 1000.0, 100.0, 2**3),  # 100 Hz dispatch with mod
+        (10, 10.0, 10.0, 2**3),  # 10 Hz dispatch with mod
+    ],
+)
+def test_counter_system(
+    n_time: int,
+    fs: float,
+    dispatch_rate: float,
+    mod: int | None,
+    test_name: str | None = None,
+):
+    target_dur = 2.6  # 2.6 seconds per test
+    if math.isinf(dispatch_rate):
+        # AFAP mode - runs as fast as possible
+        target_messages = 100  # Fixed target for AFAP
+    else:
+        target_messages = int(target_dur * dispatch_rate)
+
+    test_filename = get_test_fn(test_name)
+    ez.logger.info(test_filename)
+    settings = CounterTestSystemSettings(
+        clock_settings=ClockSettings(dispatch_rate=dispatch_rate),
+        counter_settings=CounterSettings(
+            n_time=n_time,
+            fs=fs,
+            mod=mod,
+        ),
+        log_settings=MessageLoggerSettings(
+            output=test_filename,
+        ),
+        term_settings=TerminateOnTotalSettings(
+            total=target_messages,
+        ),
+    )
+    system = CounterTestSystem(settings)
+    ez.run(SYSTEM=system)
+
+    # Collect result
+    messages: list[AxisArray] = [_ for _ in message_log(test_filename)]
+    os.remove(test_filename)
+
+    if math.isinf(dispatch_rate):
+        # The number of messages depends on how fast the computer is
+        target_messages = len(messages)
+    # This should be an equivalence assertion (==) but the use of TerminateOnTotal does
+    #  not guarantee that MessageLogger will exit before an additional message is received.
+    #  Let's just clip the last message if we exceed the target messages.
+    if len(messages) > target_messages:
+        messages = messages[:target_messages]
+    assert len(messages) >= target_messages
+
+    # Just do one quick data check (Counter now outputs 1D array)
+    agg = AxisArray.concatenate(*messages, dim="time")
+    target_samples = n_time * target_messages
+    expected_data = np.arange(target_samples)
+    if mod is not None:
+        expected_data = expected_data % mod
+    assert np.array_equal(agg.data, expected_data)
+
+
+@pytest.mark.parametrize(
+    "clock_rate, fs, n_time",
+    [
+        (10.0, 1000.0, 100),  # 10 Hz clock, fs=1000, n_time=100 (fixed)
+        (20.0, 500.0, None),  # 20 Hz clock, fs=500, n_time derived (25 samples per tick)
+        (5.0, 1000.0, None),  # 5 Hz clock, fs=1000, n_time derived (200 samples per tick)
+    ],
+)
+def test_counter_with_external_clock(
+    clock_rate: float,
+    fs: float,
+    n_time: int | None,
+    test_name: str | None = None,
+):
+    """Test Counter driven by external Clock (now the standard pattern)."""
+    target_messages = 20
+    test_filename = get_test_fn(test_name)
+    ez.logger.info(test_filename)
+
+    # This now uses the same CounterTestSystem since all counters need clocks
+    settings = CounterTestSystemSettings(
+        clock_settings=ClockSettings(dispatch_rate=clock_rate),
+        counter_settings=CounterSettings(
+            fs=fs,
+            n_time=n_time,
+        ),
+        log_settings=MessageLoggerSettings(output=test_filename),
+        term_settings=TerminateOnTotalSettings(total=target_messages),
+    )
+    system = CounterTestSystem(settings)
+    ez.run(SYSTEM=system)
+
+    # Collect result
+    messages: list[AxisArray] = [_ for _ in message_log(test_filename)]
+    os.remove(test_filename)
+
+    assert len(messages) >= target_messages
+
+    # Verify each message has correct sample rate (gain = 1/fs)
+    for msg in messages:
+        assert msg.axes["time"].gain == 1.0 / fs
+
+    # Verify data continuity
+    messages = messages[:target_messages]  # Trim to target
+    agg = AxisArray.concatenate(*messages, dim="time")
+
+    # Expected samples per tick
+    if n_time is not None:
+        expected_samples_per_tick = n_time
+    else:
+        expected_samples_per_tick = int(fs / clock_rate)
+
+    expected_total = expected_samples_per_tick * target_messages
+    # Allow for fractional sample accumulation variance
+    assert abs(len(agg.data) - expected_total) <= target_messages
+
+    # Counter values should be sequential (0, 1, 2, ...)
+    expected_data = np.arange(len(agg.data))
+    assert np.array_equal(agg.data, expected_data)