primitive 0.1.58__tar.gz → 0.1.60__tar.gz

primitive-0.1.60/.vscode/settings.json

@@ -0,0 +1,22 @@
+{
+  "cSpell.words": [
+    "Checkin",
+    "loguru",
+    "machdep",
+    "testsuites",
+    "untar",
+    "Untaring",
+    "VERIBLE",
+    "verilog",
+    "workdir"
+  ],
+  "[python]": {
+    "editor.defaultFormatter": "charliermarsh.ruff",
+    "editor.formatOnSave": true,
+    "editor.codeActionsOnSave": {
+      "source.fixAll": "explicit"
+    }
+  },
+  "ruff.fixAll": true,
+  "ruff.organizeImports": true
+}

{primitive-0.1.58 → primitive-0.1.60}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: primitive
-Version: 0.1.58
+Version: 0.1.60
 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.58 → primitive-0.1.60}/src/primitive/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2024-present Dylan Stein <dylan@primitive.tech>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "0.1.58"
+__version__ = "0.1.60"

{primitive-0.1.58 → primitive-0.1.60}/src/primitive/agent/actions.py

@@ -1,9 +1,12 @@
-import sys
 import shutil
+import sys
 from time import sleep
-from primitive.utils.actions import BaseAction
+
 from loguru import logger
+
 from primitive.__about__ import __version__
+from primitive.utils.actions import BaseAction
+
 from ..utils.cache import get_sources_cache
 from .runner import AgentRunner
 from .uploader import Uploader
@@ -73,12 +76,12 @@ class Agent(BaseAction):
                     sleep(sleep_amount)
                     continue
 
-                job_runs_data = self.primitive.jobs.get_job_runs(
+                job_runs_result = self.primitive.jobs.get_job_runs(
                     status="pending", first=1, reservation_id=active_reservation_id
                 )
 
                 pending_job_runs = [
-                    edge["node"] for edge in job_runs_data["jobRuns"]["edges"]
+                    edge["node"] for edge in job_runs_result.data["jobRuns"]["edges"]
                 ]
 
                 if not pending_job_runs:
@@ -126,6 +129,7 @@ class Agent(BaseAction):
                             source_dir=source_dir,
                             job_id=job_run["id"],
                             job_slug=job_run["job"]["slug"],
+                            max_log_size=500 * 1024,
                         )
                     except Exception as e:
                         # Log Error

{primitive-0.1.58 → primitive-0.1.60}/src/primitive/agent/process.py

@@ -34,7 +34,7 @@ class Process:
         self.sel.register(self.process.stdout, selectors.EVENT_READ)
         self.sel.register(self.process.stderr, selectors.EVENT_READ)
 
-    def probe_logs(self):
+    def log(self):
         for key, _ in self.sel.select():
             data = key.fileobj.readline()
             if not data:
@@ -48,7 +48,7 @@ class Process:
 
     def wait(self):
         while True:
-            self.probe_logs()
+            self.log()
             if not self.is_running():
                 break
 

{primitive-0.1.58 → primitive-0.1.60}/src/primitive/agent/provision.py

@@ -2,6 +2,7 @@ import sys
 from subprocess import Popen, PIPE
 from pathlib import Path
 from typing import Dict
+from ..utils.shell import env_string_to_dict
 
 
 class ProvisionPython:
@@ -34,14 +35,7 @@ class ProvisionPython:
         output, _ = proc.communicate()
 
         # Split the output into lines and parse it into a dictionary
