primitive 0.1.37__py3-none-any.whl → 0.1.39__py3-none-any.whl

primitive/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2024-present Dylan Stein <dylan@primitive.tech>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "0.1.37"
+__version__ = "0.1.39"

primitive/agent/actions.py

@@ -1,4 +1,3 @@
-import platform
 import sys
 import shutil
 from pathlib import Path
@@ -8,6 +7,7 @@ from loguru import logger
 from primitive.__about__ import __version__
 import yaml
 from ..utils.yaml import generate_script_from_yaml
+from ..utils.cache import get_sources_cache
 
 try:
     from yaml import CLoader as Loader
@@ -16,22 +16,6 @@ except ImportError:
 
 
 class Agent(BaseAction):
-    def set_cache_dir(self):
-        os_family = platform.system()
-
-        if os_family == "Darwin":
-            self.cache_dir = Path(
-                Path.home() / "Library" / "Caches" / "tech.primitive.agent"
-            )
-        elif os_family == "Linux":
-            self.cache_dir = Path(Path.home() / ".cache" / "primitive")
-        elif os_family == "Windows":
-            raise NotImplementedError("Windows is not currently supported.")
-            self.cache_dir = None
-
-        if not self.cache_dir.exists():
-            self.cache_dir.mkdir(parents=True, exist_ok=True)
-
     def execute(
         self,
     ):
@@ -40,7 +24,7 @@ class Agent(BaseAction):
         logger.info(f" [*] Version: {__version__}")
 
         # Create cache dir if it doesnt exist
-        self.set_cache_dir()
+        cache_dir = get_sources_cache()
 
         # self.primitive.hardware.update_hardware_system_info()
         try:
@@ -127,7 +111,7 @@ class Agent(BaseAction):
                             git_repo_full_name=git_repo_full_name,
                             git_ref=git_ref,
                             github_access_token=github_access_token,
-                            destination=self.cache_dir,
+                            destination=cache_dir,
                         )
                     )
 

primitive/lint/actions.py

@@ -5,6 +5,7 @@ from typing import Tuple
 from loguru import logger
 from ..utils.files import find_files_for_extension
 from ..utils.verible import install_verible
+from ..utils.cache import get_deps_cache
 
 
 class Lint(BaseAction):
@@ -17,20 +18,31 @@ class Lint(BaseAction):
             return False, message
 
         logger.debug("Checking if verible is installed")
+        verible_path = Path("verible-verilog-lint")
         try:
-            subprocess.run(["verible-verilog-lint", "--version"], capture_output=True)
+            subprocess.run([str(verible_path), "--version"], capture_output=True)
         except FileNotFoundError:
-            logger.debug("Did not find verible. Installing...")
-            try:
-                system_info = self.primitive.hardware.get_system_info()
-                install_verible(system_info=system_info)
-            except Exception as exception:
-                message = f"Failed to install verible. {exception}"
-                logger.error(message)
-                return False, message
+            logger.debug("Verible not found in $PATH. Looking in deps cache...")
+            cache_dir = get_deps_cache()
+
+            possible_dirs = cache_dir.glob("verible*")
+            verible_dir = next(possible_dirs, None)
+
+            if verible_dir is not None:
+                verible_path = verible_dir / "bin" / verible_path
+            else:
+                logger.debug("Did not find verible. Installing...")
+                try:
+                    system_info = self.primitive.hardware.get_system_info()
+                    verible_bin = install_verible(system_info=system_info)
+                    verible_path = verible_bin / verible_path
+                except Exception as exception:
+                    message = f"Failed to install verible. {exception}"
+                    logger.error(message)
+                    return False, message
 
         try:
-            subprocess.run(["verible-verilog-lint", "--version"], capture_output=True)
+            subprocess.run([str(verible_path), "--version"], capture_output=True)
         except FileNotFoundError:
             message = "Verible is not installed. Please install it to run lint."
             logger.error(message)
@@ -40,7 +52,7 @@ class Lint(BaseAction):
         # run is great for now! we will need to switch to Popen if we want to stream the output
         logger.debug("Running linter...")
         result = subprocess.run(
-            ["verible-verilog-lint", *files],
+            [str(verible_path), *files],
             capture_output=True,
             text=True,
         )
@@ -56,7 +68,7 @@ class Lint(BaseAction):
 
         if result.returncode != 0:
             if not self.primitive.DEBUG:
-                message = result.stderr
+                message = result.stdout + result.stderr
             return (False, message)
         else:
             message = "Linting successful."

primitive/utils/cache.py

