arcaflow-plugin-sdk 0.13.0__tar.gz → 0.14.0.dev1__tar.gz

{arcaflow_plugin_sdk-0.13.0 → arcaflow_plugin_sdk-0.14.0.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arcaflow-plugin-sdk
-Version: 0.13.0
+Version: 0.14.0.dev1
 Summary: Plugin SDK for Python for the Arcaflow workflow engine
 Home-page: https://github.com/arcalot/arcaflow-plugin-sdk-python
 License: Apache-2.0
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3
 Requires-Dist: PyYAML (>=6.0.1,<6.1.0)
-Requires-Dist: cbor2 (>=5.5.0,<5.6.0)
+Requires-Dist: cbor2 (>=5.6.0,<5.7.0)
 Project-URL: Bug Tracker, https://github.com/arcalot/arcaflow-plugin-sdk-python/issues
 Description-Content-Type: text/markdown
 

{arcaflow_plugin_sdk-0.13.0 → arcaflow_plugin_sdk-0.14.0.dev1}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "arcaflow-plugin-sdk"
 # Do not change, the version is automatically updated in CI.
-version = "0.13.0"
+version = "v0.14.0-dev1"
 description = "Plugin SDK for Python for the Arcaflow workflow engine"
 authors = ["Arcalot Contributors"]
 license = "Apache-2.0"
@@ -19,15 +19,30 @@ homepage = "https://github.com/arcalot/arcaflow-plugin-sdk-python"
 
 [tool.poetry.dependencies]
 python = "^3.9"
-cbor2 = "~5.5.0"
+cbor2 = "~5.6.0"
 PyYAML = "~6.0.1"
 
 [tool.poetry.group.dev.dependencies]
 coverage = "^7.0.0"
-html2text = "^2020.1.16"
+html2text = "^2024.0.0"
 pre-commit = "^3.0.0"
 sphinx = "^7.0.0"
-sphinx-rtd-theme = "^1.1.1"
+sphinx-rtd-theme = "^2.0.0"
+isort = "^5.12.0"
+black = "^24.0.0"
+autoflake = "^2.2.1"
+docformatter = "^1.7.5"
+flake8 = "^7.0.0"
+autopep8 = "^2.0.4"
+pytest-repeat = "^0.9.3"
+
+[tool.isort]
+profile = 'black'
+
+[tool.docformatter]
+recursive = true
+wrap-summaries = 79
+wrap-descriptions = 79
 
 
 [build-system]

{arcaflow_plugin_sdk-0.13.0 → arcaflow_plugin_sdk-0.14.0.dev1}/src/arcaflow_plugin_sdk/atp.py

@@ -1,7 +1,7 @@
-"""
-The Arcaflow Transport Protocol is a protocol to communicate between the Engine and a plugin. This library provides
-the services to do so. The main use-case is running over STDIO, so the communication protocol is designed to run 1:1,
-it is not possible to use multiple clients (engines) with a plugin.
+"""The Arcaflow Transport Protocol is a protocol to communicate between the
+Engine and a plugin. This library provides the services to do so. The main use-
+case is running over STDIO, so the communication protocol is designed to run
+1:1, it is not possible to use multiple clients (engines) with a plugin.
 
 The message flow is as follows:
 
@@ -31,10 +31,11 @@ ATP_SERVER_VERSION = 3
 
 
 class MessageType(IntEnum):
-    """
-    An integer ID that indicates the type of runtime message that is stored
-    in the data field. The corresponding class can then be used to deserialize
-    the inner data. Look at the go SDK for the reference data structure.
+    """An integer ID that indicates the type of runtime message that is stored
+    in the data field.
+
+    The corresponding class can then be used to deserialize the inner data.
+    Look at the go SDK for the reference data structure.
     """
 
     WORK_START = 1
@@ -46,9 +47,8 @@ class MessageType(IntEnum):
 
 @dataclasses.dataclass
 class HelloMessage:
-    """
-    This message is the initial greeting message a plugin sends to the output.
-    """
+    """This message is the initial greeting message a plugin sends to the
+    output."""
 
     version: typing.Annotated[
         int,
@@ -60,8 +60,8 @@ class HelloMessage:
         schema.Schema,
         schema.name("Schema"),
         schema.description(
-            "Schema information describing the required inputs and outputs, as well as the steps offered by this "
-            "plugin."
+            "Schema information describing the required inputs and outputs, as"
+            " well as the steps offered by this plugin."
         ),
     ]
 
@@ -98,9 +98,7 @@ class ATPServer:
         self,
         plugin_schema: schema.SchemaType,
     ) -> int:
-        """
-        This function wraps running a plugin.
-        """
+        """This function wraps running a plugin."""
         signal.signal(
             signal.SIGINT, signal.SIG_IGN
         )  # Ignore sigint. Only care about arcaflow signals.
@@ -112,7 +110,8 @@ class ATPServer:
         self.plugin_schema = plugin_schema
         self.handle_handshake()
 
-        # First replace stdout so that prints are handled by us, instead of potentially interfering with the atp pipes.
+        # First replace stdout so that prints are handled by us, instead of
+        # potentially interfering with the atp pipes.
         original_stdout = sys.stdout
         original_stderr = sys.stderr
         self.user_out_buffer = io.StringIO()
@@ -121,11 +120,13 @@ class ATPServer:
 
         # Run the read loop. This blocks to wait for the loop to finish.
         self.run_server_read_loop()
-        # Wait for the step/signal threads to finish. If it gets stuck here then there is another thread blocked.
+        # Wait for the step/signal threads to finish. If it gets stuck here
+        # then there is another thread blocked.
         for thread in self.running_threads:
             thread.join()
 
-        # Don't reset stdout/stderr until after the read and step/signal threads are done.
+        # Don't reset stdout/stderr until after the read and step/signal
+        # threads are done.
         sys.stdout = original_stdout
         sys.stderr = original_stderr
 
@@ -136,8 +137,12 @@ class ATPServer:
         self.decoder.decode()
 
         # Serialize then send HelloMessage
-        start_hello_message = HelloMessage(ATP_SERVER_VERSION, self.plugin_schema)
-        serialized_message = _HELLO_MESSAGE_SCHEMA.serialize(start_hello_message)
+        start_hello_message = HelloMessage(
+            ATP_SERVER_VERSION, self.plugin_schema
+        )
+        serialized_message = _HELLO_MESSAGE_SCHEMA.serialize(
+            start_hello_message
+        )
         self.send_message(serialized_message)
 
     def run_server_read_loop(self) -> None:
@@ -166,8 +171,10 @@ class ATPServer:
                             run_id,
                             step_fatal=True,
                             server_fatal=False,
-                            error_msg="Exception while handling work start: "
-                            f"{e} {traceback.format_exc()}",
+                            error_msg=(
+                                "Exception while handling work start: "
+                                f"{e} {traceback.format_exc()}"
+                            ),
                         )
                 elif msg_id == MessageType.SIGNAL:
                     signal_msg = runtime_msg["data"]
@@ -178,7 +185,10 @@ class ATPServer:
                             run_id,
                             step_fatal=False,
                             server_fatal=False,
-                            error_msg=f"Exception while handling signal: {e} {traceback.format_exc()}",
+                            error_msg=(
+                                "Exception while handling signal:"
+                                f" {e} {traceback.format_exc()}"
+                            ),
                         )
                 elif msg_id == MessageType.CLIENT_DONE:
                     return
@@ -189,41 +199,63 @@ class ATPServer:
                         server_fatal=False,
                         error_msg=f"Unknown runtime message ID: {msg_id}",
                     )
-                    self.stderr.write(f"Unknown kind of runtime message: {msg_id}")
+                    self.stderr.write(bytes(
+                        f"Unknown kind of runtime message: {msg_id}",
+                        encoding="utf")
+                    )
 
         except cbor2.CBORDecodeError as err:
-            self.stderr.write(f"Error while decoding CBOR: {err}")
+            self.stderr.write(bytes(
+                f"Error while decoding CBOR: {err}", encoding="utf"))
             self.send_error_message(
                 "",
                 step_fatal=False,
                 server_fatal=True,
-                error_msg=f"Error occurred while decoding CBOR: {err} {traceback.format_exc()}",
+                error_msg=(
+                    "Error occurred while decoding CBOR:"
+                    f" {err} {traceback.format_exc()}"
+                ),
             )
         except Exception as e:
             self.send_error_message(
                 "",
                 step_fatal=False,
                 server_fatal=True,
-                error_msg=f"Exception occurred in ATP server read loop: {e} {traceback.format_exc()}",
+                error_msg=(
+                    "Exception occurred in ATP server read loop:"
+                    f" {e} {traceback.format_exc()}"
+                ),
             )
 
     def handle_signal(self, run_id, signal_msg):
         saved_step_id = self.step_ids[run_id]
         received_signal_id = signal_msg["signal_id"]
 
-        unserialized_data = self.plugin_schema.unserialize_signal_handler_input(
-            saved_step_id, received_signal_id, signal_msg["data"]
+        unserialized_data = (
+            self.plugin_schema.unserialize_signal_handler_input(
+                saved_step_id, received_signal_id, signal_msg["data"]
+            )
         )
-        # The data is verified and unserialized. Now call the signal in its own thread.
+        # The data is verified and unserialized. Now call the signal in its own
+        # thread.
         run_thread = threading.Thread(
             target=self.run_signal,
-            args=(run_id, saved_step_id, received_signal_id, unserialized_data),
+            args=(
+                run_id,
+                saved_step_id,
+                received_signal_id,
+                unserialized_data,
+            ),
         )
         self.running_threads.append(run_thread)
         run_thread.start()
 
     def run_signal(
-        self, run_id: str, step_id: str, signal_id: str, unserialized_input_param: any
+        self,
+        run_id: str,
+        step_id: str,
+        signal_id: str,
+        unserialized_input_param: any,
     ):
         try:
             self.plugin_schema.call_step_signal(
@@ -234,11 +266,15 @@ class ATPServer:
                 run_id,
                 step_fatal=False,
                 server_fatal=False,
-                error_msg=f"Error while calling signal for step with run ID {run_id}: {e} "
-                f"{traceback.format_exc()}",
+                error_msg=(
+                    "Error while calling signal for step with run ID"
+                    f" {run_id}: {e} {traceback.format_exc()}"
+                ),
             )
 
-    def handle_work_start(self, run_id: str, work_start_msg: typing.Dict[str, any]):
+    def handle_work_start(
+        self, run_id: str, work_start_msg: typing.Dict[str, any]
+    ):
         if work_start_msg is None:
             self.send_error_message(
                 run_id,
@@ -305,8 +341,10 @@ class ATPServer:
                 run_id,
                 step_fatal=True,
                 server_fatal=False,
-                error_msg=f"Error while calling step {run_id}/{step_id}:"
-                f"{e} {traceback.format_exc()}",
+                error_msg=(
+                    f"Error while calling step {run_id}/{step_id}:"
+                    f"{e} {traceback.format_exc()}"
+                ),
             )
             return
 
@@ -315,7 +353,9 @@ class ATPServer:
             self.encoder.encode(data)
             self.output_pipe.flush()  # Sends it to the ATP client immediately.
 
-    def send_runtime_message(self, message_type: MessageType, run_id: str, data: any):
+    def send_runtime_message(
+        self, message_type: MessageType, run_id: str, data: any
+    ):
         self.send_message(
             {
                 "id": message_type,
@@ -339,9 +379,8 @@ class ATPServer:
 
 
 class PluginClientStateException(Exception):
-    """
-    This exception is for client ATP client errors, like problems decoding
-    """
+    """This exception is for client ATP client errors, like problems
+    decoding."""
 
     msg: str
 
@@ -361,9 +400,10 @@ class StepResult:
 
 
 class PluginClient:
-    """
-    This is a rudimentary client that reads information from a plugin and starts work on the plugin. The functions
-    must be executed in order.
+    """This is a rudimentary client that reads information from a plugin and
+    starts work on the plugin.
+
+    The functions must be executed in order.
     """
 
     to_server_pipe: io.FileIO  # Usually the stdin of the sub-process
@@ -384,16 +424,13 @@ class PluginClient:
         self.encoder.encode(None)
 
     def read_hello(self) -> HelloMessage:
-        """
-        This function reads the initial "Hello" message from the plugin.
-        """
+        """This function reads the initial "Hello" message from the plugin."""
         message = self.decoder.decode()
         return _HELLO_MESSAGE_SCHEMA.unserialize(message)
 
     def start_work(self, run_id: str, step_id: str, config: any):
-        """
-        After the Hello message has been read, this function starts work in a plugin with the specified data.
-        """
+        """After the Hello message has been read, this function starts work in
+        a plugin with the specified data."""
         self.send_runtime_message(
             MessageType.WORK_START,
             run_id,
@@ -404,9 +441,7 @@ class PluginClient:
         )
 
     def send_signal(self, run_id: str, signal_id: str, input_data: any):
-        """
-        This function sends any signals to the plugin.
-        """
+        """This function sends any signals to the plugin."""
         self.send_runtime_message(
             MessageType.SIGNAL,
             run_id,
@@ -419,7 +454,9 @@ class PluginClient:
     def send_client_done(self):
         self.send_runtime_message(MessageType.CLIENT_DONE, "", {})
 
-    def send_runtime_message(self, message_type: MessageType, run_id: str, data: any):
+    def send_runtime_message(
+        self, message_type: MessageType, run_id: str, data: any
+    ):
         self.encoder.encode(
             {
                 "id": message_type,
@@ -430,9 +467,8 @@ class PluginClient:
         self.to_server_pipe.flush()
 
     def read_single_result(self) -> StepResult:
-        """
-        This function reads until it gets the next result of an execution from the plugin, or an error.
-        """
+        """This function reads until it gets the next result of an execution
+        from the plugin, or an error."""
         while True:
             runtime_msg = self.decoder.decode()
             msg_id = runtime_msg["id"]
@@ -440,15 +476,18 @@ class PluginClient:
                 signal_msg = runtime_msg["data"]
                 if signal_msg["output_id"] is None:
                     raise PluginClientStateException(
-                        "Missing 'output_id' in CBOR message. Possibly wrong order of calls?"
+                        "Missing 'output_id' in CBOR message. Possibly wrong"
+                        " order of calls?"
                     )
                 if signal_msg["output_data"] is None:
                     raise PluginClientStateException(
-                        "Missing 'output_data' in CBOR message. Possibly wrong order of calls?"
+                        "Missing 'output_data' in CBOR message. Possibly wrong"
+                        " order of calls?"
                     )
                 if signal_msg["debug_logs"] is None:
                     raise PluginClientStateException(
-                        "Missing 'output_data' in CBOR message. Possibly wrong order of calls?"
+                        "Missing 'output_data' in CBOR message. Possibly wrong"
+                        " order of calls?"
                     )
                 return StepResult(
                     run_id=runtime_msg["run_id"],

{arcaflow_plugin_sdk-0.13.0 → arcaflow_plugin_sdk-0.14.0.dev1}/src/arcaflow_plugin_sdk/jsonschema.py

@@ -2,8 +2,9 @@ from arcaflow_plugin_sdk import schema
 
 
 def step_input(t: schema.StepSchema) -> dict:
-    """
-    This function takes a schema step and creates a JSON schema object from the input parameter.
+    """This function takes a schema step and creates a JSON schema object from
+    the input parameter.
+
     :return: the JSON schema represented as a dict.
     """
     result = t.input.to_jsonschema()
@@ -15,8 +16,9 @@ def step_input(t: schema.StepSchema) -> dict:
 
 
 def step_outputs(t: schema.StepSchema):
-    """
-    This function takes a schema step and creates a JSON schema object from the output parameters.
+    """This function takes a schema step and creates a JSON schema object from
+    the output parameters.
+
     :return: the JSON schema represented as a dict.
     """
     result = {