-        env_vars = {}
-
-        for line in output.splitlines():
-            var_line = line.split("=", 1)
-
-            if len(var_line) == 2:
-                key, value = var_line
-                env_vars[key] = value
+        env_vars = env_string_to_dict(output)
 
         cmd = f"python -m pip install -r {self.requirements_path}"
         proc = Popen(

{primitive-0.1.58 → primitive-0.1.60}/src/primitive/agent/runner.py

@@ -1,14 +1,15 @@
-import yaml
-import typing
 import os
 import threading
-from time import sleep
-from typing import TypedDict, Iterable, List, Optional, Dict
+import typing
 from pathlib import Path, PurePath
+from time import sleep
+from typing import Dict, Iterable, List, Optional, TypedDict
+
+import yaml
 from loguru import logger
 from .process import Process
 from .provision import ProvisionPython
-from ..utils.cache import get_artifacts_cache
+from ..utils.cache import get_artifacts_cache, get_logs_cache
 from ..utils.files import find_files_for_extension
 
 try:
@@ -54,12 +55,11 @@ class AgentRunner:
         self.job_slug = job_slug
         self.max_log_size = max_log_size
         self.artifacts_dir = get_artifacts_cache(self.job_id)
+        self.logs_dir = get_logs_cache(self.job_id)
+        self.logger_handle = None
 
         logger.enable("primitive")
-        self.logger_handle = logger.add(
-            Path(self.artifacts_dir / "runner_{time}.log"),
-            rotation=self.max_log_size,  # Rotate when the log file reaches 10MB
-        )
+        self.swap_logs(label="init")
 
         logger.info(f"Scanning directory for job {self.job_slug}")
 
@@ -111,6 +111,9 @@ class AgentRunner:
         conclusion = None
         total_errors = 0
         for step in self.steps():
+            # Swap logger
+            self.swap_logs(label=step["name"])
+
             logger.info(f"Beginning step {step['name']}")
 
             # Update workdir
@@ -136,7 +139,7 @@ class AgentRunner:
                 while proc.is_running():
                     # Check job status
                     status = self.primitive.jobs.get_job_status(self.job_id)
-                    status_value = status["jobRun"]["status"]
+                    status_value = status.data["jobRun"]["status"]
 
                     # TODO: Should probably use request_cancelled or something
                     # once we change it, we'll have to call conclude w/ cancelled status
@@ -182,6 +185,15 @@ class AgentRunner:
         logger.info(f"Completed {self.job_slug} job")
         logger.remove(self.logger_handle)
 
+    def swap_logs(self, label: str):
+        # Remove Handle
+        if self.logger_handle:
+            logger.remove(self.logger_handle)
+
+        self.logger_handle = logger.add(
+            Path(self.logs_dir / f"{label}_{{time}}.primitive.log"), rotation=self.max_log_size
+        )
+
     def provision(self) -> Optional[Dict]:
         match self.job["provision"]:
             case "python":
@@ -197,8 +209,6 @@ class AgentRunner:
                 return prov.create_env()
 
     def collect_artifacts(self, step: JobStep) -> None:
-        # str(PurePath(file_path).relative_to(Path(source))
-
         # Search each artifact type
         for artifact in step["artifacts"]:
             files = find_files_for_extension(self.source_dir, artifact["extension"])

primitive-0.1.60/src/primitive/agent/uploader.py

@@ -0,0 +1,106 @@
+import typing
+from typing import Dict
+import shutil
+import os
+from loguru import logger
+from pathlib import Path, PurePath
+from ..utils.cache import get_artifacts_cache, get_logs_cache
+
+if typing.TYPE_CHECKING:
+    import primitive.client
+
+
+class Uploader:
+    def __init__(
+        self,
+        primitive: "primitive.client.Primitive",
+    ):
+        self.primitive = primitive
+
+    def upload_file(self, path: Path, prefix: str, job_run_id: str) -> str:
+        file_upload_response = self.primitive.files.file_upload(
+            path, key_prefix=prefix, job_run_id=job_run_id
+        )
+        return file_upload_response.json()["data"]["fileUpload"]["id"]
+    
+    def upload_dir(self, cache: Path) -> Dict:
+        file_ids = []
+        job_run_id = cache.name
+
+        files = None
+        has_walk = getattr(cache, "walk", None)
+        if has_walk:
+            files = sorted(
+                [
+                    current_path / file
+                    for current_path, _, current_path_files in cache.walk()
+                    for file in current_path_files
+                ],
+                key=lambda p: p.stat().st_size,
+            )
+        else:
+            files = sorted(
+                [
+                    Path(Path(current_path) / file)
+                    for current_path, _, current_path_files in os.walk(cache)
+                    for file in current_path_files
+                ],
+                key=lambda p: p.stat().st_size,
+            )
+
+        for file in files:
+            upload_id = self.upload_file(
+                file,
+                prefix=str(PurePath(file).relative_to(cache.parent).parent),
+                job_run_id=job_run_id,
+            )
+
+            if upload_id:
+                file_ids.append(upload_id)
+                continue
+
+            logger.error(f"Unable to upload file {file}")
+
+        # Clean up job cache
+        shutil.rmtree(path=cache)
+
+        return {job_run_id: file_ids}
+
+
+    def scan(self) -> None:
+        # Scan artifacts directory
+        artifacts_dir = get_artifacts_cache()
+        logs_dir = get_logs_cache()
+
+        artifacts = sorted([
+            artifacts_cache
+            for artifacts_cache in artifacts_dir.iterdir()
+            if artifacts_cache.is_dir()
+        ], key=lambda p: p.stat().st_ctime)
+
+        logs = sorted([
+            logs_cache 
+            for logs_cache in logs_dir.iterdir() 
+            if logs_cache.is_dir()
+        ], key=lambda p: p.stat().st_ctime)
+
+        log_files = {
+            job_id: files
+            for log_path in logs
+            for job_id, files in self.upload_dir(log_path).items()
+        }
+
+        artifact_files = {
+            job_id: files
+            for artifact_path in artifacts
+            for job_id, files in self.upload_dir(artifact_path).items()
+        }
+
+        files_by_id = {
+            job_id: log_files.get(job_id, []) + artifact_files.get(job_id, []) 
+            for job_id in log_files.keys() | artifact_files.keys()
+        }
+
+        # Update job run
+        for job_id, files in files_by_id.items():
+            self.primitive.jobs.job_run_update(id=job_id, file_ids=files)

{primitive-0.1.58 → primitive-0.1.60}/src/primitive/auth/actions.py

@@ -1,23 +1,16 @@
 from gql import gql
 
-from ..utils.config import read_config_file, update_config_file
-from ..utils.auth import guard
-
 from primitive.utils.actions import BaseAction
 
+from ..utils.auth import guard
+from ..utils.config import read_config_file, update_config_file
+from .graphql.queries import whoami_query
+
 
 class Auth(BaseAction):
     @guard
     def whoami(self):
-        query = gql(
-            """
-            query whoami {
-                whoami {
-                    username
-                }
-            }
-        """
-        )
+        query = gql(whoami_query)
 
         result = self.primitive.session.execute(query, get_execution_result=True)
 

primitive-0.1.60/src/primitive/auth/graphql/queries.py

@@ -0,0 +1,13 @@
+whoami_query = """
+query whoami {
+    whoami {
+        username
+        defaultOrganization {
+            id
+            pk
+            name
+            slug
+        }
+    }
+}
+"""

{primitive-0.1.58 → primitive-0.1.60}/src/primitive/cli.py

@@ -1,18 +1,22 @@
 import os
 import sys
+
 import click
+
 from .__about__ import __version__
-from .client import Primitive
+from .agent.commands import cli as agent_commands
 from .auth.commands import config_command, whoami_command
+from .client import Primitive
+from .daemons.commands import cli as daemons_commands
+from .exec.commands import cli as exec_commands
 from .files.commands import cli as file_commands
-from .hardware.commands import cli as hardware_commands
-from .lint.commands import cli as lint_commands
-from .agent.commands import cli as agent_commands
 from .git.commands import cli as git_commands
-from .daemons.commands import cli as daemons_commands
+from .hardware.commands import cli as hardware_commands
 from .jobs.commands import cli as jobs_commands
+from .lint.commands import cli as lint_commands
 from .organizations.commands import cli as organizations_commands
 from .projects.commands import cli as projects_commands
+from .reservations.commands import cli as reservations_commands
 from .sim.commands import cli as sim_commands
 
 
@@ -69,6 +73,8 @@ cli.add_command(jobs_commands, "jobs")
 cli.add_command(organizations_commands, "organizations")
 cli.add_command(projects_commands, "projects")
 cli.add_command(sim_commands, "sim")
+cli.add_command(reservations_commands, "reservations")
+cli.add_command(exec_commands, "exec")
 
 if __name__ == "__main__":
     cli(obj={})

{primitive-0.1.58 → primitive-0.1.60}/src/primitive/client.py

@@ -11,6 +11,8 @@ from .git.actions import Git
 from .daemons.actions import Daemons
 from .jobs.actions import Jobs
 from .organizations.actions import Organizations
+from .exec.actions import Exec
+from .reservations.actions import Reservations
 
 from loguru import logger
 
@@ -58,11 +60,13 @@ class Primitive:
         self.jobs: Jobs = Jobs(self)
         self.files: Files = Files(self)
         self.sim: Sim = Sim(self)
+        self.reservations: Reservations = Reservations(self)
         self.hardware: Hardware = Hardware(self)
         self.lint: Lint = Lint(self)
         self.agent: Agent = Agent(self)
         self.git: Git = Git(self)
         self.daemons: Daemons = Daemons(self)
+        self.exec: Exec = Exec(self)
 
     def get_host_config(self):
         self.full_config = read_config_file()

primitive-0.1.60/src/primitive/exec/actions.py

@@ -0,0 +1,50 @@
+import typing
+
+if typing.TYPE_CHECKING:
+    pass
+
+
+from primitive.utils.actions import BaseAction
+
+
+class Exec(BaseAction):
+    def __init__(self, *args, **kwargs) -> None:
+        super().__init__(*args, **kwargs)
+
+    def execute_command(self, hardware_identifier: str, command: str) -> None:
+        hardware = self.primitive.hardware.get_hardware_from_slug_or_id(
+            hardware_identifier=hardware_identifier
+        )
+
+        # since we found hardware, we need to check that the user:
+        # - has a valid reservation on it
+        # - OR if the device is free we can reserve it
+
+        # if we create a reservation on behalf of the user, we need to release it after
+        created_reservation_on_behalf_of_user = False
+
+        if active_reservation := hardware["activeReservation"]:
+            active_reservation_id = active_reservation["id"]
+            reservation_result = self.primitive.reservations.get_reservation(
+                reservation_id=active_reservation_id
+            )
+            reservation = reservation_result.data["reservation"]
+        else:
+            reservation_result = self.primitive.reservations.create_reservation(
+                requested_hardware_ids=[hardware["id"]],
+                reason="Executing command from Primitive CLI",
+            )
+            reservation = reservation_result.data["reservationCreate"]
+            created_reservation_on_behalf_of_user = True
+
+        reservation = self.primitive.reservations.wait_for_reservation_status(
+            reservation_id=reservation["id"], desired_status="in_progress"
+        )
+
+        print(f"Executing command: {command} on {hardware['name']}")
+
+        if created_reservation_on_behalf_of_user:
+            print("Cleaning up reservation.")
+            self.primitive.reservations.release_reservation(
+                reservation_or_hardware_identifier=reservation["id"]
+            )

primitive-0.1.60/src/primitive/exec/commands.py

@@ -0,0 +1,22 @@
+import typing
+
+import click
+
+if typing.TYPE_CHECKING:
+    from ..client import Primitive
+
+
+@click.command("exec")
+@click.pass_context
+@click.argument(
+    "hardware_identifier",
+    type=str,
+    required=True,
+)
+@click.argument("command", nargs=-1, required=True)
+def cli(context, hardware_identifier: str, command: str) -> None:
+    """Exec"""
+    primitive: Primitive = context.obj.get("PRIMITIVE")
+    primitive.exec.execute_command(
+        hardware_identifier=hardware_identifier, command=command
+    )

{primitive-0.1.58 → primitive-0.1.60}/src/primitive/files/actions.py

@@ -1,10 +1,13 @@
 from pathlib import Path
+
 from gql import gql
-from primitive.graphql.sdk import create_requests_session
-from ..utils.auth import guard
 
+from primitive.graphql.sdk import create_requests_session
 from primitive.utils.actions import BaseAction
 
+from ..utils.auth import guard
+from .graphql.mutations import create_trace_mutation
+
 
 class Files(BaseAction):
     @guard
@@ -17,19 +20,7 @@ class Files(BaseAction):
         is_vector: bool,
         size: int,
     ):
