primitive 0.1.22__tar.gz → 0.1.23__tar.gz

{primitive-0.1.22 → primitive-0.1.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: primitive
-Version: 0.1.22
+Version: 0.1.23
 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
@@ -23,6 +23,7 @@ Requires-Dist: gql[all]
 Requires-Dist: ipdb
 Requires-Dist: loguru
 Requires-Dist: pyright
+Requires-Dist: pyyaml
 Requires-Dist: ruff
 Description-Content-Type: text/markdown
 

{primitive-0.1.22 → primitive-0.1.23}/pyproject.toml

@@ -32,7 +32,8 @@ dependencies = [
   "pyright",
   "click",
   "gql[all]",
-  "loguru"
+  "loguru",
+  "pyyaml",
 ]
 
 [project.urls]
@@ -47,29 +48,18 @@ primitive = "primitive.cli:cli"
 path = "src/primitive/__about__.py"
 
 [tool.hatch.envs.default]
-dependencies = [
-  "coverage[toml]>=6.5",
-  "pytest",
-]
+dependencies = ["coverage[toml]>=6.5", "pytest"]
 [tool.hatch.envs.default.scripts]
 test = "pytest {args:tests}"
 test-cov = "coverage run -m pytest {args:tests}"
-cov-report = [
-  "- coverage combine",
-  "coverage report",
-]
-cov = [
-  "test-cov",
-  "cov-report",
-]
+cov-report = ["- coverage combine", "coverage report"]
+cov = ["test-cov", "cov-report"]
 
 [[tool.hatch.envs.all.matrix]]
 python = ["3.8", "3.9", "3.10", "3.11", "3.12"]
 
 [tool.hatch.envs.types]
-dependencies = [
-  "mypy>=1.0.0",
-]
+dependencies = ["mypy>=1.0.0"]
 [tool.hatch.envs.types.scripts]
 check = "mypy --install-types --non-interactive {args:src/primitive tests}"
 
@@ -77,17 +67,11 @@ check = "mypy --install-types --non-interactive {args:src/primitive tests}"
 source_pkgs = ["primitive", "tests"]
 branch = true
 parallel = true
-omit = [
-  "src/primitive/__about__.py",
-]
+omit = ["src/primitive/__about__.py"]
 
 [tool.coverage.paths]
 primitive = ["src/primitive", "*/primitive/src/primitive"]
 tests = ["tests", "*/primitive/tests"]
 
 [tool.coverage.report]
-exclude_lines = [
-  "no cov",
-  "if __name__ == .__main__.:",
-  "if TYPE_CHECKING:",
-]
+exclude_lines = ["no cov", "if __name__ == .__main__.:", "if TYPE_CHECKING:"]

{primitive-0.1.22 → primitive-0.1.23}/requirements.txt

@@ -26,7 +26,6 @@ certifi==2024.7.4
 charset-normalizer==3.3.2
     # via requests
 click==8.1.7
-    # via primitive (pyproject.toml)
 decorator==5.1.1
     # via
     #   ipdb
@@ -38,7 +37,6 @@ frozenlist==1.4.1
     #   aiohttp
     #   aiosignal
 gql==3.5.0
-    # via primitive (pyproject.toml)
 graphql-core==3.2.3
     # via gql
 h11==0.14.0
@@ -54,7 +52,6 @@ idna==3.7
     #   requests
     #   yarl
 ipdb==0.13.13
-    # via primitive (pyproject.toml)
 ipython==8.26.0
     # via ipdb
 jedi==0.19.1
@@ -62,7 +59,6 @@ jedi==0.19.1
 jmespath==1.0.1
     # via botocore
 loguru==0.7.2
-    # via primitive (pyproject.toml)
 matplotlib-inline==0.1.7
     # via ipython
 multidict==6.0.5
@@ -84,9 +80,9 @@ pure-eval==0.2.3
 pygments==2.18.0
     # via ipython
 pyright==1.1.376
-    # via primitive (pyproject.toml)
 python-dateutil==2.9.0.post0
     # via botocore
+pyyaml==6.0.2
 requests==2.32.3
     # via
     #   gql
@@ -94,7 +90,6 @@ requests==2.32.3
 requests-toolbelt==1.0.0
     # via gql
 ruff==0.6.1
-    # via primitive (pyproject.toml)
 six==1.16.0
     # via
     #   asttokens

{primitive-0.1.22 → primitive-0.1.23}/src/primitive/__about__.py

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

{primitive-0.1.22 → primitive-0.1.23}/src/primitive/agent/actions.py

@@ -1,11 +1,36 @@
+import platform
 import sys
+from pathlib import Path
 from time import sleep
 from primitive.utils.actions import BaseAction
 from loguru import logger
 from primitive.__about__ import __version__
+import yaml
+from ..utils.yaml import generate_script_from_yaml
+
+try:
+    from yaml import CLoader as Loader
+except ImportError:
+    from yaml import Loader
 
 
 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,
     ):
