qctrl-workflow-client 3.0.0__tar.gz → 3.1.0__tar.gz

{qctrl_workflow_client-3.0.0 → qctrl_workflow_client-3.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qctrl-workflow-client
-Version: 3.0.0
+Version: 3.1.0
 Summary: Q-CTRL Client
 Home-page: https://q-ctrl.com
 License: https://q-ctrl.com/terms
@@ -33,7 +33,7 @@ Requires-Dist: importlib-metadata (>=6.8.0,<7.0.0)
 Requires-Dist: packaging (>=23.1.0,<24.0.0)
 Requires-Dist: qctrl-client (>=9.1.0,<10.0.0)
 Requires-Dist: qctrl-commons (>=22.0.0,<23.0.0)
-Requires-Dist: requests (>=2.31.0,<3.0.0)
+Requires-Dist: requests (>=2.32.0,<3.0.0)
 Requires-Dist: tenacity (>=8.1.0,<9.0.0)
 Requires-Dist: tomli (>=2.0.1,<3.0.0)
 Project-URL: Documentation, https://docs.q-ctrl.com

{qctrl_workflow_client-3.0.0 → qctrl_workflow_client-3.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "qctrl-workflow-client"
-version = "3.0.0"
+version = "3.1.0"
 description = "Q-CTRL Client"
 license = "https://q-ctrl.com/terms"
 authors = ["Q-CTRL <support@q-ctrl.com>"]
@@ -79,13 +79,13 @@ tomli = "^2.0.1"
 importlib-metadata = "^6.8.0"
 gql = "^3.4.0"
 tenacity = "^8.1.0"
-requests = "^2.31.0"
+requests = "^2.32.0"
 packaging = "^23.1.0"
 qctrl-commons = { version = "^22.0.0", source = "PyPI" }
 qctrl-client = { version = "^9.1.0", source = "PyPI" }
 
 [tool.poetry.group.dev.dependencies]
-black = "^23.7.0"
+black = "^24.3.0"
 isort = "^5.12.0"
 pre-commit = "^3.3.3"
 pylint = "^2.14.4"

{qctrl_workflow_client-3.0.0 → qctrl_workflow_client-3.1.0}/qctrlworkflowclient/__init__.py

@@ -11,7 +11,7 @@
 # distributed under the License is distributed on an "AS IS" BASIS. See the
 # License for the specific language.
 
-__version__ = "3.0.0"
+__version__ = "3.1.0"
 
 from .defaults import (
     get_authenticated_client_for_product,

{qctrl_workflow_client-3.0.0 → qctrl_workflow_client-3.1.0}/qctrlworkflowclient/functions.py

@@ -20,6 +20,8 @@ from typing import (
 )
 from warnings import warn
 
+from qctrlcommons.exceptions import QctrlArgumentsValueError
+
 
 def core_workflow(
     get_config: Callable, workflow: str, formatter: Optional[Callable] = None
@@ -61,6 +63,71 @@ def core_workflow(
             # the function
             config = get_config()
             router = config.get_router()
+
+            router.set_async_state(kwargs.pop("is_async", False))
+
+            data = func(*args, **kwargs)
+            result = router(workflow, data)
+
+            if formatter:
+                result = formatter(result)
+
+            return result
+
+        return customized_decorator
+
+    return decorator
+
+
+def async_core_workflow(
+    get_config: Callable, workflow: str, formatter: Optional[Callable] = None
+):
+    """
+    Decorator for a function which will execute asynchronously workflow.
+    The decorated function should return the data to be used
+    during async workflow execution. When being used in a client
+    package, it is recommended to use a partial to provide
+    a default value for `get_config` e.g.
+
+    async_fire_opal_workflow = partial(
+        async_core_workflow,
+        get_fire_opal_config
+    )
+
+    @async_fire_opal_workflow("execute")
+    def execute(...):
+
+    Parameters
+    ----------
+    get_config : Callable
+        Returns a `CoreClientSettings` instance. The configured
+        router will be used to execute the workflow.
+    workflow : str
+        The registered name of the workflow to be executed.
+    formatter : Callable, optional
+        Optional callable which can be used to format the workflow
+        result. The callable should accept exactly one argument
+        which is the raw result fo the workflow. If used, the
+        decorated function will return the result of this callable.
+    """
+
+    def decorator(func: Callable):
+        @wraps(func)
+        def customized_decorator(*args, **kwargs):
+            # router is instantiated before function is called
+            # so any alteration to settings is visible within
+            # the function
+            config = get_config()
+            router = config.get_router()
+
+            # Set the async state to True
+            router.set_async_state(True)
+            if "is_async" in kwargs:
+                raise QctrlArgumentsValueError(
+                    description="The asynchronous state of this function cannot be altered.",
+                    arguments={"is_async": kwargs.get("is_async")},
+                )
+
             data = func(*args, **kwargs)
             result = router(workflow, data)
 

{qctrl_workflow_client-3.0.0 → qctrl_workflow_client-3.1.0}/qctrlworkflowclient/router/api.py

@@ -199,6 +199,13 @@ class ApiRouter(BaseRouter):
         self._settings = settings
         self._validate()
         self._parallel_task_collector = None
+        self._async = False
+
+    def set_async_state(self, is_async: bool):
+        """
+        Toggle asynchronous state of workflow execution.
+        """
+        self._async = is_async
 
     def _validate(self):
         """
@@ -384,6 +391,9 @@ class ApiRouter(BaseRouter):
             errors=action_data["errors"],
         )
 
+        if self._async:
+            return {"async_result": action}
+
         if self._parallel_task_collector is not None:
             async_result = {"async_result": action}
             self._parallel_task_collector.add(async_result)
@@ -428,16 +438,11 @@ class ApiRouter(BaseRouter):
             message = warning_data["message"]
             warn(Warning(message))
 
-    @retry(
-        wait=_POLL_WAIT_CHAIN,
-        retry=retry_if_result(lambda action: not action.is_finished()),
-    )
-    def _poll_for_completion(self, action: Action) -> Action:
+    def update_action_status(self, action: Action) -> Action:
         """
-        Poll the API waiting for the action to be finished.
-        When finished, an updated `Action` object is returned.
+        Update the action status. When finished, an updated
+        `Action` object is returned.
         """
-
         _query = gql.gql(
             """
             query($modelId: String!) {
@@ -467,6 +472,17 @@ class ApiRouter(BaseRouter):
 
         return action
 
+    @retry(
+        wait=_POLL_WAIT_CHAIN,
+        retry=retry_if_result(lambda action: not action.is_finished()),
+    )
+    def _poll_for_completion(self, action: Action) -> Action:
+        """
+        Poll the API waiting for the action to be finished.
+        When finished, an updated `Action` object is returned.
+        """
+        return self.update_action_status(action)
+
     def get_result(self, action: Action) -> DecodedResult:
         """
         Return the result of the action.