primitive 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

primitive/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2024-present Dylan Stein <dylan@steins.studio>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "0.1.14"
+__version__ = "0.1.16"

primitive/agent/actions.py

@@ -65,28 +65,59 @@ class Agent(BaseAction):
                         )
                     )
 
-                    if job_run["job"]["slug"] == "lint":
-                        logger.debug("Executing Lint Job")
-
-                        self.primitive.jobs.job_run_update(
-                            job_run["id"], status="request_in_progress"
-                        )
-
-                        result, message = self.primitive.lint.execute(
-                            source=downloaded_git_repository_dir
-                        )
-                        if result:
-                            conclusion = "success"
-                        else:
-                            conclusion = "failure"
-                        self.primitive.jobs.job_run_update(
-                            job_run["id"],
-                            status="request_completed",
-                            conclusion=conclusion,
-                            stdout=message,
-                        )
-
-                        logger.debug("Lint Job Completed")
+                    match job_run["job"]["slug"]:
+                        case "lint":
+                            logger.debug("Executing Lint Job")
+
+                            self.primitive.jobs.job_run_update(
+                                job_run["id"], status="request_in_progress"
+                            )
+
+                            result, message = self.primitive.lint.execute(
+                                source=downloaded_git_repository_dir
+                            )
+                            if result:
+                                conclusion = "success"
+                            else:
+                                conclusion = "failure"
+                            self.primitive.jobs.job_run_update(
+                                job_run["id"],
+                                status="request_completed",
+                                conclusion=conclusion,
+                                stdout=message,
+                            )
+
+                            logger.debug("Lint Job Completed")
+                        case "sim":
+                            logger.debug("Executing Sim Job")
+
+                            self.primitive.job.job_run_update(
+                                job_run["id"], status="request_in_progress"
+                            )
+
+                            result, message = self.primitive.sim.execute(
+                                source=downloaded_git_repository_dir,
+                                cmd=(
+                                    "make",
+                                    "all",
+                                ),  # TODO: Change this to use container args container cmd
+                            )
+
+                            # Attempt artifact collection
+                            self.primitive.sim.collect_artifacts(
+                                source=downloaded_git_repository_dir
+                            )
+
+                            if result:
+                                conclusion = "success"
+                            else:
+                                conclusion = "failure"
+                            self.primitive.jobs.job_run_update(
+                                job_run["id"],
+                                status="request_completed",
+                                conclusion=conclusion,
+                                stdout=message,
+                            )
 
                 sleep(5)
         except KeyboardInterrupt:

primitive/cli.py

@@ -13,6 +13,7 @@ from .daemons.commands import cli as daemons_commands
 from .jobs.commands import cli as jobs_commands
 from .organizations.commands import cli as organizations_commands
 from .projects.commands import cli as projects_commands
+from .sim.commands import cli as sim_commands
 
 
 @click.group()
@@ -67,6 +68,7 @@ cli.add_command(daemons_commands, "daemons")
 cli.add_command(jobs_commands, "jobs")
 cli.add_command(organizations_commands, "organizations")
 cli.add_command(projects_commands, "projects")
+cli.add_command(sim_commands, "sim")
 
 if __name__ == "__main__":
     cli(obj={})

primitive/client.py

@@ -4,7 +4,7 @@ from .projects.actions import Projects
 from .graphql.sdk import create_session
 from .utils.config import read_config_file
 from .files.actions import Files
-from .simulations.actions import Simulations
+from .sim.actions import Sim
 from .hardware.actions import Hardware
 from .lint.actions import Lint
 from .agent.actions import Agent
@@ -61,7 +61,7 @@ class Primitive:
         self.projects: Projects = Projects(self)
         self.jobs: Jobs = Jobs(self)
         self.files: Files = Files(self)
-        self.simulations: Simulations = Simulations(self)
+        self.sim: Sim = Sim(self)
         self.hardware: Hardware = Hardware(self)
         self.lint: Lint = Lint(self)
         self.agent: Agent = Agent(self)

