wavekit 0.7.2__tar.gz → 0.8.0__tar.gz

wavekit-0.8.0/PKG-INFO

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: wavekit
+Version: 0.8.0
+Summary: High-level digital waveform analysis in Python
+License-File: LICENSE
+Author: cxzzzz
+Author-email: cxz19961010@outlook.com
+Requires-Python: >=3.9,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: lark (>=1.2,<2)
+Requires-Dist: numpy (>=2.0.0,<3.0.0)
+Requires-Dist: wavekit-pywellen (>=0.25.6)
+Project-URL: Documentation, https://cxzzzz.github.io/wavekit
+Project-URL: Repository, https://github.com/cxzzzz/wavekit
+Description-Content-Type: text/markdown
+
+# <img src="docs/en/images/logo.svg" alt="" width="30" height="30" valign="middle"> wavekit
+
+[![CI](https://github.com/cxzzzz/wavekit/actions/workflows/python-package.yml/badge.svg)](https://github.com/cxzzzz/wavekit/actions/workflows/python-package.yml)
+[![PyPI version](https://img.shields.io/pypi/v/wavekit.svg)](https://pypi.org/project/wavekit/)
+[![Python Versions](https://img.shields.io/pypi/pyversions/wavekit.svg)](https://pypi.org/project/wavekit/)
+[![Downloads](https://pepy.tech/badge/wavekit)](https://pepy.tech/project/wavekit)
+[![License](https://img.shields.io/github/license/cxzzzz/wavekit.svg)](LICENSE)
+
+English | [中文](README_ZH.md)
+
+**Wavekit is a Python library for high-level digital waveform analysis.**
+It loads signals from waveform files as clock-aligned `Waveform` objects,
+allowing users to query and operate on them at the cycle and transaction levels,
+making complex hardware behavior easier to analyze.
+
+> **AI integration:** [wavekit-mcp](https://github.com/cxzzzz/wavekit-mcp) exposes wavekit analysis through
+> MCP tools for AI-assisted workflows.
+
+## Features
+
+- **Flexible signal queries:** find and batch-load related signals from
+  hierarchical waveform data using multiple path-matching options.
+- **Cycle-level analysis:** use a range of waveform operations on clock-sampled
+  data to analyze cycle-based behavior such as interface backpressure and FIFO
+  occupancy.
+- **Transaction-level analysis:** use temporal pattern matching to describe
+  signal relationships across multiple clock cycles for protocol analysis,
+  transaction extraction, and latency measurement.
+- **Multi-format waveform support:** load and analyze VCD, FST, and FSDB files
+  using the same API.
+
+## Installation
+
+```console
+python -m pip install wavekit
+```
+
+wavekit supports Python 3.9 and newer. FSDB support requires the Verdi NPI
+runtime (`libNPI.so`); see the [installation guide](https://cxzzzz.github.io/wavekit/getting-started/installation/) for
+setup details.
+
+## Quick start
+
+Calculate the occupancy of a FIFO from a VCD waveform:
+
+```python
+import numpy as np
+
+from wavekit import VcdReader
+
+with VcdReader('simulation.vcd') as r:
+    fifo = r['tb.u_fifo']
+    with r.clock_domain(clock='tb.clk'):
+        w_ptr = fifo['w_ptr'].w
+        r_ptr = fifo['r_ptr'].w
+
+    depth = 16
+    occupancy = (w_ptr + depth - r_ptr) % depth
+
+    print('Average occupancy:', np.mean(occupancy.value))
+```
+
+See the [first waveform tutorial](https://cxzzzz.github.io/wavekit/getting-started/first-waveform/) for a
+complete runnable FIFO example.
+
+## Documentation
+
+See the [documentation](https://cxzzzz.github.io/wavekit/) for the full reference and guides:
+
+- [Installation](https://cxzzzz.github.io/wavekit/getting-started/installation/)
+- [First waveform](https://cxzzzz.github.io/wavekit/getting-started/first-waveform/)
+- [Reader guide](https://cxzzzz.github.io/wavekit/guides/reader/)
+- [Signal queries](https://cxzzzz.github.io/wavekit/guides/signal-query/)
+- [Waveform analysis](https://cxzzzz.github.io/wavekit/guides/waveform-analysis/)
+- [Pattern matching](https://cxzzzz.github.io/wavekit/guides/pattern-matching/)
+- [API reference](https://cxzzzz.github.io/wavekit/reference/api/)
+- [Complete examples](https://cxzzzz.github.io/wavekit/examples/)
+
+## Development
+
+Install the development dependencies and run the checks with Poetry:
+
+```console
+poetry install
+poetry run pytest
+poetry run ruff check .
+poetry run ruff format --check .
+poetry run mypy
+```
+
+Build the documentation locally with Python 3.10 or newer:
+
+```console
+poetry install --with docs
+poetry run zensical build --clean --strict
+```
+
+See [Contributing](https://cxzzzz.github.io/wavekit/contributing/) for contribution guidelines.
+
+## License
+
+This project is licensed under the MIT License. See [LICENSE](LICENSE).
+

wavekit-0.8.0/README.md

@@ -0,0 +1,102 @@
+# <img src="docs/en/images/logo.svg" alt="" width="30" height="30" valign="middle"> wavekit
+
+[![CI](https://github.com/cxzzzz/wavekit/actions/workflows/python-package.yml/badge.svg)](https://github.com/cxzzzz/wavekit/actions/workflows/python-package.yml)
+[![PyPI version](https://img.shields.io/pypi/v/wavekit.svg)](https://pypi.org/project/wavekit/)
+[![Python Versions](https://img.shields.io/pypi/pyversions/wavekit.svg)](https://pypi.org/project/wavekit/)
+[![Downloads](https://pepy.tech/badge/wavekit)](https://pepy.tech/project/wavekit)
+[![License](https://img.shields.io/github/license/cxzzzz/wavekit.svg)](LICENSE)
+
+English | [中文](README_ZH.md)
+
+**Wavekit is a Python library for high-level digital waveform analysis.**
+It loads signals from waveform files as clock-aligned `Waveform` objects,
+allowing users to query and operate on them at the cycle and transaction levels,
+making complex hardware behavior easier to analyze.
+
+> **AI integration:** [wavekit-mcp](https://github.com/cxzzzz/wavekit-mcp) exposes wavekit analysis through
+> MCP tools for AI-assisted workflows.
+
+## Features
+
+- **Flexible signal queries:** find and batch-load related signals from
+  hierarchical waveform data using multiple path-matching options.
+- **Cycle-level analysis:** use a range of waveform operations on clock-sampled
+  data to analyze cycle-based behavior such as interface backpressure and FIFO
+  occupancy.
+- **Transaction-level analysis:** use temporal pattern matching to describe
+  signal relationships across multiple clock cycles for protocol analysis,
+  transaction extraction, and latency measurement.
+- **Multi-format waveform support:** load and analyze VCD, FST, and FSDB files
+  using the same API.
+
+## Installation
+
+```console
+python -m pip install wavekit
+```
+
+wavekit supports Python 3.9 and newer. FSDB support requires the Verdi NPI
+runtime (`libNPI.so`); see the [installation guide](https://cxzzzz.github.io/wavekit/getting-started/installation/) for
+setup details.
+
+## Quick start
+
+Calculate the occupancy of a FIFO from a VCD waveform:
+
+```python
+import numpy as np
+
+from wavekit import VcdReader
+
+with VcdReader('simulation.vcd') as r:
+    fifo = r['tb.u_fifo']
+    with r.clock_domain(clock='tb.clk'):
+        w_ptr = fifo['w_ptr'].w
+        r_ptr = fifo['r_ptr'].w
+
+    depth = 16
+    occupancy = (w_ptr + depth - r_ptr) % depth
+
+    print('Average occupancy:', np.mean(occupancy.value))
+```
+
+See the [first waveform tutorial](https://cxzzzz.github.io/wavekit/getting-started/first-waveform/) for a
+complete runnable FIFO example.
+
+## Documentation
+
+See the [documentation](https://cxzzzz.github.io/wavekit/) for the full reference and guides:
+
+- [Installation](https://cxzzzz.github.io/wavekit/getting-started/installation/)
+- [First waveform](https://cxzzzz.github.io/wavekit/getting-started/first-waveform/)
+- [Reader guide](https://cxzzzz.github.io/wavekit/guides/reader/)
+- [Signal queries](https://cxzzzz.github.io/wavekit/guides/signal-query/)
+- [Waveform analysis](https://cxzzzz.github.io/wavekit/guides/waveform-analysis/)
+- [Pattern matching](https://cxzzzz.github.io/wavekit/guides/pattern-matching/)
+- [API reference](https://cxzzzz.github.io/wavekit/reference/api/)
+- [Complete examples](https://cxzzzz.github.io/wavekit/examples/)
+
+## Development
+
+Install the development dependencies and run the checks with Poetry:
+
+```console
+poetry install
+poetry run pytest
+poetry run ruff check .
+poetry run ruff format --check .
+poetry run mypy
+```
+
+Build the documentation locally with Python 3.10 or newer:
+
+```console
+poetry install --with docs
+poetry run zensical build --clean --strict
+```
+
+See [Contributing](https://cxzzzz.github.io/wavekit/contributing/) for contribution guidelines.
+
+## License
+
+This project is licensed under the MIT License. See [LICENSE](LICENSE).

wavekit-0.7.2/build.py → wavekit-0.8.0/build_exts.py

@@ -1,3 +1,5 @@
+import os
+import sys
 from pathlib import Path
 
 import numpy as np
@@ -7,22 +9,37 @@ from setuptools import Extension, setup
 for artifact in Path('src/wavekit').glob('**/*.so'):
     artifact.unlink()
 
+if os.environ.get('PYODIDE'):
+    compile_args = ['-fpic', '-O3']
+    link_args = ['-O3']
+    fsdb_libraries = []
+elif sys.platform == 'linux':
+    compile_args = ['-fpic', '-O3']
+    link_args = ['-O3']
+    fsdb_libraries = ['dl']
+elif sys.platform == 'darwin':
+    compile_args = ['-fpic', '-O3']
+    link_args = ['-O3']
+    fsdb_libraries = []
+else:
+    raise RuntimeError(f'Unsupported platform: {sys.platform}')
+
 extensions = [
     Extension(
         'wavekit.readers.value_change',
         sources=['src/wavekit/readers/value_change.pyx'],
         include_dirs=[np.get_include()],
-        extra_compile_args=['-fpic', '-O3', '-march=native'],
-        extra_link_args=['-O3', '-march=native'],
+        extra_compile_args=compile_args,
+        extra_link_args=link_args,
         language='c++',
     ),
     Extension(
         'wavekit.readers.fsdb.npi_fsdb_reader',
         sources=['src/wavekit/readers/fsdb/npi_fsdb_reader.pyx'],
         include_dirs=[np.get_include()],
-        libraries=['dl'],
-        extra_compile_args=['-fpic', '-O3', '-march=native'],
-        extra_link_args=['-O3', '-march=native'],
+        libraries=fsdb_libraries,
+        extra_compile_args=compile_args,
+        extra_link_args=link_args,
         language='c++',
     ),
 ]

{wavekit-0.7.2 → wavekit-0.8.0}/pyproject.toml

@@ -1,11 +1,12 @@
 [tool.poetry]
 name = "wavekit"
-version = "0.7.2"
-description = "a fundamental package for digital circuit waveform analysis"
+version = "0.8.0"
+description = "High-level digital waveform analysis in Python"
 authors = ["cxzzzz <cxz19961010@outlook.com>"]
 readme = "README.md"
 repository = "https://github.com/cxzzzz/wavekit"
-build = "build.py"
+documentation = "https://cxzzzz.github.io/wavekit"
+build = "build_exts.py"
 include = [
     { path = "src/wavekit/**/*.so", format = "wheel" },
 ]
@@ -13,15 +14,19 @@ include = [
 [tool.poetry.dependencies]
 python = "^3.9"
 numpy = "^2.0.0"
-vcdvcd = "^2.3.5"
-pylibfst = "^0.2.1"
-pytest = "^8.2.2"
+wavekit-pywellen = ">=0.25.6"
 lark = ">=1.2,<2"
 
 [tool.poetry.group.dev.dependencies]
+pytest = "^8.2.2"
 ruff = "^0.6.2"
 mypy = "^1.11.2"
 
+
+[tool.poetry.group.docs.dependencies]
+zensical = {version = "^0.0.57", python = ">=3.10,<4.0"}
+mkdocstrings-python = {version = "1.18.2", python = ">=3.10,<4.0"}
+
 [tool.ruff]
 target-version = "py39"
 line-length = 100

{wavekit-0.7.2 → wavekit-0.8.0}/src/wavekit/__init__.py

@@ -9,6 +9,7 @@ try:
 except metadata.PackageNotFoundError:
     __version__ = 'unknown'
 
+from .readers.clock_domain import ClockDomain as ClockDomain
 from .readers.fst.reader import FstReader as FstReader
 from .readers.hierarchy import Node as Node
 from .readers.hierarchy import Scope as Scope
@@ -16,7 +17,6 @@ from .readers.hierarchy import Signal as Signal
 from .readers.hierarchy import SignalCompositeType as SignalCompositeType
 from .readers.matcher import BraceCapture as BraceCapture
 from .readers.matcher import Capture as Capture
-from .readers.matcher import CaptureKey as CaptureKey
 from .readers.matcher import ExactCapture as ExactCapture
 from .readers.matcher import RegexCapture as RegexCapture
 from .readers.matcher import WildcardCapture as WildcardCapture
@@ -29,13 +29,13 @@ __all__ = [
     'VcdReader',
     'FsdbReader',
     'FstReader',
+    'ClockDomain',
     'Node',
     'Scope',
     'Range',
     'Signal',
     'SignalCompositeType',
     'Capture',
-    'CaptureKey',
     'ExactCapture',
     'BraceCapture',
     'RegexCapture',

{wavekit-0.7.2 → wavekit-0.8.0}/src/wavekit/expression.py

@@ -149,7 +149,7 @@ def evaluate_expression(expr: str, namespace: dict[str, Any]) -> Any:
     Parameters
     ----------
     expr:
-        The substituted expression returned by :func:`parse_expression`.
+        The substituted expression returned by ``parse_expression``.
         Physical paths must be resolved and replaced before calling this
         function.
     namespace:

{wavekit-0.7.2 → wavekit-0.8.0}/src/wavekit/pattern/compiler.py

@@ -28,7 +28,7 @@ from .steps import (
 def infer_declarative_axis(steps: list[Step]) -> Waveform | None:
     """Infer a minimal first-static-waveform scan axis hint from steps."""
     # Axis inference is intentionally minimal.  It only finds a static waveform
-    # so start/end_cycle can be translated to indices; full clock alignment
+    # so start/end_cycle can be translated to indices; full cycle-axis alignment
     # validation remains lazy in PatternRuntime.note_waveform().
     for step in steps:
         if isinstance(step, (WaitStep, ConsumeStep)):

{wavekit-0.7.2 → wavekit-0.8.0}/src/wavekit/pattern/dsl.py

@@ -28,8 +28,8 @@ class Pattern:
     """Declarative temporal pattern builder over waveform signals.
 
     Build steps with ``Pattern().wait(...).capture(...)`` and execute with
-    module-level :func:`match`. ``Pattern`` stores only the declarative step AST;
-    programmable checking/extraction uses :func:`match(body)` or :func:`collect(body)`.
+    module-level ``match``. ``Pattern`` stores only the declarative step AST;
+    programmable checking/extraction uses ``match(body)`` or ``collect(body)``.
 
     The first blocking step selects candidate start cycles. Later blocking steps
     wait within a matched transaction.
@@ -77,7 +77,10 @@ class Pattern:
     def consume(
         self,
         cond: Waveform | Callable[[int, dict[str, Any]], bool] | bool,
-        channel: Channel | Hashable | Callable[[int, dict[str, Any]], Channel | Hashable],
+        channel: Channel
+        | Hashable
+        | Callable[[int, dict[str, Any]], Channel | Hashable]
+        | None = None,
         *,
         require: Waveform | Callable[[int, dict[str, Any]], bool] | bool | None = None,
         require_message: str | Callable[[int, dict[str, Any]], str] | None = None,
@@ -93,10 +96,11 @@ class Pattern:
             cycle number. ``captures`` is the current match's capture dict.
         channel:
             ``Channel``, hashable key, or ``callable(index, captures) -> Channel | Hashable``.
-            Channel callbacks use the same ``(index, captures)`` arguments.
-            The resolved ``(channel, cycle)`` can be claimed by at most one match;
-            earlier start cycles win. This does not reserve the channel while
-            ``cond`` is false.
+            If omitted, this consume step receives a private channel created when
+            the step is declared. Channel callbacks use the same ``(index, captures)``
+            arguments. The resolved ``(channel, cycle)`` can be claimed by at most
+            one match; earlier start cycles win. This does not reserve the channel
+            while ``cond`` is false.
         require:
             Optional condition checked while ``cond`` is false, or while ``cond`` is
             true but the current ``(channel, cycle)`` was already claimed. It is not
@@ -110,9 +114,13 @@ class Pattern:
         Pattern
             This pattern, for chaining.
         """
+        resolved_channel = Channel() if channel is None else channel
         self._steps.append(
             ConsumeStep(
-                cond=cond, channel=channel, require=require, require_message=require_message
+                cond=cond,
+                channel=resolved_channel,
+                require=require,
+                require_message=require_message,
             )
         )
         return self
@@ -235,7 +243,7 @@ class Pattern:
         Notes
         -----
         Exactly one of ``until`` and ``when`` is required. Conditions use the same
-        ``Waveform`` / ``bool`` / callable forms as :meth:`wait`.
+        ``Waveform`` / ``bool`` / callable forms as ``wait``.
         """
         if until is not None and when is not None:
             raise ValueError("Cannot specify both 'until' and 'when' in loop()")

{wavekit-0.7.2 → wavekit-0.8.0}/src/wavekit/pattern/result.py

@@ -19,14 +19,18 @@ class MatchStatus:
 
     @dataclass(frozen=True)
     class OK(MatchStatusValue):
-        pass
+        """Successful completion of a pattern candidate."""
 
     @dataclass(frozen=True)
     class Timeout(MatchStatusValue):
+        """A pattern candidate did not complete within its allowed duration."""
+
         message: str | None = None
 
     @dataclass(frozen=True)
     class RequireViolated(MatchStatusValue):
+        """A non-blocking ``require`` check failed."""
+
         message: str | None = None
 
 
@@ -81,7 +85,7 @@ class MatchRecords(Sequence[MatchRecord]):
     """Columnar batch of pattern match records.
 
     ``start`` and ``end`` are point waveforms: ``.value`` stores waveform-array
-    sample indices, ``.clock`` stores absolute cycle numbers, and ``.time`` stores
+    sample indices, ``.cycle`` stores absolute cycle numbers, and ``.time`` stores
     simulation timestamps. ``duration.value`` is ``end.value - start.value + 1``.
     """
 
@@ -112,7 +116,7 @@ class MatchRecords(Sequence[MatchRecord]):
         value = np.array(
             [isinstance(status, MatchStatus.OK) for status in self.status.value], dtype=bool
         )
-        return Waveform(value, self.start.clock.copy(), self.start.time.copy(), width=1)
+        return Waveform(value, self.start.cycle.copy(), self.start.time.copy(), width=1)
 
     @property
     def failed(self) -> Waveform:
@@ -127,7 +131,7 @@ class MatchRecords(Sequence[MatchRecord]):
         value = np.array(
             [not isinstance(status, MatchStatus.OK) for status in self.status.value], dtype=bool
         )
-        return Waveform(value, self.start.clock.copy(), self.start.time.copy(), width=1)
+        return Waveform(value, self.start.cycle.copy(), self.start.time.copy(), width=1)
 
     def filter_ok(self) -> MatchRecords:
         """Return records whose status is ``MatchStatus.OK``.
@@ -215,12 +219,12 @@ class MatchRecords(Sequence[MatchRecord]):
         return MatchRecord(
             start=MatchPoint(
                 index=int(self.start.value[index]),
-                cycle=int(self.start.clock[index]),
+                cycle=int(self.start.cycle[index]),
                 time=int(self.start.time[index]),
             ),
             end=MatchPoint(
                 index=int(self.end.value[index]),
-                cycle=int(self.end.clock[index]),
+                cycle=int(self.end.cycle[index]),
                 time=int(self.end.time[index]),
             ),
             status=self.status.value[index],

{wavekit-0.7.2 → wavekit-0.8.0}/src/wavekit/pattern/runtime.py

@@ -37,7 +37,7 @@ class PatternContext:
 
     Programmable bodies run once per scanned start cycle. Use ``ctx.value(...)``
     to read waveforms, ``ctx.wait(...)`` / ``ctx.consume(...)`` / ``ctx.delay(...)``
-    to move through time, and return ``ctx.OK`` from :func:`wavekit.pattern.match`
+    to move through time, and return ``ctx.OK`` from ``wavekit.pattern.match``
     bodies to record a successful match.
     """
 
@@ -121,7 +121,7 @@ class PatternContext:
         Parameters
         ----------
         waveform:
-            Waveform to read. It must share the same clock axis as other observed
+            Waveform to read. It must share the same cycle axis as other observed
             pattern waveforms.
         offset:
             Relative sample offset from ``ctx.index``. ``0`` reads the current
@@ -142,17 +142,17 @@ class PatternContext:
         Parameters
         ----------
         waveform:
-            Waveform whose clock axis is read and validated.
+            Waveform whose cycle axis is read and validated.
         offset:
             Relative sample offset from ``ctx.index``.
 
         Returns
         -------
         Any
-            Scalar value from ``waveform.clock[ctx.index + offset]``.
+            Scalar value from ``waveform.cycle[ctx.index + offset]``.
         """
         index = self._waveform_index(waveform, offset)
-        return waveform.clock[index]
+        return waveform.cycle[index]
 
     def time(self, waveform: Waveform, offset: int = 0) -> Any:
         """Return a waveform timestamp at the current sample plus *offset*.
@@ -400,14 +400,14 @@ class PatternRuntime:
         if self._start_cycle is None:
             return 0
         axis = self._require_axis()
-        return int(np.searchsorted(axis.clock, self._start_cycle))
+        return int(np.searchsorted(axis.cycle, self._start_cycle))
 
     @cached_property
     def scan_end_index(self) -> int:
         axis = self._require_axis()
         if self._end_cycle is None:
             return len(axis.value)
-        return int(np.searchsorted(axis.clock, self._end_cycle))
+        return int(np.searchsorted(axis.cycle, self._end_cycle))
 
     def match(self, start_cycle: int | None = None, end_cycle: int | None = None) -> MatchRecords:
         completed = self._run(start_cycle, end_cycle)
@@ -426,20 +426,20 @@ class PatternRuntime:
                 continue
             raise PatternError(
                 f'Pattern failed with {inst.status}; '
-                f'start_cycle={axis.clock[inst.start_index]}, '
-                f'failure_cycle={axis.clock[inst.end_index]}'
+                f'start_cycle={axis.cycle[inst.start_index]}, '
+                f'failure_cycle={axis.cycle[inst.end_index]}'
             )
         return [inst.return_value for inst in completed if inst.return_value is not None]
 
     def _records(self, completed: list[PatternInstance]) -> MatchRecords:
         axis = self._require_axis()
-        completed.sort(key=lambda i: (int(axis.clock[i.start_index]), i.order))
+        completed.sort(key=lambda i: (int(axis.cycle[i.start_index]), i.order))
         start_index_arr = np.array([i.start_index for i in completed], dtype=np.int64)
         end_index_arr = np.array([i.end_index for i in completed], dtype=np.int64)
         start_cycle_arr = np.array(
-            [int(axis.clock[i.start_index]) for i in completed], dtype=np.int64
+            [int(axis.cycle[i.start_index]) for i in completed], dtype=np.int64
         )
-        end_cycle_arr = np.array([int(axis.clock[i.end_index]) for i in completed], dtype=np.int64)
+        end_cycle_arr = np.array([int(axis.cycle[i.end_index]) for i in completed], dtype=np.int64)
         start_time_arr = np.array(
             [int(axis.time[i.start_index]) for i in completed], dtype=np.int64
         )
@@ -493,10 +493,10 @@ class PatternRuntime:
             self._axis = waveform
             self._validated_waveform_ids.add(waveform_id)
             return
-        if len(waveform.clock) != len(self._axis.clock):
-            raise PatternError('Waveform clock arrays have different lengths')
-        if not np.array_equal(waveform.clock, self._axis.clock):
-            raise PatternError('Waveform clock arrays are not aligned')
+        if len(waveform.cycle) != len(self._axis.cycle):
+            raise PatternError('Waveform cycle arrays have different lengths')
+        if not np.array_equal(waveform.cycle, self._axis.cycle):
+            raise PatternError('Waveform cycle arrays are not aligned')
         self._validated_waveform_ids.add(waveform_id)
 
     def resolve_channel(

wavekit-0.8.0/src/wavekit/readers/__init__.py

@@ -0,0 +1 @@
+"""Waveform reader backends and hierarchy types."""