-        mutation = gql(
-            """
-            mutation createTrace($input: TraceCreateInput!) {
-                traceCreate(input: $input) {
-                    ... on Trace {
-                        id
-                        signalId
-                        signalName
-                    }
-                }
-            }
-        """
-        )
+        mutation = gql(create_trace_mutation)
         input = {
             "fileId": file_id,
             "signalId": signal_id,
@@ -39,7 +30,9 @@ class Files(BaseAction):
             "size": size,
         }
         variables = {"input": input}
-        result = self.primitive.session.execute(mutation, variable_values=variables)
+        result = self.primitive.session.execute(
+            mutation, variable_values=variables, get_execution_result=True
+        )
         return result
 
     @guard

primitive-0.1.60/src/primitive/files/graphql/mutations.py

@@ -0,0 +1,11 @@
+create_trace_mutation = """
+mutation createTrace($input: TraceCreateInput!) {
+    traceCreate(input: $input) {
+        ... on Trace {
+            id
+            signalId
+            signalName
+        }
+    }
+}
+"""

{primitive-0.1.58 → primitive-0.1.60}/src/primitive/git/actions.py

@@ -1,26 +1,26 @@
+import os
 from pathlib import Path
+
+from gql import gql
+from loguru import logger
+
 from primitive.utils.actions import BaseAction