primitive/daemons/launch_agents.py

@@ -6,6 +6,7 @@ HOME_DIRECTORY = Path.home()
 CURRENT_USER = str(HOME_DIRECTORY.expanduser()).lstrip("/Users/")
 
 PRIMITIVE_BINARY_PATH = Path(HOME_DIRECTORY / ".pyenv" / "shims" / "primitive")
+
 PRIMITIVE_LAUNCH_AGENT_FILEPATH = Path(
     HOME_DIRECTORY / "Library" / "LaunchAgents" / "tech.primitive.agent.plist"
 )
@@ -78,6 +79,15 @@ def populate_fresh_launch_agent():
     PRIMITIVE_LAUNCH_AGENT_FILEPATH.parent.mkdir(parents=True, exist_ok=True)
     PRIMITIVE_LAUNCH_AGENT_FILEPATH.touch()
 
+    found_primitive_binary_path = PRIMITIVE_BINARY_PATH
+    if not PRIMITIVE_BINARY_PATH.exists():
+        result = subprocess.run(["which", "primitive"], capture_output=True)
+        if result.returncode == 0:
+            found_primitive_binary_path = result.stdout.decode().rstrip("\n")
+        else:
+            print("primitive binary not found")
+            return False
+
     PRIMITIVE_LAUNCH_AGENT_FILEPATH.write_text(
         f"""<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -96,7 +106,7 @@ def populate_fresh_launch_agent():
 	</array>
     <key>ProgramArguments</key>
     <array>
-        <string>{PRIMITIVE_BINARY_PATH}</string>
+        <string>{found_primitive_binary_path}</string>
         <string>agent</string>
     </array>
     <key>RunAtLoad</key>

primitive/daemons/launch_service.py

@@ -82,8 +82,17 @@ def populate_service_file():
         "After": "network.target",
     }
 
+    found_primitive_binary_path = PRIMITIVE_BINARY_PATH
+    if not PRIMITIVE_BINARY_PATH.exists():
+        result = subprocess.run(["which", "primitive"], capture_output=True)
+        if result.returncode == 0:
+            found_primitive_binary_path = result.stdout.decode().rstrip("\n")
+        else:
+            print("primitive binary not found")
+            return False
+
     config["Service"] = {
-        "ExecStart": f"{PRIMITIVE_BINARY_PATH} agent",
+        "ExecStart": f"{found_primitive_binary_path} agent",
         "Restart": "always",
         "StandardError": f"append:{PRIMITIVE_AGENT_LOGS_FILEPATH}",
         "StandardOutput": f"append:{PRIMITIVE_AGENT_LOGS_FILEPATH}",

primitive/jobs/actions.py

@@ -125,6 +125,10 @@ fragment JobRunFragment on JobRun {
     name
     createdAt
     updatedAt
+  } 
+  jobSettings {
+    containerArgs
+    containerCommand
   }
   gitCommit {
     sha

primitive/lint/actions.py

@@ -9,7 +9,7 @@ from ..utils.verible import install_verible
 
 class Lint(BaseAction):
     def execute(self, source: Path = Path.cwd()) -> Tuple[bool, str]:
-        logger.debug("Starting linter for source: {source}")
+        logger.debug(f"Starting linter for source: {source}")
         files = find_files_for_extension(source, ".sv")
         if not files:
             message = "No files found to lint."

primitive/projects/actions.py

@@ -5,7 +5,6 @@ from primitive.utils.actions import BaseAction
 
 
 class Projects(BaseAction):
-
     def get_projects(
         self,
         organization_id: Optional[str] = None,

primitive/sim/actions.py

@@ -0,0 +1,190 @@
+from gql import gql
+from pathlib import Path
+from primitive.utils.actions import BaseAction
+from loguru import logger
+import subprocess
+from typing import Tuple, List
+from ..utils.files import find_files_for_extension
+import os
+from .vcd import TokenKind, tokenize
+import io
+from collections import defaultdict
+import urllib
+import json
+
+
+class Sim(BaseAction):
+    def execute(
+        self, source: Path = Path.cwd(), cmd: Tuple[str] = ["make"]
+    ) -> Tuple[bool, str]:
+        logger.debug(f"Starting simulation run for source: {source}")
+
+        os.chdir(source)
+        logger.debug(f"Changed to {source}, starting sim run")
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, env=os.environ)
+        except FileNotFoundError:
+            message = f"Did not find {cmd}"
+            logger.error(message)
+            return False, message
+
+        logger.debug("Sim run complete.")
+
+        message = ""
+        if result.stderr:
+            logger.error("\n" + result.stderr)
+        if result.stdout:
+            logger.info("\n" + result.stdout)
+        message = "See above logs for sim output."
+
+        if result.returncode != 0:
+            if not self.primitive.DEBUG:
+                message = result.stderr
+            return False, message
+        else:
+            message = "Sim run successful."
+
+        return True, message
+
+    def upload_file(self, path: Path) -> str:
+        file_upload_response = self.primitive.files.file_upload(
+            path, key_prefix=f"{self.job_run_id}/{str(path.parent)}"
+        )
+        return file_upload_response.json()["data"]["fileUpload"]["id"]
+
+    def collect_artifacts(self, source) -> None:
+        file_ids = []
+
+        # Look for VCD artifacts
+        files = find_files_for_extension(source, ".vcd")
+        for file in files:
+            trace_file_ids = self.generate_timeseries(path=file)
+        file_ids.extend(trace_file_ids)
+
+        logger.debug("Uploading additional artifacts...")
+        files = find_files_for_extension(source, (".xml", ".vcd", ".log", ".history"))
+        for file_path in files:
+            try:
+                file_ids.append(self.upload_file(file_path))
+            except FileNotFoundError:
+                logger.warning(f"{file_path} not found...")
+
+        logger.debug("Updating job run...")
+        if len(file_ids) > 0:
+            job_run_update_response = self.primitive.projects.job_run_update(
+                id=self.job_run_id, file_ids=file_ids
+            )
+            logger.success(job_run_update_response)
+
+    def generate_timeseries(self, path: Path) -> List[str]:
+        logger.debug("Parsing VCD file...")
+        with open(path, "rb") as f:
+            tokens = tokenize(io.BytesIO(f.read()))
+
+        metadata = defaultdict(dict)
+        traces = defaultdict(list)
+        timescale_unit = "s"
+        timescale_magnitude = 1
+        active_module: str = ""
+        time: int = 0
+
+        for token in tokens:
+            match token.kind:
+                case TokenKind.TIMESCALE:
+                    timescale_unit = token.data.unit.value
+                    timescale_magnitude = token.data.magnitude.value
+                case TokenKind.SCOPE:
+                    active_module = token.data.ident
+                case TokenKind.CHANGE_TIME:
+                    time = int(token.data)
+                case TokenKind.VAR:
+                    var = {
+                        "id_code": token.data.id_code,
+                        "module": active_module,
+                        "var_type": str(token.data.type_),
+                        "var_size": token.data.size,
+                        "reference": token.data.reference,
+                        "bit_index": str(token.data.bit_index),
+                    }
+                    metadata[token.data.id_code] = var
+                case TokenKind.CHANGE_SCALAR:
+                    traces[token.data.id_code].append(
+                        (str(time), str(token.data.value))
+                    )
+                case TokenKind.CHANGE_VECTOR:
+                    traces[token.data.id_code].append(
+                        (str(time), str(token.data.value))
+                    )
+
+        # Add traces and write files
+        logger.debug("Uploading traces...")
+        trace_file_ids = []
+        for id_code, timeseries in traces.items():
+
+            def hashed(id_code):
+                return urllib.parse.quote_plus(id_code, safe="")
+
+            file_path = path.parent / f"{hashed(id_code)}.vcd.json"
+            with open(file_path, "w") as f:
+                f.write(json.dumps(timeseries))
+
+            trace_file_id = self.upload_file(file_path)
+            trace_file_ids.append(trace_file_id)
+
+            self.trace_create(
+                id_code=id_code,
+                module=metadata[id_code]["module"],
+                var_type=metadata[id_code]["var_type"],
+                var_size=metadata[id_code]["var_size"],
+                reference=metadata[id_code]["reference"],
+                bit_index=metadata[id_code]["bit_index"],
+                timescale_unit=timescale_unit,
+                timescale_magnitude=timescale_magnitude,
+                organization=self.organization_id,
+                file=trace_file_id,
+                job_run=self.job_run_id,
+            )
+
+        return trace_file_ids
+
+    def trace_create(
+        self,
+        id_code: str,
+        module: str,
+        var_type: str,
+        var_size: int,
+        reference: str,
+        bit_index: str,
+        timescale_unit: str,
+        timescale_magnitude: int,
+        organization: str,
+        file: str,
+        job_run: str,
+    ):
+        mutation = gql(
+            """
+            mutation createTrace($input: TraceCreateInput!) {
+                traceCreate(input: $input) {
+                    ... on Trace {
+                        id
+                    }
+                }
+            }
+        """
+        )
+        input = {
+            "idCode": id_code,
+            "module": module,
+            "varType": var_type,
+            "varSize": var_size,
+            "reference": reference,
+            "bitIndex": bit_index,
+            "timescaleUnit": timescale_unit,
+            "timescaleMagnitude": timescale_magnitude,
+            "organization": organization,
+            "file": file,
+            "jobRun": job_run,
+        }
+        variables = {"input": input}
+        result = self.primitive.session.execute(mutation, variable_values=variables)
+        return result

primitive/sim/commands.py

@@ -0,0 +1,19 @@
+import click
+from pathlib import Path
+import typing
+from typing import Tuple
+from ..utils.printer import print_result
+
+if typing.TYPE_CHECKING:
+    from ..client import Primitive
+
+
+@click.command("sim")
+@click.pass_context
+@click.argument("cmd", nargs=-1, required=True)
+@click.option("--source", type=click.Path(exists=True), default=".")
+def cli(context, source: str, cmd: Tuple[str]) -> None:
+    """Sim"""
+    primitive: Primitive = context.obj.get("PRIMITIVE")
+    result, message = primitive.sim.execute(source=Path(source), cmd=cmd)
+    print_result(message=message, context=context)

primitive/sim/vcd.py

@@ -0,0 +1,761 @@
+"""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)}")