@@ -13,6 +38,9 @@ class Agent(BaseAction):
         logger.info(" [*] primitive")
         logger.info(f" [*] Version: {__version__}")
 
+        # Create cache dir if it doesnt exist
+        self.set_cache_dir()
+
         # self.primitive.hardware.update_hardware_system_info()
         try:
             self.primitive.hardware.check_in_http(is_available=True, is_online=True)
@@ -95,6 +123,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,
                         )
                     )
 
@@ -106,6 +135,23 @@ class Agent(BaseAction):
                     if containerArgs := job_run["jobSettings"]["containerArgs"]:
                         cmd = tuple(containerArgs.split(" "))
 
+                    # Load config and generate bash script
+                    yaml_config_path = Path(source_dir / "primitive.yaml")
+                    run_script_path = None
+                    if yaml_config_path.exists() and yaml_config_path.is_file():
+                        yaml_config = yaml.load(
+                            open(yaml_config_path, "r"), Loader=Loader
+                        )
+                        run_script_path = generate_script_from_yaml(
+                            yaml_config,
+                            slug=job_run["job"]["slug"],
+                            destination=source_dir,
+                        )
+                        cmd = (
+                            "/bin/bash",
+                            str(run_script_path.resolve()),
+                        )
+
                     match job_run["job"]["slug"]:
                         case "lint":
                             logger.debug("Executing Lint Job")

primitive-0.1.23/src/primitive/sim/actions.py

