primitive 0.1.14__tar.gz → 0.1.16__tar.gz

{primitive-0.1.14 → primitive-0.1.16}/PKG-INFO

@@ -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 → primitive-0.1.16}/src/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-0.1.14 → primitive-0.1.16}/src/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-0.1.14 → primitive-0.1.16}/src/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-0.1.14 → primitive-0.1.16}/src/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-0.1.14 → primitive-0.1.16}/src/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-0.1.14 → primitive-0.1.16}/src/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-0.1.14 → primitive-0.1.16}/src/primitive/jobs/actions.py

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

{primitive-0.1.14 → primitive-0.1.16}/src/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-0.1.14 → primitive-0.1.16}/src/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-0.1.16/src/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-0.1.16/src/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)