primitive 0.1.22__py3-none-any.whl → 0.1.24__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.22"
+__version__ = "0.1.24"

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")
@@ -142,9 +188,7 @@ class Agent(BaseAction):
 
                             # Attempt artifact collection
                             self.primitive.sim.collect_artifacts(
-                                source=source_dir,
-                                job_run_id=job_run["id"],
-                                organization_id=job_run["organization"]["id"],
+                                source=source_dir, job_run_id=job_run["id"]
                             )
 
                             if result:

primitive/sim/actions.py

@@ -1,16 +1,15 @@
-from gql import gql
-from pathlib import Path
+from pathlib import Path, PurePath
 from primitive.utils.actions import BaseAction
 from loguru import logger
 import subprocess
-from typing import Tuple, List
+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 urllib
 import json
+import xml.etree.ElementTree as ET
 
 
 class Sim(BaseAction):
@@ -50,26 +49,27 @@ class Sim(BaseAction):
         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
+    def collect_artifacts(self, source: Path, job_run_id: str) -> None:
+        # Parse 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)
+            self.parse_vcd(path=file)
+
+        # Parse XML artifacts
+        files = find_files_for_extension(source, ".xml")
+        for file in files:
+            self.parse_xml(path=file)
 
         logger.debug("Uploading additional artifacts...")
-        files = find_files_for_extension(source, (".xml", ".vcd", ".log", ".history"))
+        # 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(file_path.parent)}"
+                        file_path,
+                        prefix=f"{job_run_id}/{str(PurePath(file_path).relative_to(Path(source)).parent)}",
                     )
                 )
             except FileNotFoundError:
@@ -82,119 +82,115 @@ class Sim(BaseAction):
             )
             logger.success(job_run_update_response)
 
-    def generate_timeseries(
-        self, path: Path, job_run_id: str, organization_id: str
-    ) -> List[str]:
+    def parse_xml(self, path: Path) -> None:
+        results = ET.parse(path)
+        testsuites = results.getroot()
+
+        parsed_results = {}
+        testsuites_name = testsuites.attrib["name"]
+        parsed_results[testsuites_name] = {}
+
+        for testsuite in testsuites.findall("testsuite"):
+            testsuite_name = testsuite.attrib["name"]
+            parsed_results[testsuites_name][testsuite_name] = {
+                "properties": {},
+                "testcases": {},
+            }
+            props = parsed_results[testsuites_name][testsuite_name]["properties"]
+            testcases = parsed_results[testsuites_name][testsuite_name]["testcases"]
+
+            for prop in testsuite.findall("property"):
+                props[prop.attrib["name"]] = prop.attrib["value"]
+
+            for testcase in testsuite.findall("testcase"):
+                testcases[testcase.attrib["name"]] = {
+                    attr_key: attr_val for attr_key, attr_val in testcase.attrib.items()
+                }
+
+                failures = testcase.findall("failure")
+
+                if len(failures) > 0:
+                    for failure in failures:
+                        testcases[testcase.attrib["name"]]["status"] = {
+                            "conclusion": "failure",
+                            "message": failure.attrib["message"],
+                        }
+                else:
+                    testcases[testcase.attrib["name"]]["status"] = {
+                        "conclusion": "success",
+                        "message": "",
+                    }
+
+        # Write parsed file
+        data_path = path.parent / f"{path.name}.json"
+        with open(data_path, "w") as f:
+            f.write(json.dumps(parsed_results))
+
+    def parse_vcd(self, path: Path) -> None:
         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
+        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:
-                    timescale_unit = token.data.unit.value
-                    timescale_magnitude = token.data.magnitude.value
+                    metadata["timescaleUnit"] = token.data.unit.value
+                    metadata["timescaleMagnitude"] = token.data.magnitude.value
                 case TokenKind.SCOPE:
