primitive 0.1.21__py3-none-any.whl → 0.1.23__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.21"
+__version__ = "0.1.23"

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)
@@ -21,15 +49,40 @@ class Agent(BaseAction):
             sys.exit(1)
 
         try:
+            active_reservation_id = None
+            active_reservation_pk = None
+
             while True:
                 hardware = self.primitive.hardware.get_own_hardware_details()
+                if hardware["activeReservation"]:
+                    if (
+                        hardware["activeReservation"]["id"] != active_reservation_id
+                        or hardware["activeReservation"]["pk"] != active_reservation_pk
+                    ):
+                        logger.warning("New reservation for this hardware.")
+                        active_reservation_id = hardware["activeReservation"]["id"]
+                        active_reservation_pk = hardware["activeReservation"]["pk"]
+                        logger.debug("Active Reservation:")
+                        logger.debug(f"Node ID: {active_reservation_id}")
+                        logger.debug(f"PK: {active_reservation_pk}")
+                else:
+                    if (
+                        hardware["activeReservation"] is None
+                        and active_reservation_id is not None
+                        and hardware["isAvailable"]
+                    ):
+                        logger.debug("Previous Reservation is Complete:")
+                        logger.debug(f"Node ID: {active_reservation_id}")
+                        logger.debug(f"PK: {active_reservation_pk}")
+                        active_reservation_id = None
+                        active_reservation_pk = None
 
-                active_reservation_id = None
-                if hardware.get("activeReservation"):
-                    active_reservation_id = hardware["activeReservation"]["id"]
                 if not active_reservation_id:
-                    logger.debug("No active reservation found")
-                    sleep(5)
+                    sleep_amount = 5
+                    logger.debug(
+                        f"No active reservation found... [sleeping {sleep_amount} seconds]"
+                    )
+                    sleep(sleep_amount)
                     continue
 
                 job_runs_data = self.primitive.jobs.get_job_runs(
@@ -40,6 +93,14 @@ class Agent(BaseAction):
                     edge["node"] for edge in job_runs_data["jobRuns"]["edges"]
                 ]
 
+                if not pending_job_runs:
+                    sleep_amount = 5
+                    logger.debug(
+                        f"Waiting for Job Runs... [sleeping {sleep_amount} seconds]"
+                    )
+                    sleep(sleep_amount)
+                    continue
+
                 for job_run in pending_job_runs:
                     logger.debug("Found pending Job Run")
                     logger.debug(f"Job Run ID: {job_run['id']}")
@@ -62,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,
                         )
                     )
 
@@ -73,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/hardware/actions.py

@@ -464,6 +464,10 @@ fragment HardwareFragment on Hardware {
   slug
   createdAt
   updatedAt
+  isAvailable
+  isOnline
+  isQuarantined
+  isHealthy
   capabilities {
     id
     pk

primitive/sim/actions.py

@@ -1,15 +1,13 @@
-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
 
 
@@ -53,23 +51,23 @@ class Sim(BaseAction):
     def collect_artifacts(
         self, source: Path, job_run_id: str, organization_id: str
     ) -> None:
-        file_ids = []
-
-        # Look for VCD artifacts
+        # Split VCD artifacts
         files = find_files_for_extension(source, ".vcd")
         for file in files:
-            trace_file_ids = self.generate_timeseries(
+            self.split_vcd(
                 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"))
+        # 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 +80,71 @@ 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 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)
-        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.21.dist-info → primitive-0.1.23.dist-info}/METADATA

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

@@ -1,8 +1,8 @@
-primitive/__about__.py,sha256=JiIZ_OJnMBk7JQxWOZ-Ln2mvyV5v9BfpDzkeFWd4wQ0,129
+primitive/__about__.py,sha256=t_yxgDK5E5ZXzNOixMhkLwEWmOymxLER3wGKqe2Kdg4,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=CFb44aKPG2IF4c2Jqb0sBj4iA7VCtojcaGHgWdrtLYE,5407
+primitive/agent/actions.py,sha256=ZGnkjieQ6i61HhZuBt8TYjA6CgEJ5R4a6kEUqWIRSMM,8744
 primitive/agent/commands.py,sha256=-dVDilELfkGfbZB7qfEPs77Dm1oT62qJj4tsIk4KoxI,254
 primitive/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 primitive/auth/actions.py,sha256=N2bGcwXNsB89pzs66gF9A5_WzUScY5fhfOyWixqo2y8,1054
@@ -18,7 +18,7 @@ primitive/git/actions.py,sha256=fepcl5529w_hsaC6fBw9f-QHeyqNjGXz8HI5ebzbZMs,1386
 primitive/git/commands.py,sha256=64B2STTOn0dwVDmJHqEwekmIqKMfSyBBFwKg29Wt8Aw,1230
 primitive/graphql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 primitive/graphql/sdk.py,sha256=BhCGmDtc4sNnH8CxbQSJyFwOZ-ZSqMtjsxMB3JRBhPw,1456
-primitive/hardware/actions.py,sha256=Ea3_2E3F_3WapV60g_mOIcpXhadoknwihR7slXyUWtk,18840
+primitive/hardware/actions.py,sha256=JJXEeW35QzVGcLN4ym5gYZwY71hxLzM1GYPXWaObEts,18893
 primitive/hardware/commands.py,sha256=QE7LLeFdfOqlvz3JwdwJJRZAY3fHI1zB9kYmmDajpq0,1477
 primitive/jobs/actions.py,sha256=1Mc-bg4nCd5qiKC-hPODveTPZwwo0Kztl5BuidLr-Sc,7718
 primitive/jobs/commands.py,sha256=MxPCkBEYW_eLNqgCRYeyj7ZcLOFAWfpVZlqDR2Y_S0o,830
@@ -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=VT3PgMt_lC-zz_nx9kI8vWMclsOOkVaJmrYegQu31AM,5513
 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.21.dist-info/METADATA,sha256=MherRu1tZf7ePM5Inx7ebfvihZOrYKJlxMgSYQrTt80,1818
-primitive-0.1.21.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-primitive-0.1.21.dist-info/entry_points.txt,sha256=p1K8DMCWka5FqLlqP1sPek5Uovy9jq8u51gUsP-z334,48
-primitive-0.1.21.dist-info/licenses/LICENSE.txt,sha256=B8kmQMJ2sxYygjCLBk770uacaMci4mPSoJJ8WoDBY_c,1098
-primitive-0.1.21.dist-info/RECORD,,
+primitive/utils/yaml.py,sha256=4UP_9MXHoNb9_SCeUDm9xqYg9sHltqpVhNgsY6GNfb8,527
+primitive-0.1.23.dist-info/METADATA,sha256=HxzprzDhPdTYFNxtEACxa57jBgn-ZJcGNfQtELXfKuE,1840
+primitive-0.1.23.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+primitive-0.1.23.dist-info/entry_points.txt,sha256=p1K8DMCWka5FqLlqP1sPek5Uovy9jq8u51gUsP-z334,48
+primitive-0.1.23.dist-info/licenses/LICENSE.txt,sha256=B8kmQMJ2sxYygjCLBk770uacaMci4mPSoJJ8WoDBY_c,1098
+primitive-0.1.23.dist-info/RECORD,,