+
 from ..utils.auth import guard
-from loguru import logger
-import os
+from .graphql.queries import github_app_token_query
 
 
 class Git(BaseAction):
     @guard
     def get_github_access_token(self) -> str:
-        query = """
-query githubAppToken{
-    githubAppToken {
-        token
-    }
-}
-"""
-
+        query = gql(github_app_token_query)
         filters = {}
         variables = {
             "filters": filters,
         }
-        result = self.primitive.session.execute(query, variable_values=variables)
+        result = self.primitive.session.execute(
+            query, variable_values=variables, get_execution_result=True
+        )
         return result
 
     def download_git_repository_at_ref(

{primitive-0.1.58 → primitive-0.1.60}/src/primitive/git/commands.py

@@ -1,8 +1,10 @@
-import click
-from pathlib import Path
+import os
 import typing
+from pathlib import Path
+
+import click
+
 from ..utils.printer import print_result
-import os
 
 if typing.TYPE_CHECKING:
     from ..client import Primitive
@@ -39,11 +41,10 @@ def download_ref_command(
     destination: Path = Path.cwd(),
 ):
     primitive: Primitive = context.obj.get("PRIMITIVE")
-    result, message = primitive.git.download_git_repository_at_ref(
+    path = primitive.git.download_git_repository_at_ref(
         git_repo_full_name=git_repo_full_name,
         git_ref=git_ref,
         github_access_token=github_access_token,
         destination=destination,
     )
-    fg = "red" if not result else "green"
-    print_result(message, context=context, fg=fg)
+    print_result(message=path, context=context)

primitive-0.1.60/src/primitive/git/graphql/queries.py

@@ -0,0 +1,7 @@
+github_app_token_query = """
+query githubAppToken{
+    githubAppToken {
+        token
+    }
+}
+"""

primitive-0.1.60/src/primitive/graphql/relay.py

@@ -0,0 +1,32 @@
+import base64
+from typing import Tuple
+
+
+def from_base64(value: str) -> Tuple[str, str]:
+    """
+    FROM:
+    https://github.com/strawberry-graphql/strawberry/blob/main/strawberry/relay/utils.py#L16C1-L40C1
+
+    Parse the base64 encoded relay value.
+
+    Args:
+        value:
+            The value to be parsed
+
+    Returns:
+        A tuple of (TypeName, NodeID).
+
+    Raises:
+        ValueError:
+            If the value is not in the expected format
+
+    """
+    try:
+        res = base64.b64decode(value.encode()).decode().split(":", 1)
+    except Exception as e:
+        raise ValueError(str(e)) from e
+
+    if len(res) != 2:
+        raise ValueError(f"{res} expected to contain only 2 items")
+
+    return res[0], res[1]