{primitive-0.1.14.dist-info → primitive-0.1.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: primitive
-Version: 0.1.14
+Version: 0.1.16
 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.14.dist-info → primitive-0.1.16.dist-info}/RECORD

@@ -1,16 +1,16 @@
-primitive/__about__.py,sha256=NZWfnlUO354pWRTdV9CUZL2iipJ1paYR9Gljq6eTciM,129
+primitive/__about__.py,sha256=HhQ4GDjamHIwuTA3ry_5pOfBegiEFbQZ7WGCiJd3A00,129
 primitive/__init__.py,sha256=bwKdgggKNVssJFVPfKSxqFMz4IxSr54WWbmiZqTMPNI,106
-primitive/cli.py,sha256=VA1c9RiH79mqYvIvYT0msu4tEPlYiU1C2LstbdzyjWk,2291
-primitive/client.py,sha256=FYc-Onu1c0fjttSWlhK0B1ZOizDsP3qGtOAUHvPGqG0,2410
-primitive/agent/actions.py,sha256=8G9-QjUKRvlvlZ_6NyZr2KvvW1FTS54q-KPUzyAPccE,3657
+primitive/cli.py,sha256=VQPSewC6ouGdEG9W1gllawGJTydpOY0Lzg7LURXcqQg,2374
+primitive/client.py,sha256=SFPG4H2wJao8euGdnYp-l7dk_fDpWeVn2aT2WNJUAqo,2370
+primitive/agent/actions.py,sha256=e0xqQm0EeAqwhS45JrsxjNdT_JPMAgolav62jsHjdVM,5131
 primitive/agent/commands.py,sha256=-dVDilELfkGfbZB7qfEPs77Dm1oT62qJj4tsIk4KoxI,254
 primitive/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 primitive/auth/actions.py,sha256=N2bGcwXNsB89pzs66gF9A5_WzUScY5fhfOyWixqo2y8,1054
 primitive/auth/commands.py,sha256=JahUq0E2e7Xa-FX1WEUv7TgM6ieDvNH4VwRRtxAW7HE,2340
 primitive/daemons/actions.py,sha256=Nt3yNtbBhen0jK4sRsH_N7AP3UBuyL48VaUhtC7wYq8,2015
 primitive/daemons/commands.py,sha256=-Muh-6ib4uAVtPn_67AcMrDwuCwYlCnRQozCi2Xurmk,1726