@@ -0,0 +1,41 @@
+import platform
+from pathlib import Path
+
+
+def get_cache_dir() -> Path:
+    os_family = platform.system()
+
+    cache_dir = None
+    if os_family == "Darwin":
+        cache_dir = Path(Path.home() / "Library" / "Caches" / "tech.primitive.agent")
+    elif os_family == "Linux":
+        cache_dir = Path(Path.home() / ".cache" / "primitive")
+    elif os_family == "Windows":
+        raise NotImplementedError("Windows is not currently supported.")
+
+    if not cache_dir.exists():
+        cache_dir.mkdir(parents=True, exist_ok=True)
+
+    return cache_dir
+
+
+def get_sources_cache() -> Path:
+    cache_dir = get_cache_dir()
+
+    sources_dir = cache_dir / "sources"
+
+    if not sources_dir.exists():
+        sources_dir.mkdir(parents=True, exist_ok=True)
+
+    return sources_dir
+
+
+def get_deps_cache() -> Path:
+    cache_dir = get_cache_dir()
+
+    deps_dir = cache_dir / "deps"
+
+    if not deps_dir.exists():
+        deps_dir.mkdir(parents=True, exist_ok=True)
+
+    return deps_dir

primitive/utils/verible.py

@@ -1,7 +1,7 @@
 import tarfile
 import requests
 from .shell import add_path_to_shell
-from pathlib import Path
+from .cache import get_deps_cache
 
 from loguru import logger
 
@@ -12,7 +12,7 @@ VERIBLE_LINUX_X86_64_OS_LINK = "https://github.com/chipsalliance/verible/release
 VERIBLE_LINUX_ARM64_LINK = "https://github.com/chipsalliance/verible/releases/download/v0.0-3752-g8b64887e/verible-v0.0-3752-g8b64887e-linux-static-arm64.tar.gz"
 
 
-def install_verible(system_info: dict) -> bool:
+def install_verible(system_info: dict) -> str:
     url = None
     if system_info.get("os_family") == "Darwin":
         url = VERIBLE_MAC_OS_LINK
@@ -23,8 +23,10 @@ def install_verible(system_info: dict) -> bool:
     elif system_info.get("processor") == "arm":
         url = VERIBLE_LINUX_X86_64_OS_LINK
 
+    deps_cache = get_deps_cache()
+
     verible_dir_name = url.split("/")[-1].split(".tar.gz")[0]
-    file_download_path = Path.home() / f"{verible_dir_name}.tar.gz"
+    file_download_path = deps_cache / f"{verible_dir_name}.tar.gz"
 
     logger.debug("Downloading verible")
     response = requests.get(url, stream=True)
@@ -38,7 +40,7 @@ def install_verible(system_info: dict) -> bool:
 
     logger.debug("Untaring verible")
     with tarfile.open(file_download_path) as tar:
-        tar.extractall(Path.home())
+        tar.extractall(deps_cache)
 
     logger.debug("Deleting tar.gz artifact")
     file_download_path.unlink()
@@ -47,9 +49,9 @@ def install_verible(system_info: dict) -> bool:
     if "linux" in unpacked_verible_dir_name:
         unpacked_verible_dir_name = unpacked_verible_dir_name.split("-linux")[0]
 
-    verible_bin = Path.home().joinpath(unpacked_verible_dir_name).joinpath("bin")
+    verible_bin = deps_cache.joinpath(unpacked_verible_dir_name).joinpath("bin")
 
     logger.debug("Adding verible to PATH")
     add_path_to_shell(verible_bin)
 
-    return True
+    return verible_bin

