primitive 0.1.13__py3-none-any.whl → 0.1.15__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.13"
+__version__ = "0.1.15"

primitive/agent/actions.py

@@ -32,7 +32,7 @@ class Agent(BaseAction):
                     sleep(5)
                     continue
 
-                job_runs_data = self.primitive.projects.get_job_runs(
+                job_runs_data = self.primitive.jobs.get_job_runs(
                     status="pending", first=1, reservation_id=active_reservation_id
                 )
 
@@ -52,7 +52,7 @@ class Agent(BaseAction):
                     )
 
                     github_access_token = (
-                        self.primitive.projects.github_access_token_for_job_run(
+                        self.primitive.jobs.github_access_token_for_job_run(
                             job_run["id"]
                         )
                     )
@@ -65,28 +65,59 @@ class Agent(BaseAction):
                         )
                     )
 
-                    if job_run["job"]["slug"] == "lint":
-                        logger.debug("Executing Lint Job")
-
-                        self.primitive.projects.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.projects.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/cli.py

@@ -10,6 +10,10 @@ 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 .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()
@@ -61,6 +65,10 @@ cli.add_command(lint_commands, "lint")
 cli.add_command(agent_commands, "agent")
 cli.add_command(git_commands, "git")
 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/client.py

@@ -4,12 +4,14 @@ 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
 from .git.actions import Git
 from .daemons.actions import Daemons
+from .jobs.actions import Jobs
+from .organizations.actions import Organizations
 
 from loguru import logger
 
@@ -55,9 +57,11 @@ class Primitive:
         )
 
         self.auth: Auth = Auth(self)
+        self.organizations: Organizations = Organizations(self)
         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/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/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/jobs/actions.py

