primitive 0.2.5__tar.gz → 0.2.7__tar.gz

{primitive-0.2.5 → primitive-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: primitive
-Version: 0.2.5
+Version: 0.2.7
 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.2.5 → primitive-0.2.7}/src/primitive/__about__.py

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

{primitive-0.2.5 → primitive-0.2.7}/src/primitive/agent/runner.py

@@ -2,6 +2,7 @@ import os
 import re
 import typing
 import shutil
+import time
 from typing import Dict, TypedDict, List
 from abc import abstractmethod
 from enum import IntEnum, Enum
@@ -155,18 +156,22 @@ class Runner:
         self.modified_env = {**self.initial_env}
 
         task_failed = False
+        conclusion = "success"
         for task in self.config["executes"]:
             with logger.contextualize(label=task["label"]):
                 with asyncio.Runner() as async_runner:
                     if task_failed := async_runner.run(self.run_task(task)):
                         break
 
-        if not task_failed:
-            self.primitive.jobs.job_run_update(
-                self.job_run["id"], status="request_completed", conclusion="success"
-            )
+        if task_failed:
+            conclusion = "failure"
+        else:
             logger.success(f"Completed {self.job['slug']} job")
 
+        self.primitive.jobs.job_run_update(
+            self.job_run["id"], status="request_completed", conclusion=conclusion
+        )
+
     async def run_task(self, task: Task) -> bool:
         for cmd in task["cmd"].strip().split("\n"):
             # Adding an additional echo and utilizing stdbuf to force line buffering
@@ -191,6 +196,9 @@ class Runner:
                 stderr=asyncio.subprocess.PIPE,
             )
 
+            loop = asyncio.get_running_loop()
+            monitor_task = loop.run_in_executor(None, self.monitor_cmd, process)
+
             stdout_failed, stderr_failed, cancelled = await asyncio.gather(
                 self.log_cmd(
                     process=process, stream=process.stdout, tags=task.get("tags", {})
@@ -198,26 +206,22 @@ class Runner:
                 self.log_cmd(
                     process=process, stream=process.stderr, tags=task.get("tags", {})
                 ),
-                asyncio.create_task(self.monitor_cmd(process=process)),
+                monitor_task,
             )
 
             returncode = await process.wait()
 
             if cancelled:
+                logger.warning("Job cancelled by user")
                 return True
 
-            if returncode > 0 or stdout_failed or stderr_failed:
-                await self.primitive.jobs.ajob_run_update(
-                    self.job_run["id"], status="request_completed", conclusion="failure"
+            if returncode > 0:
+                logger.error(
+                    f"Task {task['label']} failed on '{cmd}' with return code {returncode}"
                 )
-
-                if returncode > 0:
-                    logger.error(
-                        f"Task {task['label']} failed on '{cmd}' with return code {returncode}"
-                    )
-                else:
-                    logger.error(f"Task {task['label']} failed on '{cmd}'")
-
+                return True
+            elif stdout_failed or stderr_failed:
+                logger.error(f"Task {task['label']} failed on '{cmd}'")
                 return True
 
         return False
@@ -298,14 +302,14 @@ class Runner:
 
         return [line for line in lines if len(line) > 0]
 
-    async def monitor_cmd(self, process) -> bool:
+    def monitor_cmd(self, process) -> bool:
         while process.returncode is None:
-            status = await self.primitive.jobs.aget_job_status(self.job_run["id"])
+            status = self.primitive.jobs.get_job_status(self.job_run["id"])
+
             status_value = status.data["jobRun"]["status"]
             conclusion_value = status.data["jobRun"]["conclusion"]
 
             if status_value == "completed" and conclusion_value == "cancelled":
-                logger.warning("Job cancelled by user")
                 try:
                     process.terminate()
                 except ProcessLookupError:
@@ -313,7 +317,7 @@ class Runner:
 
                 return True
 
-            await asyncio.sleep(5)
+            time.sleep(5)
 
         return False
 

{primitive-0.2.5 → primitive-0.2.7}/src/primitive/graphql/sdk.py

@@ -28,8 +28,7 @@ def create_session(
 
     transport = AIOHTTPTransport(url=url, headers=headers)
     session = Client(
-        transport=transport,
-        fetch_schema_from_transport=fetch_schema_from_transport,
+        transport=transport, fetch_schema_from_transport=fetch_schema_from_transport
     )
     return session
 

{primitive-0.2.5 → primitive-0.2.7}/src/primitive/jobs/actions.py

@@ -128,30 +128,6 @@ class Jobs(BaseAction):
         )
         return result
 
-    @guard
-    async def ajob_run_update(
-        self,
-        id: str,
-        status: str = None,
-        conclusion: str = None,
-        file_ids: Optional[List[str]] = [],
-    ):
-        mutation = gql(job_run_update_mutation)
-        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
-        variables = {"input": input}
-
-        async with self.primitive.session as session:
-            result = await session.execute(
-                mutation, variable_values=variables, get_execution_result=True
-            )
-        return result
-
     @guard
     def github_access_token_for_job_run(self, job_run_id: str):
         query = gql(github_app_token_for_job_run_query)
@@ -184,14 +160,3 @@ class Jobs(BaseAction):
             query, variable_values=variables, get_execution_result=True
         )
         return result
-
-    @guard
-    async def aget_job_status(self, id: str):
-        query = gql(job_run_status_query)
-        variables = {"id": id}
-
-        async with self.primitive.session as session:
-            result = await session.execute(
-                query, variable_values=variables, get_execution_result=True
-            )
-        return result