-primitive/daemons/launch_agents.py,sha256=xR_JDL93mt5-fSbj-v3qvYFvLqfn486fPNbNxZOb1wU,4412
-primitive/daemons/launch_service.py,sha256=3ktr0n0rSNA-IV6hQ8hbG50L2Y3V8-IeW79C8CrZi8U,5203
+primitive/daemons/launch_agents.py,sha256=qovt32gwpjGDd82z_SY5EGCUjaUyNA49pZFajZsw3eE,4796
+primitive/daemons/launch_service.py,sha256=GZYUQfScpFAxma_pCZH4nRSVtrynTQEfeAvn9eJK2PE,5586
 primitive/files/actions.py,sha256=f4JN3QFB2WXw-0JpnE-4-movnqtvXIpCrGd_9pdkeW4,2624
 primitive/files/commands.py,sha256=DDizo3xJnU3KLUBTMeeM72viVpnJinLwxs84tmqKhqo,810
 primitive/git/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -20,17 +20,19 @@ primitive/graphql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU
 primitive/graphql/sdk.py,sha256=BhCGmDtc4sNnH8CxbQSJyFwOZ-ZSqMtjsxMB3JRBhPw,1456
 primitive/hardware/actions.py,sha256=Ea3_2E3F_3WapV60g_mOIcpXhadoknwihR7slXyUWtk,18840
 primitive/hardware/commands.py,sha256=QE7LLeFdfOqlvz3JwdwJJRZAY3fHI1zB9kYmmDajpq0,1477