{primitive-0.1.37.dist-info → primitive-0.1.39.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: primitive
-Version: 0.1.37
+Version: 0.1.39
 Project-URL: Documentation, https://github.com//primitivecorp/primitive-cli#readme
 Project-URL: Issues, https://github.com//primitivecorp/primitive-cli/issues
 Project-URL: Source, https://github.com//primitivecorp/primitive-cli

{primitive-0.1.37.dist-info → primitive-0.1.39.dist-info}/RECORD

@@ -1,8 +1,8 @@
-primitive/__about__.py,sha256=87MHpnCo7NoJcs8kmPjMM3csVpyyNkb4ert2iQ2G_X8,130
+primitive/__about__.py,sha256=_BMdl-E4C928TL5DMNPwXGZXZshwzVn9FoCKsCYkjoM,130
 primitive/__init__.py,sha256=bwKdgggKNVssJFVPfKSxqFMz4IxSr54WWbmiZqTMPNI,106
 primitive/cli.py,sha256=VQPSewC6ouGdEG9W1gllawGJTydpOY0Lzg7LURXcqQg,2374
 primitive/client.py,sha256=SFPG4H2wJao8euGdnYp-l7dk_fDpWeVn2aT2WNJUAqo,2370
-primitive/agent/actions.py,sha256=qFrJmsvZWTtmk9_dsDUuD84LQyd6lqZL7GlEw0eFEco,9020
+primitive/agent/actions.py,sha256=cxavCfRG76KJ6M-FVwg3htMbJLz16gUjy30h-vsJ7A0,8468
 primitive/agent/commands.py,sha256=-dVDilELfkGfbZB7qfEPs77Dm1oT62qJj4tsIk4KoxI,254
 primitive/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 primitive/auth/actions.py,sha256=N2bGcwXNsB89pzs66gF9A5_WzUScY5fhfOyWixqo2y8,1054
@@ -22,7 +22,7 @@ primitive/hardware/actions.py,sha256=JJXEeW35QzVGcLN4ym5gYZwY71hxLzM1GYPXWaObEts
 primitive/hardware/commands.py,sha256=QE7LLeFdfOqlvz3JwdwJJRZAY3fHI1zB9kYmmDajpq0,1477
 primitive/jobs/actions.py,sha256=LpUJN-GOiDSehQANfV_F86eRRKPZ2ew9skKdnlalXU4,7734
 primitive/jobs/commands.py,sha256=MxPCkBEYW_eLNqgCRYeyj7ZcLOFAWfpVZlqDR2Y_S0o,830
-primitive/lint/actions.py,sha256=fGnNlcD_B-E0SvRUTvTdSlTm2kCQUTrlBLB0mt1sXKM,2268
+primitive/lint/actions.py,sha256=tWsrht1dowGprcZjEUtjCJzozEQmh9sv2_C2__YHIOI,2825
 primitive/lint/commands.py,sha256=3CZvkOEMpJspJWmaQzA5bpPKx0_VCijQIXA9l-eTnZE,487
 primitive/organizations/actions.py,sha256=e0V4E1UK1IcBJsWWH6alHYUmArhzPrBqZ8WkHPIcLq0,2268
 primitive/organizations/commands.py,sha256=_dwgVEJCqMa5VgB_7P1wLPFc0AuT1p9dtyR9JRr4kpw,487
@@ -32,18 +32,18 @@ primitive/projects/commands.py,sha256=Fqqgpi4cm6zOgkHK--0F0hiiIj32BmgZ-h1MydmWwd
 primitive/sim/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 primitive/sim/actions.py,sha256=MkhiAH5QvF2jbnpgWL29HeSrTYiSW0UJpql2wZ4q18w,4900
 primitive/sim/commands.py,sha256=8PaOfL1MO6qxTn7mNVRnBU1X2wa3gk_mlbAhBW6MnI0,591
-primitive/sim/vcd.py,sha256=mAbGnKWM0qzIUMkuSmO0p3sU25kOqbl31mvCsDSrXeM,22221
 primitive/utils/actions.py,sha256=HOFrmM3-0A_A3NS84MqrZ6JmQEiiPSoDqEeuu6b_qfQ,196
+primitive/utils/cache.py,sha256=rzMhqDnP8QIzRidF7iyYA5rBGRLEu0tjX0POX0E1xFw,975
 primitive/utils/config.py,sha256=DlFM5Nglo22WPtbpZSVtH7NX-PTMaKYlcrUE7GPRG4c,1058
 primitive/utils/files.py,sha256=Yv__bQes3YIlzhOT9kVxtYhoA5CmUjPSvphl9PZ41k4,867
 primitive/utils/git.py,sha256=1qNOu8X-33CavmrD580BmrFhD_WVO9PGWHUUboXJR_g,663
 primitive/utils/memory_size.py,sha256=4xfha21kW82nFvOTtDFx9Jk2ZQoEhkfXii-PGNTpIUk,3058
 primitive/utils/printer.py,sha256=f1XUpqi5dkTL3GWvYRUGlSwtj2IxU1q745T4Fxo7Tn4,370
 primitive/utils/shell.py,sha256=-7UjQaBqSGHzEEyX8pNjeYFFP0P3lVnDV0OkgPz1qHU,1050
-primitive/utils/verible.py,sha256=QYczN1IvxODfj4jeq0nqjFuF0Oi0Zdx-Q32ySOJgcw8,2205
+primitive/utils/verible.py,sha256=r7c_hfqvL0UicMmIzK3Cy_BfZI1ZpcfBeLqKEWFWqJo,2252
 primitive/utils/yaml.py,sha256=4UP_9MXHoNb9_SCeUDm9xqYg9sHltqpVhNgsY6GNfb8,527
-primitive-0.1.37.dist-info/METADATA,sha256=AA7RYGrTBDffHSCXaxh5YnBaTeXRCfdRQA1TGzTE9Jc,3782
-primitive-0.1.37.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-primitive-0.1.37.dist-info/entry_points.txt,sha256=p1K8DMCWka5FqLlqP1sPek5Uovy9jq8u51gUsP-z334,48
-primitive-0.1.37.dist-info/licenses/LICENSE.txt,sha256=B8kmQMJ2sxYygjCLBk770uacaMci4mPSoJJ8WoDBY_c,1098
-primitive-0.1.37.dist-info/RECORD,,
+primitive-0.1.39.dist-info/METADATA,sha256=kANNdscAcTCkcY2ZAAnLS-ovI3wQwUhAEIvUZu9gYtc,3782
+primitive-0.1.39.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+primitive-0.1.39.dist-info/entry_points.txt,sha256=p1K8DMCWka5FqLlqP1sPek5Uovy9jq8u51gUsP-z334,48
+primitive-0.1.39.dist-info/licenses/LICENSE.txt,sha256=B8kmQMJ2sxYygjCLBk770uacaMci4mPSoJJ8WoDBY_c,1098
+primitive-0.1.39.dist-info/RECORD,,

primitive/sim/vcd.py

@@ -1,761 +0,0 @@
-"""Read Value Change Dump (VCD) files.
-
-Adapted from Western Digital's PyVCD: https://github.com/westerndigitalcorporation/pyvcd
-
-The primary interface is the :func:`tokenize()` generator function,
-parses a binary VCD stream, yielding tokens as they are encountered.
-
-.. code::
-
-   >>> import io
-   >>> from vcd.reader import TokenKind, tokenize
-   >>> vcd = b"$date today $end $timescale 1 ns $end"
-   >>> tokens = tokenize(io.BytesIO(vcd))
-   >>> token = next(tokens)
-   >>> assert token.kind is TokenKind.DATE
-   >>> assert token.date == 'today'
-   >>> token = next(tokens)
-   >>> assert token.kind is TokenKind.TIMESCALE
-   >>> assert token.timescale.magnitude.value == 1
-   >>> assert token.timescale.unit.value == 'ns'
-
-"""
-
-import io
-from dataclasses import dataclass
-from enum import Enum
-from typing import Iterator, NamedTuple, Optional, Tuple, Union
-
-
-class ScopeType(Enum):
-    """Valid VCD scope types."""
-
-    begin = "begin"
-    fork = "fork"
-    function = "function"
-    module = "module"
-    task = "task"
-
-
-class VarType(Enum):
-    """Valid VCD variable types."""
-
-    event = "event"
-    integer = "integer"
-    parameter = "parameter"
-    real = "real"
-    realtime = "realtime"
-    reg = "reg"
-    supply0 = "supply0"
-    supply1 = "supply1"
-    time = "time"
-    tri = "tri"
-    triand = "triand"
-    trior = "trior"
-    trireg = "trireg"
-    tri0 = "tri0"
-    tri1 = "tri1"
-    wand = "wand"
-    wire = "wire"
-    wor = "wor"
-    string = "string"
-
-    def __str__(self) -> str:
-        return self.value
-
-
-class TimescaleMagnitude(Enum):
-    """Valid timescale magnitudes."""
-
-    one = 1
-    ten = 10
-    hundred = 100
-
-
-class TimescaleUnit(Enum):
-    """Valid timescale units."""
-
-    second = "s"
-    millisecond = "ms"
-    microsecond = "us"
-    nanosecond = "ns"
-    picosecond = "ps"
-    femtosecond = "fs"
-
-
-class Timescale(NamedTuple):
-    """Timescale magnitude and unit."""
-
-    magnitude: TimescaleMagnitude
-    unit: TimescaleUnit
-
-    @classmethod
-    def from_str(cls, s: str) -> "Timescale":
-        for unit in TimescaleUnit:
-            if s == unit.value:
-                mag = TimescaleMagnitude(1)
-                break
-        else:
-            for mag in reversed(TimescaleMagnitude):
-                mag_str = str(mag.value)
-                if s.startswith(mag_str):
-                    unit_str = s[len(mag_str) :].lstrip(" ")
-                    unit = TimescaleUnit(unit_str)
-                    break
-            else:
-                raise ValueError(f"Invalid timescale magnitude {s!r}")
-        return Timescale(mag, unit)
-
-    def __str__(self) -> str:
-        return f"{self.magnitude.value} {self.unit.value}"
-
-
-class TokenKind(Enum):
-    """Kinds of VCD tokens."""
-
-    COMMENT = 1
-    DATE = 2
-    ENDDEFINITIONS = 3
-    SCOPE = 4
-    TIMESCALE = 5
-    UPSCOPE = 6
-    VAR = 7
-    VERSION = 8
-    DUMPALL = 9
-    DUMPOFF = 10
-    DUMPON = 11
-    DUMPVARS = 12
-    END = 13
-    CHANGE_TIME = 14
-    CHANGE_SCALAR = 15
-    CHANGE_VECTOR = 16
-    CHANGE_REAL = 17
-    CHANGE_STRING = 18
-
-
-class VarDecl(NamedTuple):
-    """VCD variable declaration.
-
-    Examples::
-
-       $var wire 4 !@# foobar [ 3 : 1 ] $end
-       $var real 1 aaa foobar $end
-       $var integer 32 > foobar[8] $end
-
-    """
-
-    type_: VarType  #: Type of variable
-    size: int  #: Size, in bits, of variable
-    id_code: str
-    """Identifer code of variable.
-
-    This code is used in subsequent value change descriptors
-    to map-back to this variable declaration."""
-
-    reference: str
-    """Reference name of variable.
-
-    This human-readable name typically corresponds to the name of a
-    variable in the model that output the VCD."""
-
-    bit_index: Union[None, int, Tuple[int, int]]
-    """Optional range of bits to select from the variable.
-
-    May select a single bit index, e.g. ``ref [ 3 ]``. Or a range of
-    bits, e.g. from ``ref [ 7 : 3 ]`` (MSB index then LSB index)."""
-
-    @property
-    def ref_str(self) -> str:
-        if self.bit_index is None:
-            return self.reference
-        elif isinstance(self.bit_index, int):
-            return f"{self.reference}[{self.bit_index}]"
-        else:
-            return f"{self.reference}[{self.bit_index[0]}:{self.bit_index[1]}]"
-
-
-class ScopeDecl(NamedTuple):
-    """VCD scope declaration.
-
-    Examples::
-
-       $scope module Foo $end
-       $scope
-          fork alpha_beta
-       $end
-
-    """
-
-    type_: ScopeType  #: Type of scope
-    ident: str  #: Scope name
-
-
-class VectorChange(NamedTuple):
-    """Vector value change descriptor.
-
-    A vector value consists of multiple 4-state values, where the four
-    states are 0, 1, X, and Z. When a vector value consists entirely
-    of 0 and 1 states, :attr:`value` will be an int. Otherwise
-    :attr:`value` will be a str.
-
-    """
-
-    id_code: str  #: Identifier code of associated variable.
-    value: Union[int, str]  #: New value of associated vector variable.
-
-
-class RealChange(NamedTuple):
-    """Real value (floating point) change descriptor."""
-
-    id_code: str  #: Identifier code of associated variable.
-    value: float  #: New value of associated real variable.
-
-
-class ScalarChange(NamedTuple):
-    """Scalar value change descriptor.
-
-    A scalar is a single 4-state value. The value is one of '0', '1',
-    'X', or 'Z'.
-
-    """
-
-    id_code: str  #: Identifier code of associated variable.
-    value: str  #: New value of associated scalar variable.
-
-
-class StringChange(NamedTuple):
-    """String value change descriptor.
-
-    Strings are VCD extension supported by GTKWave.
-
-    """
-
-    id_code: str  #: Identifier code of associated variable.
-    value: str  #: New value of associated string variable.
-
-
-class Location(NamedTuple):
-    """Describe location within VCD stream/file."""
-
-    line: int  #: Line number
-    column: int  #: Column number
-
-
-class Span(NamedTuple):
-    """Describe location span within VCD stream/file."""
-
-    start: Location  #: Start of span
-    end: Location  #: End of span
-
-
-class Token(NamedTuple):
-    """VCD token yielded from :func:`tokenize()`.
-
-    These are relatively high-level tokens insofar as each token fully
-    captures an entire VCD declaration, command, or change descriptor.
-
-    The :attr:`kind` attribute determines the :attr:`data` type. Various
-    kind-specific properties provide runtime type-checked access to the
-    kind-specific data.
-
-    .. Note::
-
-       The :attr:`data` attribute may be accessed directly to avoid
-       runtime type checks and thus achieve better runtime performance
-       versus accessing kind-specific properties such as
-       :attr:`scalar_change`.
-
-    """
-
-    kind: TokenKind
-    "The kind of token."
-
-    span: Span
-    "The start and end location of the token within the file/stream."
-
-    data: Union[
-        None,  # $enddefinitions $upscope $dump* $end
-        int,  # time change
-        str,  # $comment, $date, $version
-        ScopeDecl,  # $scope
-        Timescale,  # $timescale
-        VarDecl,  # $var
-        ScalarChange,
-        VectorChange,
-        RealChange,
-        StringChange,
-    ]
-    "Data associated with the token. The data type depends on :attr:`kind`."
-
-    @property
-    def comment(self) -> str:
-        """Unstructured text from a ``$comment`` declaration."""
-        assert self.kind is TokenKind.COMMENT
-        assert isinstance(self.data, str)
-        return self.data
-
-    @property
-    def date(self) -> str:
-        """Unstructured text from a ``$date`` declaration."""
-        assert self.kind is TokenKind.DATE
-        assert isinstance(self.data, str)
-        return self.data
-
-    @property
-    def scope(self) -> ScopeDecl:
-        """Scope type and identifier from ``$scope`` declaration."""
-        assert self.kind is TokenKind.SCOPE
-        assert isinstance(self.data, ScopeDecl)
-        return self.data
-
-    @property
-    def timescale(self) -> Timescale:
-        """Magnitude and unit from ``$timescale`` declaration."""
-        assert self.kind is TokenKind.TIMESCALE
-        assert isinstance(self.data, Timescale)
-        return self.data
-
-    @property
-    def var(self) -> VarDecl:
-        """Details from a ``$var`` declaration."""
-        assert self.kind is TokenKind.VAR
-        assert isinstance(self.data, VarDecl)
-        return self.data
-
-    @property
-    def version(self) -> str:
-        """Unstructured text from a ``$version`` declaration."""
-        assert self.kind is TokenKind.VERSION
-        assert isinstance(self.data, str)
-        return self.data
-
-    @property
-    def time_change(self) -> int:
-        """Simulation time change."""
-        assert self.kind is TokenKind.CHANGE_TIME
-        assert isinstance(self.data, int)
-        return self.data
-
-    @property
-    def scalar_change(self) -> ScalarChange:
-        """Scalar value change descriptor."""
-        assert self.kind is TokenKind.CHANGE_SCALAR
-        assert isinstance(self.data, ScalarChange)
-        return self.data
-
-    @property
-    def vector_change(self) -> VectorChange:
-        """Vector value change descriptor."""
-        assert self.kind is TokenKind.CHANGE_VECTOR
-        assert isinstance(self.data, VectorChange)
-        return self.data
-
-    @property
-    def real_change(self) -> RealChange:
-        """Real (float) value change descriptor."""
-        assert self.kind is TokenKind.CHANGE_REAL
-        assert isinstance(self.data, RealChange)
-        return self.data
-
-    @property
-    def string_change(self) -> StringChange:
-        "String value change descriptor."
-        assert self.kind is TokenKind.CHANGE_STRING
-        assert isinstance(self.data, StringChange)
-        return self.data
-
-
-class VCDParseError(Exception):
-    """Catch-all error for any VCD parsing errors."""
-
-    def __init__(self, loc: Location, msg: str) -> None:
-        super().__init__(f"{loc.line}:{loc.column}: {msg}")
-        self.loc = loc
-        "Location within VCD file where error was detected."
-
-
-HasReadinto = Union[io.BufferedIOBase, io.RawIOBase]
-
-
-def tokenize(stream: HasReadinto, buf_size: Optional[int] = None) -> Iterator[Token]:
-    """Parse VCD stream into tokens.
-
-    The input stream must be opened in binary mode. E.g. with ``open(path, 'rb')``.
-
-    """
-    if buf_size is None:
-        buf_size = io.DEFAULT_BUFFER_SIZE
-
-    s = _TokenizerState(stream, bytearray(buf_size))
-
-    try:
-        while True:
-            s.advance()
-            yield _parse_token(s)
-    except StopIteration:
-        return
-
-
-@dataclass
-class _TokenizerState:
-    stream: HasReadinto
-    buf: bytearray
-    pos: int = 0
-    end: int = 0
-    lineno: int = 1
-    column: int = 0
-
-    @property
-    def loc(self) -> Location:
-        return Location(self.lineno, self.column)
-
-    def span(self, start: Location) -> Span:
-        return Span(start, self.loc)
-
-    def advance(self, raise_on_eof: bool = True) -> int:
-        if self.pos < self.end:
-            self.pos += 1
-        else:
-            n = self.stream.readinto(self.buf)
-            if n:
-                self.end = n - 1
-                self.pos = 0
-            elif raise_on_eof:
-                raise StopIteration()
-            else:
-                return 0
-        c = self.buf[self.pos]
-        if c == 10:
-            self.lineno += 1
-            self.column = 1
-        else:
-            self.column += 1
-        return self.buf[self.pos]
-
-    def skip_ws(self) -> int:
-        c = self.buf[self.pos]
-        while c == 32 or 9 <= c <= 13:
-            c = self.advance()
-        return c
-
-    def take_ws_after_kw(self, kw: str) -> None:
-        if _is_ws(self.buf[self.pos]):
-            self.advance()
-        else:
-            raise VCDParseError(self.loc, f"Expected whitespace after identifier ${kw}")
-
-    def take_decimal(self) -> int:
-        digits = []
-        c = self.buf[self.pos]
-        while 48 <= c <= 57:  # '0' <= c <= '9'
-            digits.append(c)
-            c = self.advance(raise_on_eof=False)
-        if digits:
-            return int(bytes(digits))
-        else:
-            raise VCDParseError(self.loc, "Expected decimal value")
-
-    def take_id_code(self) -> str:
-        printables = []
-        c = self.buf[self.pos]
-        while 33 <= c <= 126:  # printable character
-            printables.append(c)
-            c = self.advance(raise_on_eof=False)
-        if printables:
-            return bytes(printables).decode("ascii")
-        else:
-            raise VCDParseError(self.loc, "Expected id code")
-
-    def take_identifier(self) -> str:
-        identifier = []
-        c = self.buf[self.pos]
-
-        # Identifiers must start with letter or underscore
-        if (
-            65 <= c <= 90  # 'A' <= c <= 'Z'
-            or 97 <= c <= 122  # 'a' - 'z'
-            or c == 95  # '_'
-        ):
-            identifier.append(c)
-            c = self.advance()
-        elif c == 92:
-            # If we encounter an escaped identifier,
-            # just remove the escape character
-            # NOTE: may need to revisit this
-            c = self.advance()
-        else:
-            raise VCDParseError(self.loc, "Identifier must start with a-zA-Z_")
-
-        while (
-            48 <= c <= 57  # '0' - '9'
-            or 65 <= c <= 90  # 'A' - 'Z'
-            or 97 <= c <= 122  # 'a' - 'z'
-            or c == 95  # '_'
-            or c == 36  # '$'
-            or c == 46  # '.' not in spec, but seen in the wild
-            or c == 40  # '(' - produced by cva6 core
-            or c == 41  # ')' - produced by cva6 core
-            or c == 91  # '[' - produced by dumping packed arrays
-            or c == 93  # ']' - produced by dumping packed arrays
-        ):
-            identifier.append(c)
-            c = self.advance(raise_on_eof=False)
-
-        return bytes(identifier).decode("ascii")
-
-    def take_bit_index(self) -> Union[int, Tuple[int, int]]:
-        self.skip_ws()
-        index0 = self.take_decimal()
-        index1: Optional[int]
-
-        c = self.skip_ws()
-        if c == 58:  # ':'
-            self.advance()
-            self.skip_ws()
-            index1 = self.take_decimal()
-        else:
-            index1 = None
-
-        c = self.skip_ws()
-        if c == 93:  # ']'
-            self.advance(raise_on_eof=False)
-            if index1 is None:
-                return index0
-            else:
-                return (index0, index1)
-        else:
-            raise VCDParseError(self.loc, 'Expected bit index to terminate with "]"')
-
-    def take_to_end(self) -> str:
-        chars = [
-            self.buf[self.pos],  # $
-            self.advance(),  # --> e
-            self.advance(),  # --> n
-            self.advance(),  # --> d
-        ]
-        while not (  # Check for 'd' 'n' 'e' '$'
-            chars[-1] == 100
-            and chars[-2] == 110
-            and chars[-3] == 101
-            and chars[-4] == 36
-        ):
-            chars.append(self.advance())
-
-        if len(chars) > 4 and not _is_ws(chars[-5]):
-            loc = Location(self.lineno, self.column - min(len(chars), 5))
-            raise VCDParseError(loc, "Expected whitespace before $end")
-
-        return bytes(chars[:-5]).decode("ascii")
-
-    def take_end(self) -> None:
-        if (
-            self.skip_ws() != 36  # '$'
-            or self.advance() != 101  # 'e'
-            or self.advance() != 110  # 'n'
-            or self.advance() != 100  # 'd'
-        ):
-            raise VCDParseError(self.loc, "Expected $end")
-
-
-def _is_ws(c: int) -> bool:
-    return c == 32 or 9 <= c <= 13
-
-
-def _parse_token(s: _TokenizerState) -> Token:
-    c = s.skip_ws()
-    start = s.loc
-    if c == 35:  # '#'
-        # Parse time change
-        s.advance()
-        time = s.take_decimal()
-        return Token(TokenKind.CHANGE_TIME, s.span(start), time)
-    elif c == 48 or c == 49 or c == 122 or c == 90 or c == 120 or c == 88:
-        # c in '01zZxX'
-        # Parse scalar change
-        scalar_value = chr(c)
-        s.advance()
-        id_code = s.take_id_code()
-        return Token(
-            TokenKind.CHANGE_SCALAR, s.span(start), ScalarChange(id_code, scalar_value)
-        )
-    elif c == 66 or c == 98:  # 'B' or 'b'
-        # Parse vector change
-        vector = []
-        c = s.advance()
-        while c == 48 or c == 49:  # '0' or '1'
-            vector.append(c)
-            c = s.advance()
-        vector_value: Union[int, str]
-
-        if c == 122 or c == 90 or c == 120 or c == 88:  # c in 'zZxX'
-            vector.append(c)
-            c = s.advance()
-            while (
-                c == 48 or c == 49 or c == 122 or c == 90 or c == 120 or c == 88
-            ):  # c in '01zZxX'
-                vector.append(c)
-                c = s.advance()
-            vector_value = bytes(vector).decode("ascii")
-        else:
-            vector_value = int(bytes(vector), 2)
-
-        if not _is_ws(c):
-            raise VCDParseError(s.loc, "Expected whitespace after vector value")
-
-        s.skip_ws()
-
-        id_code = s.take_id_code()
-
-        return Token(
-            TokenKind.CHANGE_VECTOR, s.span(start), VectorChange(id_code, vector_value)
-        )
-    elif c == 82 or c == 114:  # 'R' or 'r'
-        # Parse real change
-        real_digits = []
-        c = s.advance()
-
-        while not _is_ws(c):
-            real_digits.append(c)
-            c = s.advance()
-
-        try:
-            real = float(bytes(real_digits))
-        except ValueError:
-            real_str = bytes(real_digits).decode("ascii")
-            raise VCDParseError(start, f"Expected real value, got: {real_str}")
-
-        s.skip_ws()
-
-        id_code = s.take_id_code()
-
-        return Token(TokenKind.CHANGE_REAL, s.span(start), RealChange(id_code, real))
-    elif c == 83 or c == 115:  # 'S' or 's'
-        chars = []
-        c = s.advance()
-        while not _is_ws(c):
-            chars.append(c)
-            c = s.advance()
-        s.skip_ws()
-        id_code = s.take_id_code()
-        string_value = bytes(chars).decode("ascii")
-        return Token(
-            TokenKind.CHANGE_STRING, s.span(start), StringChange(id_code, string_value)
-        )
-    elif c == 36:  # '$'
-        s.advance()
-        kw = s.take_identifier()
-
-        if kw == "comment":
-            s.take_ws_after_kw(kw)
-            comment = s.take_to_end()
-            return Token(TokenKind.COMMENT, s.span(start), comment)
-        elif kw == "date":
-            s.take_ws_after_kw(kw)
-            date_str = s.take_to_end()
-            return Token(TokenKind.DATE, s.span(start), date_str)
-        elif kw == "enddefinitions":
-            s.take_ws_after_kw(kw)
-            s.take_end()
-            return Token(TokenKind.ENDDEFINITIONS, s.span(start), None)
-        elif kw == "scope":
-            s.take_ws_after_kw(kw)
-            s.skip_ws()
-            identifier = s.take_identifier()
-            try:
-                scope_type = ScopeType(identifier)
-            except ValueError:
-                raise VCDParseError(s.loc, f"Invalid $scope type: {identifier}")
-
-            s.skip_ws()
-
-            scope_ident = s.take_identifier()
-
-            s.take_end()
-
-            scope_decl = ScopeDecl(scope_type, scope_ident)
-
-            return Token(TokenKind.SCOPE, s.span(start), scope_decl)
-        elif kw == "timescale":
-            s.take_ws_after_kw(kw)
-            s.skip_ws()
-            mag_int = s.take_decimal()
-
-            try:
-                magnitude = TimescaleMagnitude(mag_int)
-            except ValueError:
-                valid_magnitudes = ", ".join(str(m.value) for m in TimescaleMagnitude)
-                raise VCDParseError(
-                    s.loc,
-                    f"Invalid $timescale magnitude: {mag_int}. "
-                    f"Must be one of: {valid_magnitudes}.",
-                )
-
-            s.skip_ws()
-            unit_str = s.take_identifier()
-            try:
-                unit = TimescaleUnit(unit_str)
-            except ValueError:
-                valid_units = ", ".join(u.value for u in TimescaleUnit)
-                raise VCDParseError(
-                    s.loc,
-                    f"Invalid $timescale unit: {unit_str}. "
-                    f"Must be one of: {valid_units}.",
-                )
-
-            s.take_end()
-
-            timescale = Timescale(magnitude, unit)
-            return Token(TokenKind.TIMESCALE, s.span(start), timescale)
-        elif kw == "upscope":
-            s.take_ws_after_kw(kw)
-            s.take_end()
-            return Token(TokenKind.UPSCOPE, s.span(start), None)
-        elif kw == "var":
-            s.take_ws_after_kw(kw)
-            s.skip_ws()
-            type_str = s.take_identifier()
-            try:
-                type_ = VarType(type_str)
-            except ValueError:
-                valid_types = ", ".join(t.value for t in VarType)
-                raise VCDParseError(
-                    s.loc,
-                    f"Invalid $var type: {type_str}. Must be one of: {valid_types}",
-                )
-
-            s.skip_ws()
-            size = s.take_decimal()
-            s.skip_ws()
-            id_code = s.take_id_code()
-            s.skip_ws()
-            ident = s.take_identifier()
-
-            bit_index: Union[None, int, Tuple[int, int]]
-            c = s.skip_ws()
-            if c == 91:  # '['
-                s.advance()
-                bit_index = s.take_bit_index()
-            else:
-                bit_index = None
-
-            s.take_end()
-            var_decl = VarDecl(type_, size, id_code, ident, bit_index)
-            return Token(TokenKind.VAR, s.span(start), var_decl)
-        elif kw == "version":
-            s.take_ws_after_kw(kw)
-            version = s.take_to_end()
-            return Token(TokenKind.VERSION, s.span(start), version)
-        elif kw == "dumpall":
-            return Token(TokenKind.DUMPALL, s.span(start), None)
-        elif kw == "dumpoff":
-            return Token(TokenKind.DUMPOFF, s.span(start), None)
-        elif kw == "dumpon":
-            return Token(TokenKind.DUMPON, s.span(start), None)
-        elif kw == "dumpvars":
-            return Token(TokenKind.DUMPVARS, s.span(start), None)
-        elif kw == "end":
-            return Token(TokenKind.END, s.span(start), None)
-        else:
-            raise VCDParseError(s.loc, f"invalid keyword ${kw}")
-    else:
-        raise VCDParseError(s.loc, f"confused: {chr(c)}")