@@ -0,0 +1,150 @@
+from pathlib import Path, PurePath
+from primitive.utils.actions import BaseAction
+from loguru import logger
+import subprocess
+from typing import Tuple
+from ..utils.files import find_files_for_extension
+import os
+from .vcd import TokenKind, tokenize
+import io
+from collections import defaultdict
+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, prefix: str) -> str:
+        file_upload_response = self.primitive.files.file_upload(path, key_prefix=prefix)
+        return file_upload_response.json()["data"]["fileUpload"]["id"]
+
+    def collect_artifacts(
+        self, source: Path, job_run_id: str, organization_id: str
+    ) -> None:
+        # Split VCD artifacts
+        files = find_files_for_extension(source, ".vcd")
+        for file in files:
+            self.split_vcd(
+                path=file, job_run_id=job_run_id, organization_id=organization_id
+            )
+
+        logger.debug("Uploading additional artifacts...")
+        # TODO: Figure out how to track ".log", ".history" files w/ analog stuff involved
+        file_ids = []
+        files = find_files_for_extension(source, (".xml", ".vcd", ".json"))
+        for file_path in files:
+            try:
+                file_ids.append(
+                    self.upload_file(
+                        file_path,
+                        prefix=f"{job_run_id}/{str(PurePath(file_path).relative_to(Path(source)).parent)}",
+                    )
+                )
+            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.jobs.job_run_update(
+                id=job_run_id, file_ids=file_ids
+            )
+            logger.success(job_run_update_response)
+
+    def split_vcd(self, path: Path, job_run_id: str, organization_id: str) -> None:
+        logger.debug("Parsing VCD file...")
+        with open(path, "rb") as f:
+            tokens = tokenize(io.BytesIO(f.read()))
+
+        metadata = defaultdict(dict)
+        header = defaultdict(dict)
+        data = defaultdict(list)
+
+        active_scope = header
+        previous_scope = None
+
+        current_time = 0
+
+        for token in tokens:
+            match token.kind:
+                case TokenKind.TIMESCALE:
+                    metadata["timescaleUnit"] = token.data.unit.value
+                    metadata["timescaleMagnitude"] = token.data.magnitude.value
+                case TokenKind.SCOPE:
+                    scope_type = str(token.data.type_)
+                    scope_ident = token.data.ident
+                    key = f"{scope_type}:{scope_ident}"
+                    active_scope[key] = {}
+
+                    previous_scope = active_scope
+                    active_scope = active_scope[key]
+                case TokenKind.UPSCOPE:
+                    active_scope = previous_scope
+                case TokenKind.VAR:
+                    active_scope[token.data.id_code] = {
+                        "id_code": token.data.id_code,
+                        "var_type": str(token.data.type_),
+                        "var_size": token.data.size,
+                        "reference": token.data.reference,
+                        "bit_index": str(token.data.bit_index),
+                    }
+                case TokenKind.CHANGE_TIME:
+                    current_time = int(token.data)
+                case TokenKind.CHANGE_SCALAR:
+                    data[token.data.id_code].append(
+                        (str(current_time), str(token.data.value))
+                    )
+                case TokenKind.CHANGE_VECTOR:
+                    data[token.data.id_code].append(
+                        (str(current_time), str(token.data.value))
+                    )
+
+        # Add traces and write files
+        logger.debug("Writing traces...")
+
+        # Find name of file for json dumps
+        file_name = path.name.split(".")[0]
+
+        # Write metadata file
+        metadata_path = path.parent / f"{file_name}.metadata.vcd.json"
+        with open(metadata_path, "w") as f:
+            f.write(json.dumps(metadata))
+
+        # Write header file
+        header_path = path.parent / f"{file_name}.header.vcd.json"
+        with open(header_path, "w") as f:
+            f.write(json.dumps(metadata))
+
+        # Write data file
+        data_path = path.parent / f"{file_name}.data.vcd.json"
+        with open(data_path, "w") as f:
+            f.write(json.dumps(metadata))

primitive-0.1.23/src/primitive/utils/yaml.py

@@ -0,0 +1,23 @@
+from pathlib import Path
+
+
+def generate_script_from_yaml(yaml_config: dict, slug: str, destination: Path) -> None:
+    commands_blocks = []
+    if steps := yaml_config[slug]["steps"]:
+        for step in steps:
+            commands_blocks.append(step["run"])
+
+    script = f"""
+#!/bin/bash
+
+{"".join(commands_blocks)}
+    """
+
+    output_path = Path(destination / "run.sh")
+    with open(output_path, "w") as f:
+        f.write(script)
+
+    # Apply execute file permissions
+    output_path.chmod(0o744)
+
+    return output_path

primitive-0.1.22/src/primitive/sim/actions.py

@@ -1,200 +0,0 @@
-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, prefix: str) -> str:
-        file_upload_response = self.primitive.files.file_upload(path, key_prefix=prefix)
-        return file_upload_response.json()["data"]["fileUpload"]["id"]
-
-    def collect_artifacts(
-        self, source: Path, job_run_id: str, organization_id: str
-    ) -> 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, job_run_id=job_run_id, organization_id=organization_id
-            )
-            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, prefix=f"{job_run_id}/{str(file_path.parent)}"
-                    )
-                )
-            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.jobs.job_run_update(
-                id=job_run_id, file_ids=file_ids
-            )
-            logger.success(job_run_update_response)
-
-    def generate_timeseries(
-        self, path: Path, job_run_id: str, organization_id: str
-    ) -> 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, prefix=f"{job_run_id}/{str(file_path.parent)}"
-            )
-            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=organization_id,
-                file=trace_file_id,
-                job_run=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