-primitive/jobs/actions.py,sha256=ftVWIB10PxTrFsDmSd9C3WV3puiQftTLBKFIjcS_StI,7562
+primitive/jobs/actions.py,sha256=JsoVh7XVPX7AVb73fKwxY_UsMcFt4YWgMhveyJf56oc,7622
 primitive/jobs/commands.py,sha256=MxPCkBEYW_eLNqgCRYeyj7ZcLOFAWfpVZlqDR2Y_S0o,830
-primitive/lint/actions.py,sha256=PDw0fkIkI5hHHjoHaAiXvQUocwHZkgB2mfI-LGMl6TI,2267
+primitive/lint/actions.py,sha256=fGnNlcD_B-E0SvRUTvTdSlTm2kCQUTrlBLB0mt1sXKM,2268
 primitive/lint/commands.py,sha256=3CZvkOEMpJspJWmaQzA5bpPKx0_VCijQIXA9l-eTnZE,487
 primitive/organizations/actions.py,sha256=e0V4E1UK1IcBJsWWH6alHYUmArhzPrBqZ8WkHPIcLq0,2268
 primitive/organizations/commands.py,sha256=_dwgVEJCqMa5VgB_7P1wLPFc0AuT1p9dtyR9JRr4kpw,487
 primitive/projects/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-primitive/projects/actions.py,sha256=L2M2SvFdDr2XnpoxFl61jXmIriD4T1vVMoBFgCy6SY4,2062