@@ -0,0 +1,307 @@
+from typing import List, Optional
+from gql import gql
+
+
+from primitive.utils.actions import BaseAction
+
+
+class Jobs(BaseAction):
+    def get_jobs(
+        self,
+        organization_id: Optional[str] = None,
+        project_id: Optional[str] = None,
+        job_id: Optional[str] = None,
+        slug: Optional[str] = None,
+        first: Optional[int] = 1,
+        last: Optional[int] = None,
+    ):
+        query = gql(
+            """ 
+            fragment PageInfoFragment on PageInfo {
+                hasNextPage
+                hasPreviousPage
+                startCursor
+                endCursor
+            }
+
+            fragment JobFragment on Job {
+                id
+                pk
+                slug
+                name
+                createdAt
+                updatedAt
+            }
+
+            query jobs(
+                $before: String
+                $after: String
+                $first: Int
+                $last: Int
+                $filters: JobFilters
+            ) {
+                jobs(
+                    before: $before
+                    after: $after
+                    first: $first
+                    last: $last
+                    filters: $filters
+                ) {
+                    totalCount
+                    pageInfo {
+                        ...PageInfoFragment
+                    }
+                    edges {
+                        cursor
+                        node {
+                            ...JobFragment
+                        }
+                    }
+                }
+            }
+            """
+        )
+
+        filters = {}
+        if organization_id:
+            filters["organization"] = {"id": organization_id}
+        if project_id:
+            filters["project"] = {"id": project_id}
+        if job_id:
+            filters["id"] = job_id
+        if slug:
+            filters["slug"] = {"exact": slug}
+
+        variables = {
+            "first": first,
+            "last": last,
+            "filters": filters,
+            "order": {
+                "createdAt": "DESC",
+            },
+        }
+
+        result = self.primitive.session.execute(
+            query, variable_values=variables, get_execution_result=True
+        )
+        jobs = [edge["node"] for edge in result.data["jobs"]["edges"]]
+        return jobs
+
+    def get_job_runs(
+        self,
+        organization_id: Optional[str] = None,
+        project_id: Optional[str] = None,
+        job_id: Optional[str] = None,
+        reservation_id: Optional[str] = None,
+        git_commit_id: Optional[str] = None,
+        status: Optional[str] = None,
+        conclusion: Optional[str] = None,
+        first: Optional[int] = 1,
+        last: Optional[int] = None,
+    ):
+        query = gql(
+            """
+fragment PageInfoFragment on PageInfo {
+  hasNextPage
+  hasPreviousPage
+  startCursor
+  endCursor
+}
+
+fragment JobRunFragment on JobRun {
+  id
+  pk
+  createdAt
+  updatedAt
+  completedAt
+  startedAt
+  status
+  conclusion
+  stdout
+  job {
+    id
+    pk
+    slug
+    name
+    createdAt
+    updatedAt
+  } 
+  jobSettings {
+    containerArgs
+    containerCommand
+  }
+  gitCommit {
+    sha
+    branch
+    repoFullName
+  }
+}
+
+query jobRuns(
+  $before: String
+  $after: String
+  $first: Int
+  $last: Int
+  $filters: JobRunFilters
+  $order: JobRunOrder
+) {
+  jobRuns(
+    before: $before
+    after: $after
+    first: $first
+    last: $last
+    filters: $filters
+    order: $order
+  ) {
+    totalCount
+    pageInfo {
+      ...PageInfoFragment
+    }
+    edges {
+      cursor
+      node {
+        ...JobRunFragment
+      }
+    }
+  }
+}
+"""
+        )
+
+        filters = {}
+        if organization_id:
+            filters["organization"] = {"id": organization_id}
+        if project_id:
+            filters["project"] = {"id": project_id}
+        if job_id:
+            filters["job"] = {"id": job_id}
+        if reservation_id:
+            filters["reservation"] = {"id": reservation_id}
+        if git_commit_id:
+            filters["gitCommit"] = {"id": git_commit_id}
+        if status:
+            filters["status"] = {"exact": status}
+        if conclusion:
+            filters["conclusion"] = {"exact": status}
+
+        variables = {
+            "first": first,
+            "last": last,
+            "filters": filters,
+            "order": {
+                "createdAt": "DESC",
+            },
+        }
+
+        result = self.primitive.session.execute(query, variable_values=variables)
+        return result
+
+    def get_job_run(self, id: str):
+        query = gql(
+            """
+            fragment JobRunFragment on JobRun {
+                id
+                pk
+                createdAt
+                updatedAt
+                completedAt
+                startedAt
+                status
+                conclusion
+                stdout
+                job {
+                    id
+                    pk
+                    slug
+                    name
+                    createdAt
+                    updatedAt
+                }
+                gitCommit {
+                    sha
+                    branch
+                    repoFullName
+                }
+            }
+
+            query jobRun($id: GlobalID!) {
+                jobRun(id: $id) {
+                    ...JobRunFragment
+                }
+            }
+            """
+        )
+        variables = {"id": id}
+        result = self.primitive.session.execute(query, variable_values=variables)
+        return result
+
+    def job_run_update(
+        self,
+        id: str,
+        status: str = None,
+        conclusion: str = None,
+        stdout: str = None,
+        file_ids: Optional[List[str]] = [],
+    ):
+        mutation = gql(
+            """
+            mutation jobRunUpdate($input: JobRunUpdateInput!) {
+                jobRunUpdate(input: $input) {
+                    ... on JobRun {
+                        id
+                        status
+                        conclusion
+                    }
+                }
+            }
+        """
+        )
+        input = {"id": id}
+        if status:
+            input["status"] = status
+        if conclusion:
+            input["conclusion"] = conclusion
+        if file_ids and len(file_ids) > 0:
+            input["files"] = file_ids
+        if stdout:
+            input["stdout"] = stdout
+        variables = {"input": input}
+        result = self.primitive.session.execute(mutation, variable_values=variables)
+        return result
+
+    def github_access_token_for_job_run(self, job_run_id: str):
+        query = gql(
+            """
+query ghAppTokenForJobRun($jobRunId: GlobalID!) {
+    ghAppTokenForJobRun(jobRunId: $jobRunId)
+}
+"""
+        )
+        variables = {"jobRunId": job_run_id}
+        result = self.primitive.session.execute(query, variable_values=variables)
+        return result["ghAppTokenForJobRun"]
+
+    def get_latest_job_run_for_job(
+        self, job_slug: Optional[str] = None, job_id: Optional[str] = None
+    ):
+        if not job_slug and not job_id:
+            raise ValueError("job_slug or job_id is required")
+        jobs_results = self.get_jobs(slug=job_slug)
+        jobs = [edge["node"] for edge in jobs_results.data["jobs"]["edges"]]
+
+        job_id = jobs.id
+        job_run_results = self.get_job_runs(job_id=job_id, first=1)
+        job_run = [edge["node"] for edge in job_run_results.data["job_runs"]["edges"]][
+            0
+        ]
+        return job_run
+
+    def job_run_start(
+        self,
+        job_slug: str,
+        job_id: str,
+    ):
+        if not job_slug and not job_id:
+            raise ValueError("job_slug or job_id is required")
+
+        self.get_jobs(slug=job_slug)