-                    active_module = token.data.ident
-                case TokenKind.CHANGE_TIME:
-                    time = int(token.data)
+                    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:
-                    var = {
+                    active_scope[token.data.id_code] = {
                         "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_TIME:
+                    current_time = int(token.data)
                 case TokenKind.CHANGE_SCALAR:
-                    traces[token.data.id_code].append(
-                        (str(time), str(token.data.value))
+                    data[token.data.id_code].append(
+                        (str(current_time), str(token.data.value))
                     )
                 case TokenKind.CHANGE_VECTOR:
-                    traces[token.data.id_code].append(
-                        (str(time), str(token.data.value))
+                    data[token.data.id_code].append(
+                        (str(current_time), str(token.data.value))
                     )
 
         # Add traces and write files
-        logger.debug("Uploading traces...")
-        trace_file_ids = []
-        for id_code, timeseries in traces.items():
+        logger.debug("Writing traces...")
 
-            def hashed(id_code):
-                return urllib.parse.quote_plus(id_code, safe="")
+        # Find name of file for json dumps
+        file_name = path.name.split(".")[0]
 
-            file_path = path.parent / f"{hashed(id_code)}.vcd.json"
-            with open(file_path, "w") as f:
-                f.write(json.dumps(timeseries))
+        # 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))
 
-            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,
-            )
+        # 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))
 
-        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
+        # 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/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.dist-info → primitive-0.1.24.dist-info}/METADATA

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

@@ -1,8 +1,8 @@
-primitive/__about__.py,sha256=GLbyQLa84sxg9eRnmnWkVVauDFJZS0FGa5ocDebd_3g,129
+primitive/__about__.py,sha256=_w49f95cSqBz80O_5aXINkQBIbfMdD--GZTies4DMl0,129
 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=uTT3Ke95BTL9haAHFhPJPasZEDlqDuC2uEF03Omap7E,7020
+primitive/agent/actions.py,sha256=fAuQmd5Z8FX3w1AiwLd4a_PPuBynzmdiWRmWA9ftn-8,8632
 primitive/agent/commands.py,sha256=-dVDilELfkGfbZB7qfEPs77Dm1oT62qJj4tsIk4KoxI,254
 primitive/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 primitive/auth/actions.py,sha256=N2bGcwXNsB89pzs66gF9A5_WzUScY5fhfOyWixqo2y8,1054
@@ -30,7 +30,7 @@ primitive/projects/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 primitive/projects/actions.py,sha256=xhebDUMN9DXWvngWJyJkiijghbZwffy-JIPSsOg8agE,2061
 primitive/projects/commands.py,sha256=Fqqgpi4cm6zOgkHK--0F0hiiIj32BmgZ-h1MydmWwdE,464
 primitive/sim/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-primitive/sim/actions.py,sha256=vmhiFH8WhQgVEeIHG9r2Gxb5ZZMdk19JYiz5r2F21cg,6864
+primitive/sim/actions.py,sha256=OywgMR2-ErgL3Q5YsOMoD-UxeUkZHrMoJYxxQAl5sss,7283
 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
@@ -41,8 +41,9 @@ 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.22.dist-info/METADATA,sha256=O1FnkxZf7VZ8cu575Na1xlA2-6z6esA-sqgWp-0sWtc,1818
-primitive-0.1.22.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-primitive-0.1.22.dist-info/entry_points.txt,sha256=p1K8DMCWka5FqLlqP1sPek5Uovy9jq8u51gUsP-z334,48
-primitive-0.1.22.dist-info/licenses/LICENSE.txt,sha256=B8kmQMJ2sxYygjCLBk770uacaMci4mPSoJJ8WoDBY_c,1098
-primitive-0.1.22.dist-info/RECORD,,
+primitive/utils/yaml.py,sha256=4UP_9MXHoNb9_SCeUDm9xqYg9sHltqpVhNgsY6GNfb8,527
+primitive-0.1.24.dist-info/METADATA,sha256=VCnsBIbMsGhGTQzilsu0KRcSVB81L-4bW1w8KyyQSg8,1840
+primitive-0.1.24.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+primitive-0.1.24.dist-info/entry_points.txt,sha256=p1K8DMCWka5FqLlqP1sPek5Uovy9jq8u51gUsP-z334,48
+primitive-0.1.24.dist-info/licenses/LICENSE.txt,sha256=B8kmQMJ2sxYygjCLBk770uacaMci4mPSoJJ8WoDBY_c,1098
+primitive-0.1.24.dist-info/RECORD,,