+primitive/projects/actions.py,sha256=xhebDUMN9DXWvngWJyJkiijghbZwffy-JIPSsOg8agE,2061
 primitive/projects/commands.py,sha256=Fqqgpi4cm6zOgkHK--0F0hiiIj32BmgZ-h1MydmWwdE,464
-primitive/simulations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-primitive/simulations/actions.py,sha256=YR0oxxd7_kuUIH77BWZLUs9rLRiSJztPPhpgDJU2PbY,1267
+primitive/sim/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+primitive/sim/actions.py,sha256=6gAHotyD3QjglwQKdXsBK0cPuJmOAaDI0DlJyh9KpFY,6513
+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/config.py,sha256=DlFM5Nglo22WPtbpZSVtH7NX-PTMaKYlcrUE7GPRG4c,1058
 primitive/utils/files.py,sha256=Yv__bQes3YIlzhOT9kVxtYhoA5CmUjPSvphl9PZ41k4,867
@@ -39,8 +41,8 @@ primitive/utils/memory_size.py,sha256=4xfha21kW82nFvOTtDFx9Jk2ZQoEhkfXii-PGNTpIU
 primitive/utils/printer.py,sha256=f1XUpqi5dkTL3GWvYRUGlSwtj2IxU1q745T4Fxo7Tn4,370
 primitive/utils/shell.py,sha256=-7UjQaBqSGHzEEyX8pNjeYFFP0P3lVnDV0OkgPz1qHU,1050
 primitive/utils/verible.py,sha256=QYczN1IvxODfj4jeq0nqjFuF0Oi0Zdx-Q32ySOJgcw8,2205
-primitive-0.1.14.dist-info/METADATA,sha256=L7Npr3zJ77e2VpLmfKrhJ7bb3OuI2LKLxIS7Nvak7SQ,1818
-primitive-0.1.14.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-primitive-0.1.14.dist-info/entry_points.txt,sha256=p1K8DMCWka5FqLlqP1sPek5Uovy9jq8u51gUsP-z334,48
-primitive-0.1.14.dist-info/licenses/LICENSE.txt,sha256=B8kmQMJ2sxYygjCLBk770uacaMci4mPSoJJ8WoDBY_c,1098
-primitive-0.1.14.dist-info/RECORD,,
+primitive-0.1.16.dist-info/METADATA,sha256=waiNzX14CjPaARYniKRCDd9gwCAKAEu9yMuwFhQ8yOI,1818
+primitive-0.1.16.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+primitive-0.1.16.dist-info/entry_points.txt,sha256=p1K8DMCWka5FqLlqP1sPek5Uovy9jq8u51gUsP-z334,48
+primitive-0.1.16.dist-info/licenses/LICENSE.txt,sha256=B8kmQMJ2sxYygjCLBk770uacaMci4mPSoJJ8WoDBY_c,1098
+primitive-0.1.16.dist-info/RECORD,,

primitive/simulations/actions.py

@@ -1,48 +0,0 @@
-from gql import gql
-
-
-from primitive.utils.actions import BaseAction
-
-
-class Simulations(BaseAction):
-    def trace_create(
-        self,
-        id_code: str,
-        module: str,
-        var_type: str,
-        var_size: int,
-        reference: str,
-        bit_index: str,
-        timescale_unit: str,
-        timescale_magnitude: int,
-        organization: str,
-        file: str,
-        job_run: str,
-    ):
-        mutation = gql(
-            """
-            mutation createTrace($input: TraceCreateInput!) {
-                traceCreate(input: $input) {
-                    ... on Trace {
-                        id
-                    }
-                }
-            }
-        """
-        )
-        input = {
-            "idCode": id_code,
-            "module": module,
-            "varType": var_type,
-            "varSize": var_size,
-            "reference": reference,
-            "bitIndex": bit_index,
-            "timescaleUnit": timescale_unit,
-            "timescaleMagnitude": timescale_magnitude,
-            "organization": organization,
-            "file": file,
-            "jobRun": job_run,
-        }
-        variables = {"input": input}
-        result = self.primitive.session.execute(mutation, variable_values=variables)
-        return result