primitive/jobs/commands.py

@@ -0,0 +1,41 @@
+import click
+
+from ..utils.printer import print_result
+
+import typing
+
+if typing.TYPE_CHECKING:
+    from ..client import Primitive
+
+
+@click.group()
+@click.pass_context
+def cli(context):
+    """Jobs Commands"""
+    pass
+
+
+@cli.command("list")
+@click.pass_context
+def list(
+    context,
+    organization_slug: str = None,
+    organization_id: str = None,
+):
+    """List Job"""
+    primitive: Primitive = context.obj.get("PRIMITIVE")
+    message = primitive.jobs.get_jobs()
+    print_result(message=message, context=context)
+
+
+@cli.command("details")
+@click.argument("job_slug")
+@click.pass_context
+def details(
+    context,
+    job_slug: str = None,
+):
+    """List Job"""
+    primitive: Primitive = context.obj.get("PRIMITIVE")
+    message = primitive.jobs.get_jobs(slug=job_slug)
+    print_result(message=message, context=context)

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/organizations/actions.py

@@ -0,0 +1,84 @@
+from typing import Optional
+from gql import gql
+
+
+from primitive.utils.actions import BaseAction
+
+
+class Organizations(BaseAction):
+    def get_organizations(
+        self,
+        organization_id: Optional[str] = None,
+        slug: Optional[str] = None,
+        first: Optional[int] = 1,
+        last: Optional[int] = None,
+    ):
+        query = gql(
+            """ 
+            fragment PageInfoFragment on PageInfo {
+                hasNextPage
+                hasPreviousPage
+                startCursor
+                endCursor
+            }
+
+            fragment OrganizationFragment on Organization {
+                id
+                pk
+                slug
+                name
+                createdAt
+                updatedAt
+            }
+
+            query organizations(
+                $before: String
+                $after: String
+                $first: Int
+                $last: Int
+                $filters: OrganizationFilters
+                $order: OrganizationOrder
+            ) {
+                organizations(
+                    before: $before
+                    after: $after
+                    first: $first
+                    last: $last
+                    filters: $filters
+                    order: $order
+                ) {
+                    totalCount
+                    pageInfo {
+                        ...PageInfoFragment
+                    }
+                    edges {
+                        cursor
+                        node {
+                            ...OrganizationFragment
+                        }
+                    }
+                }
+            }
+            """
+        )
+
+        filters = {}
+        if organization_id:
+            filters["organization"] = {"id": organization_id}
+        if slug:
+            filters["slug"] = {"exact": slug}
+
+        variables = {
+            "first": first,
+            "last": last,
+            "filters": filters,
+            "order": {
+                "createdAt": "DESC",
+            },
+        }
+
+        result = self.primitive.session.execute(
+            query, variable_values=variables, get_execution_result=True
+        )
+        organizations = [edge["node"] for edge in result.data["organizations"]["edges"]]
+        return organizations

primitive/organizations/commands.py

@@ -0,0 +1,24 @@
+import click
+
+from ..utils.printer import print_result
+
+import typing
+
+if typing.TYPE_CHECKING:
+    from ..client import Primitive
+
+
+@click.group()
+@click.pass_context
+def cli(context):
+    """Organizations Commands"""
+    pass
+
+
+@cli.command("list")
+@click.pass_context
+def details(context):
+    """List Organizations"""
+    primitive: Primitive = context.obj.get("PRIMITIVE")
+    message = primitive.organizations.get_organizations()
+    print_result(message=message, context=context)