qctrl-workflow-client 7.2.0__tar.gz → 8.0.0__tar.gz

{qctrl_workflow_client-7.2.0 → qctrl_workflow_client-8.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qctrl-workflow-client
-Version: 7.2.0
+Version: 8.0.0
 Summary: Q-CTRL Workflow Client
 License: https://q-ctrl.com/terms
 Keywords: black opal,boulder opal,fire opal,ironstone opal,nisq,open controls,q control,q ctrl,q-control,q-ctrl,qcontrol,qctrl,quantum,quantum algorithms,quantum circuits,quantum coding,quantum coding software,quantum computing,quantum control,quantum control software,quantum control theory,quantum engineering,quantum error correction,quantum firmware,quantum fundamentals,quantum navigation,quantum sensing,qubit,qudit
@@ -8,7 +8,7 @@ Author: Q-CTRL
 Author-email: support@q-ctrl.com
 Maintainer: Q-CTRL
 Maintainer-email: support@q-ctrl.com
-Requires-Python: >=3.9, <3.14
+Requires-Python: >=3.10, <3.14
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -18,7 +18,6 @@ Classifier: License :: Other/Proprietary License
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12

{qctrl_workflow_client-7.2.0 → qctrl_workflow_client-8.0.0}/pyproject.toml

@@ -1,8 +1,8 @@
 [project]
 name = "qctrl-workflow-client"
 description = "Q-CTRL Workflow Client"
-requires-python = ">=3.9, <3.14"
-version = "7.2.0"
+requires-python = ">=3.10, <3.14"
+version = "8.0.0"
 license = "https://q-ctrl.com/terms"
 authors = [
     { name = "Q-CTRL", email = "support@q-ctrl.com" },
@@ -70,6 +70,10 @@ classifiers = [
     "Intended Audience :: Science/Research",
     "Natural Language :: English",
     "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Topic :: Internet :: WWW/HTTP",
     "Topic :: Scientific/Engineering :: Physics",
     "Topic :: Scientific/Engineering :: Visualization",
@@ -100,19 +104,32 @@ qctrl-commons = { version = "^25.1.2", source = "PyPI" }
 qctrl-client = { version = "^14.0.0", source = "PyPI" }
 
 [tool.poetry.group.dev.dependencies]
-black = "^25.1.0"
-isort = "^6.0.0"
 pre-commit = "^4.1.0"
-pylint = "^3.3.4"
 pytest = "^8.3.4"
 pytest-cov = "^7.0.0"
 pytest-mock = "^3.10.0"
 pytest-xdist = "^3.2.1"
 qctrl-core-workflow-manager = "^5.1.1"
+ruff = "^0.6.0"
 
-[tool.isort]
-profile = "black"
-force_grid_wrap = "2"
+[tool.ruff]
+line-length = 100
+
+[tool.ruff.lint]
+select = ['ALL']
+ignore = [
+  "ANN",    # Type annotations
+  "D", # docstring
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**/*.py" = [
+  "S101",   # Assertions in code
+  "SLF001", # Accessing private members
+]
+
+[tool.ruff.lint.pydocstyle]
+convention = "numpy" # https://numpydoc.readthedocs.io/en/latest/format.html#sections
 
 [tool.pytest.ini_options]
 addopts = "--cov=qctrlworkflowclient --cov-fail-under=80 --cov-report=term-missing:skip-covered"

{qctrl_workflow_client-7.2.0 → qctrl_workflow_client-8.0.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__ = "7.2.0"
+__version__ = "8.0.0"
 
 from .defaults import get_authenticated_client_for_product
 from .functions import (
@@ -28,3 +28,15 @@ from .router import (
     LocalRouter,
 )
 from .settings import CoreClientSettings
+
+__all__ = [
+    "get_authenticated_client_for_product",
+    "core_workflow",
+    "print_warnings",
+    "Product",
+    "ProductInfo",
+    "ApiRouter",
+    "BaseRouter",
+    "LocalRouter",
+    "CoreClientSettings",
+]

{qctrl_workflow_client-7.2.0 → qctrl_workflow_client-8.0.0}/qctrlworkflowclient/defaults.py

@@ -13,13 +13,17 @@
 
 from __future__ import annotations
 
-from typing import Optional
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from qctrlclient.auth import BaseAuth
+else:
+    from qctrlclient.auth import BaseAuth  # noqa: TCH002
 
 from qctrlclient import (
     CliAuth,
     GraphQLClient,
 )
-from qctrlclient.auth import BaseAuth
 from qctrlclient.defaults import (
     get_default_api_url,
     get_default_cli_auth,
@@ -31,8 +35,8 @@ from .utils import get_installed_version
 
 def get_authenticated_client_for_product(
     package_name: str,
-    api_url: Optional[str] = None,
-    auth: Optional[BaseAuth | str] = None,
+    api_url: str | None = None,
+    auth: BaseAuth | str | None = None,
 ) -> GraphQLClient:
     """
     Return a `GraphQLClient` using default URL and Auth (if not provided)
@@ -48,19 +52,17 @@ def get_authenticated_client_for_product(
         The authentication object (or a URL as str to create one) to use.
         If not provided, the default authentication object will be used.
     """
-
     if isinstance(auth, str):
         auth = CliAuth(auth)
 
     headers = {
         "User-Agent": generate_user_agent(
-            package_name, get_installed_version(package_name)
+            package_name,
+            get_installed_version(package_name),
         ),
     }
-    client = GraphQLClient(
+    return GraphQLClient(
         url=api_url or get_default_api_url(),
         headers=headers,
         auth=auth or get_default_cli_auth(),
     )
-
-    return client

{qctrl_workflow_client-7.2.0 → qctrl_workflow_client-8.0.0}/qctrlworkflowclient/functions.py

@@ -11,25 +11,28 @@
 # distributed under the License is distributed on an "AS IS" BASIS. See the
 # License for the specific language.
 
+from __future__ import annotations
+
 from functools import wraps
 from typing import (
+    TYPE_CHECKING,
     Any,
-    Callable,
-    Dict,
-    Optional,
 )
 from warnings import warn
 
 from qctrlcommons.exceptions import QctrlArgumentsValueError
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
 from qctrlworkflowclient.router.api import ApiRouter
 
 
 def core_workflow(
     get_config: Callable,
     workflow: str,
-    formatter: Optional[Callable] = None,
-    registry_selector: Optional[Callable] = None,
+    formatter: Callable | None = None,
+    registry_selector: Callable | None = None,
 ):
     """
     Decorator for a function which will execute a workflow.
@@ -103,8 +106,8 @@ def core_workflow(
 def async_core_workflow(
     get_config: Callable,
     workflow: str,
-    formatter: Optional[Callable] = None,
-    registry_selector: Optional[Callable] = None,
+    formatter: Callable | None = None,
+    registry_selector: Callable | None = None,
 ):
     """
     Decorator for a function which will execute asynchronously workflow.
@@ -180,7 +183,7 @@ def async_core_workflow(
     return decorator
 
 
-def print_warnings(result: Dict[str, Any]):
+def print_warnings(result: dict[str, Any]):
     """
     Result formatter which prints all `warnings` in
     the result and removes them from the result.
@@ -188,6 +191,6 @@ def print_warnings(result: Dict[str, Any]):
     warnings = result.pop("warnings", [])
 
     for warning in warnings:
-        warn(warning, RuntimeWarning)
+        warn(warning, RuntimeWarning, stacklevel=2)
 
     return result

{qctrl_workflow_client-7.2.0 → qctrl_workflow_client-8.0.0}/qctrlworkflowclient/router/__init__.py

@@ -14,3 +14,5 @@
 from .api import ApiRouter
 from .base import BaseRouter
 from .local import LocalRouter
+
+__all__ = ["ApiRouter", "BaseRouter", "LocalRouter"]

{qctrl_workflow_client-7.2.0 → qctrl_workflow_client-8.0.0}/qctrlworkflowclient/router/api.py

@@ -17,16 +17,25 @@ from dataclasses import dataclass
 from enum import Enum
 from functools import cached_property
 from typing import (
+    TYPE_CHECKING,
     Any,
-    Callable,
-    Dict,
-    List,
-    Optional,
+    ClassVar,
 )
 from warnings import warn
 
 import gql
-from qctrlclient import GraphQLClient
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from qctrlclient import GraphQLClient
+
+    from qctrlworkflowclient.settings import CoreClientSettings
+else:
+    from qctrlclient import GraphQLClient  # noqa: TCH002
+
+    from qctrlworkflowclient.settings import CoreClientSettings  # noqa: TCH001
+
 from qctrlclient.exceptions import GraphQLClientError
 from qctrlcommons.preconditions import check_argument
 from qctrlcommons.serializers import (
@@ -42,7 +51,6 @@ from tenacity import (
 from typing_extensions import TypedDict
 
 from qctrlworkflowclient.products import Product
-from qctrlworkflowclient.settings import CoreClientSettings
 from qctrlworkflowclient.utils import get_installed_version
 
 from .base import BaseRouter
@@ -88,7 +96,7 @@ class Organization:
     slug: str
     name: str
 
-    def to_dict(self) -> Dict[str, str]:
+    def to_dict(self) -> dict[str, str]:
         """
         The dictionary representation of the organization.
         """
@@ -135,9 +143,9 @@ class Action:
     """
 
     action_id: str
-    status: Optional[str] = None
-    raw_result: Optional[Any] = None
-    errors: Optional[List[Dict[str, Any]]] = None
+    status: str | None = None
+    raw_result: Any | None = None
+    errors: list[dict[str, Any]] | None = None
 
     @property
     def result(self) -> DecodedResult:
@@ -205,7 +213,7 @@ class ApiRouter(BaseRouter):
         registered in.
     """
 
-    _TRACKED_PACKAGES = [
+    _TRACKED_PACKAGES: ClassVar[list[str]] = [
         "boulder-opal",
         "fire-opal",
         "qctrl-client",
@@ -220,7 +228,7 @@ class ApiRouter(BaseRouter):
         self._parallel_task_collector = None
         self._async = False
 
-    def set_async_state(self, is_async: bool):
+    def set_async_state(self, *, is_async: bool):
         """
         Toggle asynchronous state of workflow execution.
         """
@@ -230,9 +238,9 @@ class ApiRouter(BaseRouter):
         """
         Perform validation checks on the settings.
         """
-
         if not self._settings.product:
-            raise GraphQLClientError("`product` must be configured in settings")
+            error_message = "`product` must be configured in settings"
+            raise GraphQLClientError(error_message)
 
         self._check_organization_config()
 
@@ -248,7 +256,6 @@ class ApiRouter(BaseRouter):
         If the above rules cannot be guaranteed, an error message
         will be displayed.
         """
-
         # organization configured by user
         if self._settings.organization:
             found = False
@@ -259,22 +266,24 @@ class ApiRouter(BaseRouter):
                     break
 
             if not found:
-                raise RuntimeError(
+                error_message = (
                     f"Configured organization not found, is not set up, or does not have valid "
                     f"product access: `{self._settings.organization}`"
                 )
+                raise RuntimeError(error_message)
 
         # organization not configured by user
         else:
             # no valid organizations found for the user
             if not self._organizations:
-                raise RuntimeError(
+                error_message = (
                     "No organizations are set up or have a valid subscription to the product. "
                     "Please ensure that your organization is set up and has an active subscription "
                     "to the product you are trying to access. If you believe this is an error, "
                     "contact your Q-CTRL representative or visit the Q-CTRL support portal at "
                     "https://support.q-ctrl.com."
                 )
+                raise RuntimeError(error_message)
 
             # user is a member of multiple organizations
             if len(self._organizations) > 1:
@@ -290,12 +299,11 @@ class ApiRouter(BaseRouter):
             self._settings.organization = self._organizations[0].slug
 
     @cached_property
-    def _organizations(self) -> List[Organization]:
+    def _organizations(self) -> list[Organization]:
         """
         Return the list of organizations that the user is
         assigned to which provide access to the configured product.
         """
-
         query = gql.gql(
             """
             query {
@@ -317,36 +325,32 @@ class ApiRouter(BaseRouter):
                     }
                 }
             }
-        """
+        """,
         )
 
         response = self._client.execute(query)
         data = response["profile"]["profile"]["organizations"]
-        organizations = []
-
-        for organization_data in data:
+        return [
+            Organization(
+                organization_id=organization_data["id"],
+                slug=organization_data["slug"],
+                name=organization_data["name"],
+            )
+            for organization_data in data
             if self._has_product_access(
-                organization_data, self._settings.product.value.name
-            ):
-                organizations.append(
-                    Organization(
-                        organization_id=organization_data["id"],
-                        slug=organization_data["slug"],
-                        name=organization_data["name"],
-                    )
-                )
-
-        return organizations
+                organization_data,
+                self._settings.product.value.name,
+            )
+        ]
 
     @staticmethod
-    def _has_product_access(organization_data: Dict, product_name: str) -> bool:
+    def _has_product_access(organization_data: dict, product_name: str) -> bool:
         """
         Convenience function to check if the organization
         has access to the given product. The format of
         `organization_data` is based on the output of the query
         in `_get_organizations`.
         """
-
         for product_data in organization_data["products"]:
             if product_data["name"] == product_name:
                 return product_data["active"]
@@ -354,7 +358,8 @@ class ApiRouter(BaseRouter):
         return False
 
     def enable_parallel(
-        self, callback: Optional[Callable[[DecodedResult], dict]] = None
+        self,
+        callback: Callable[[DecodedResult], dict] | None = None,
     ):
         """
         Return a context manager to collect parallel tasks.
@@ -404,7 +409,7 @@ class ApiRouter(BaseRouter):
                     }
                 }
             }
-        """
+        """,
         )
 
         client_metadata = self._get_client_metadata()
@@ -415,9 +420,10 @@ class ApiRouter(BaseRouter):
         _data = json.dumps(data, cls=DataTypeEncoder)
         payload_size = len(_data.encode("utf-8"))
         if payload_size > _MAX_PAYLOAD_SIZE_MB * 1e6:
-            raise ValueError(
+            error_message = (
                 f"Payload size {payload_size}, exceeds max allowed {_MAX_PAYLOAD_SIZE_MB} MB."
             )
+            raise ValueError(error_message)
         input_ = {
             "registry": registry,
             "workflow": workflow,
@@ -427,8 +433,6 @@ class ApiRouter(BaseRouter):
 
         response = self._client.execute(query, {"input": input_})
 
-        # pylint:disable=unsubscriptable-object
-
         self._handle_warnings(response["startCoreWorkflow"]["warnings"])
         action_data = response["startCoreWorkflow"]["action"]
 
@@ -449,12 +453,11 @@ class ApiRouter(BaseRouter):
 
         return self.get_result(action)
 
-    def _get_client_metadata(self) -> Dict[str, Any]:
+    def _get_client_metadata(self) -> dict[str, Any]:
         """
         Return the client metadata to be included on the
         request to start the workflow.
         """
-
         package_versions = {}
 
         for package in self._TRACKED_PACKAGES:
@@ -474,17 +477,17 @@ class ApiRouter(BaseRouter):
             if organization.slug == self._settings.organization:
                 return organization
 
-        raise RuntimeError(f"Organization not found: {self._settings.organization}")
+        error_message = f"Organization not found: {self._settings.organization}"
+        raise RuntimeError(error_message)
 
     @staticmethod
-    def _handle_warnings(warnings_data: List[Dict[str, Any]]):
+    def _handle_warnings(warnings_data: list[dict[str, Any]]):
         """
         Handle warnings returned when starting a workflow.
         """
-
         for warning_data in warnings_data:
             message = warning_data["message"]
-            warn(Warning(message))
+            warn(Warning(message), stacklevel=2)
 
     def update_action_status(self, action: Action) -> Action:
         """
@@ -508,7 +511,7 @@ class ApiRouter(BaseRouter):
                     }
                 }
             }
-        """
+        """,
         )
 
         response = self._client.execute(_query, {"modelId": action.action_id})
@@ -532,21 +535,23 @@ class ApiRouter(BaseRouter):
         return self.update_action_status(action)
 
     def get_result(
-        self, action: Action, revoke_on_interrupt: bool = True
+        self,
+        action: Action,
+        *,
+        revoke_on_interrupt: bool = True,
     ) -> DecodedResult:
         """
         Return the result of the action.
         """
-        return self._fetch_action(action, revoke_on_interrupt).result
+        return self._fetch_action(action, revoke_on_interrupt=revoke_on_interrupt).result
 
-    def _fetch_action(self, action: Action, revoke_on_interrupt: bool = True) -> Any:
+    def _fetch_action(self, action: Action, *, revoke_on_interrupt: bool = True) -> Any:
         """
         Fetch the action from the server. If the action
         has not finished, the API will be polled until it has.
         If the action has failed, a `RuntimeError` will be
         raised.
         """
-
         if not action.is_finished():
             try:
                 action = self._poll_for_completion(action)
@@ -570,9 +575,8 @@ class ApiRouter(BaseRouter):
 
         if action.is_revoked():
             self._settings.event_dispatch("action.revoked", action=action)
-            raise RuntimeError(
-                f'Your task (action_id="{action.action_id}") has been cancelled.'
-            )
+            error_message = f'Your task (action_id="{action.action_id}") has been cancelled.'
+            raise RuntimeError(error_message)
 
         self._settings.event_dispatch("action.success", action=action)
         return action
@@ -581,7 +585,6 @@ class ApiRouter(BaseRouter):
         """
         Update the status of the Action to REVOKED.
         """
-
         _query = gql.gql(
             """
             mutation updateActionMutation($modelId: String!, $status: ActionStatusEnum ) {
@@ -598,11 +601,12 @@ class ApiRouter(BaseRouter):
                     }
                 }
             }
-        """
+        """,
         )
 
         self._client.execute(
-            _query, {"modelId": action.action_id, "status": ActionStatus.REVOKED.value}
+            _query,
+            {"modelId": action.action_id, "status": ActionStatus.REVOKED.value},
         )
 
     def request_machines(self, machine_count: int):
@@ -622,21 +626,19 @@ class ApiRouter(BaseRouter):
             The minimum number of machines requested to be online.
         """
         if not isinstance(machine_count, int) or machine_count < 1:
-            raise GraphQLClientError(
-                "The number of machines requested must be an integer greater than 0."
-            )
+            error_message = "The number of machines requested must be an integer greater than 0."
+            raise GraphQLClientError(error_message)
 
         if self._request_minimum_number_of_machines(machine_count) > 0:
             _s = "" if machine_count == 1 else "s"
-            print(f"Waiting for {machine_count} machine{_s} to be online...")
+            print("Waiting for %d machine%s to be online...", machine_count, _s)  # noqa: T201
             self.wait_for_machine_instantiation(machine_count)
-        print(f"Requested machines ({machine_count}) are online.")
+        print("Requested machines (%d) are online.", machine_count)  # noqa: T201
 
     def _request_minimum_number_of_machines(self, machine_count: int) -> int:
         """
         Request the minimum number of machines that are to be provisioned.
         """
-
         _query = gql.gql(
             """
         mutation requestMachines($minimum: Int!, $organizationId: ID!) {
@@ -648,7 +650,7 @@ class ApiRouter(BaseRouter):
                 }
             }
         }
-        """
+        """,
         )
         response = self._client.execute(
             _query,
@@ -666,14 +668,13 @@ class ApiRouter(BaseRouter):
     @retry(
         wait=wait_fixed(10),
         retry=retry_if_result(
-            lambda response: response["online"] < response["requested"]
+            lambda response: response["online"] < response["requested"],
         ),
     )
     def wait_for_machine_instantiation(self, number_of_machines_requested: int):
         """
         Wait until the requested number of machines are online.
         """
-
         number_of_machines_online = self.get_machine_status()["online"]
 
         def machines(count: int) -> str:
@@ -681,9 +682,10 @@ class ApiRouter(BaseRouter):
                 return "1 machine"
             return f"{count} machines"
 
-        print(
-            f"Current environment: {machines(number_of_machines_online)} online, "
-            f"{machines(number_of_machines_requested - number_of_machines_online)} pending."
+        print(  # noqa: T201
+            "Current environment: %s online, %s pending.",
+            machines(number_of_machines_online),
+            machines(number_of_machines_requested - number_of_machines_online),
         )
         return {
             "online": number_of_machines_online,
@@ -712,7 +714,7 @@ class ApiRouter(BaseRouter):
                     }
                 }
             }
-            """
+            """,
         )
 
         response = self._client.execute(
@@ -741,7 +743,7 @@ class ApiRouter(BaseRouter):
                     }
                 }
             }
-            """
+            """,
         )
 
         response = self._client.execute(
@@ -773,7 +775,7 @@ class ApiRouter(BaseRouter):
                 }
             }
         }
-        """
+        """,
         )
         return self._client.execute(
             _query,
@@ -787,7 +789,8 @@ class ApiRouter(BaseRouter):
         self,
         limit: int,
         offset: int = 0,
-        status: Optional[str] = None,
+        status: str | None = None,
+        *,
         only_user_results: bool = True,
     ) -> list[dict[str, Any]]:
         """
@@ -830,7 +833,7 @@ class ApiRouter(BaseRouter):
                     }
                 }
             }
-        """
+        """,
         )
 
         check_argument(limit >= 1, "Limit must be at least 1.", {"limit": limit})
@@ -851,11 +854,16 @@ class ApiRouter(BaseRouter):
             filter_by["status"] = {"exact": status}
 
         response = self._client.execute(
-            _query, {"limit": limit, "offset": offset, "filterBy": filter_by}
+            _query,
+            {"limit": limit, "offset": offset, "filterBy": filter_by},
         )
         return response["actions"]["actions"]
 
-    def create_presigned_url_upload(self, checksum: str) -> PresignedUrlData:
+    def create_presigned_url_upload(
+        self,
+        checksum: str,
+        registry: str,
+    ) -> PresignedUrlData:
         """
         Create a presigned URL for uploading data using the provided checksum.
 
@@ -863,6 +871,8 @@ class ApiRouter(BaseRouter):
         ----------
         checksum : str
             The Base64-encoded SHA-256 checksum of the data to be uploaded.
+        registry : str
+            The client registry name.
 
         Returns
         -------
@@ -888,16 +898,16 @@ class ApiRouter(BaseRouter):
                 }
               }
             }
-            """
+            """,
         )
 
         response = self._client.execute(
             query,
             variable_values={
                 "input": {
-                    "clientApp": self._settings.product.value.registry,
+                    "clientApp": registry,
                     "checksum": checksum,
-                }
+                },
             },
         )
         return response["createPresignedUrlUpload"]["presignedUrlData"]
@@ -908,24 +918,26 @@ class ParallelCollector:
     Collect tasks to run them in parallel.
     """
 
-    def __init__(self, router: ApiRouter, callback: Optional[Callable[dict, dict]]):
+    def __init__(self, router: ApiRouter, callback: Callable[dict, dict] | None):
         self._router = router
         self._callback = (lambda x: x.decoded) if callback is None else callback
         self._async_results = []
 
-    def add(self, async_result: Dict[str, Action]) -> None:
+    def add(self, async_result: dict[str, Action]) -> None:
         """
         The async result as a dictionary is added for fetching the response later
         when existing the context manager.
         """
-        assert len(async_result) == 1
+        if len(async_result) != 1:
+            error_message = "Expected exactly one async result"
+            raise ValueError(error_message)
         self._async_results.append(async_result)
 
     def __enter__(self):
-        self._router._parallel_task_collector = self
+        self._router._parallel_task_collector = self  # noqa: SLF001
 
     def __exit__(self, exc_type, exc_value, traceback):
-        self._router._parallel_task_collector = None
+        self._router._parallel_task_collector = None  # noqa: SLF001
 
         # Do not try to call any functions upon an exception.
         if isinstance(exc_value, Exception):
@@ -933,13 +945,16 @@ class ParallelCollector:
 
         for result in self._async_results:
             action = result.pop("async_result", None)
-            assert action is not None
-            response = self._router._fetch_action(action)
+            if action is None:
+                error_message = "Action cannot be None"
+                raise ValueError(error_message)
+            response = self._router._fetch_action(action)  # noqa: SLF001
             if action.action_id != response.action_id:
-                raise RuntimeError(
+                error_message = (
                     f"Got the wrong result of action {response.action_id}, "
                     f"expected to update the result of action {action.action_id}."
                 )
+                raise RuntimeError(error_message)
             result.update(self._callback(response.result))
 
         return True

{qctrl_workflow_client-7.2.0 → qctrl_workflow_client-8.0.0}/qctrlworkflowclient/router/local.py

@@ -10,6 +10,14 @@
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS. See the
 # License for the specific language.
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from qctrlcoreworkflowmanager import CallableResolver
+else:
+    from qctrlcoreworkflowmanager import CallableResolver  # noqa: TCH002
 
 from .base import BaseRouter
 
@@ -21,12 +29,12 @@ class LocalRouter(BaseRouter):
 
     Parameters
     ----------
-    resolver : BaseResolver
+    resolver : CallableResolver
         A resolver object for the registry which contains all
         required workflows.
     """
 
-    def __init__(self, resolver: "BaseResolver"):
+    def __init__(self, resolver: CallableResolver):
         self._resolver = resolver
 
     def __call__(self, workflow, data=None):
@@ -43,5 +51,4 @@ class LocalRouter(BaseRouter):
         data = data or {}
         task = self._resolver.get_workflow_task_from_signature(workflow, **data)
         func = self._resolver(task)
-        result = func()
-        return result
+        return func()

{qctrl_workflow_client-7.2.0 → qctrl_workflow_client-8.0.0}/qctrlworkflowclient/settings.py

@@ -13,20 +13,21 @@
 
 from __future__ import annotations
 
+import contextlib
+from collections.abc import Callable
 from dataclasses import dataclass
 from functools import cached_property
 from typing import (
+    TYPE_CHECKING,
     Any,
-    Callable,
-    Dict,
-    Optional,
-    Union,
 )
 
-from .products import Product
 from .router.base import BaseRouter
 
-EventListener = Callable[[str, Dict[str, Any]], None]
+if TYPE_CHECKING:
+    from .products import Product
+
+EventListener = Callable[[str, dict[str, Any]], None]
 
 
 @dataclass
@@ -53,19 +54,19 @@ class CoreClientSettings:
         will be dispatched to.
     """
 
-    router: Union[BaseRouter, Callable]
-    product: Optional[Product] = None
-    organization: Optional[str] = None
-    event_listeners: Optional[list[EventListener]] = None
+    router: BaseRouter | Callable
+    product: Product | None = None
+    organization: str | None = None
+    event_listeners: list[EventListener] | None = None
 
     def update(self, **kwargs):
         """
         Update settings fields.
         """
-
         for attr, value in kwargs.items():
             if not hasattr(self, attr):
-                raise AttributeError(f"Invalid field: {attr}")
+                error_message = f"Invalid field: {attr}"
+                raise AttributeError(error_message)
 
             setattr(self, attr, value)
 
@@ -76,17 +77,14 @@ class CoreClientSettings:
         """
         Clear the cached router.
         """
-        try:
+        with contextlib.suppress(AttributeError):
             delattr(self, "_router")
-        except AttributeError:
-            pass
 
     @cached_property
     def _router(self) -> BaseRouter:
         """
         Prepare the router to be used by the core client.
         """
-
         router = self.router
 
         if isinstance(router, BaseRouter):
@@ -96,7 +94,8 @@ class CoreClientSettings:
             router = router()
 
         if not isinstance(router, BaseRouter):
-            raise ValueError(f"Invalid router: {router}")
+            error_message = f"Invalid router: {router}"
+            raise TypeError(error_message)
 
         return router
 

{qctrl_workflow_client-7.2.0 → qctrl_workflow_client-8.0.0}/qctrlworkflowclient/utils.py

@@ -19,8 +19,10 @@ from importlib.metadata import (
     version,
 )
 from pathlib import Path
-from types import ModuleType
-from typing import Optional
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from types import ModuleType
 
 import requests
 import tomli
@@ -28,7 +30,7 @@ from importlib_metadata import packages_distributions
 from packaging.version import parse
 
 
-def get_installed_version(package: str) -> Optional[str]:
+def get_installed_version(package: str) -> str | None:
     """
     Get the installed version of the package. If
     the version cannot be found (e.g. package not installed)
@@ -52,7 +54,7 @@ class PackageInfo:
     name: str
     install_name: str
     import_name: str
-    changelog_url: Optional[str] = None
+    changelog_url: str | None = None
 
 
 def get_latest_pypi_version(package: str) -> str:
@@ -70,15 +72,17 @@ def check_package_version(package: PackageInfo) -> None:
     show an upgrade message if the current version is outdated.
     """
     local_package = sys.modules.get(package.import_name)
-    assert local_package is not None, f"{package.import_name} is not found."
-    local_version = getattr(local_package, "__version__")
+    if local_package is None:
+        error_message = f"{package.import_name} is not found."
+        raise ImportError(error_message)
+    local_version = local_package.__version__
     latest_version = get_latest_pypi_version(package.install_name)
 
     if parse(local_version) < parse(latest_version):
-        print(f"{package.name} update available.")
-        print(f"Latest version is {latest_version}, you have {local_version}.")
+        print(f"{package.name} update available.")  # noqa: T201
+        print(f"Latest version is {latest_version}, you have {local_version}.")  # noqa: T201
         if package.changelog_url is not None:
-            print(f"Visit {package.changelog_url} for the latest product updates.")
+            print(f"Visit {package.changelog_url} for the latest product updates.")  # noqa: T201
 
 
 def package_versions_table(package_names: list[str]) -> str:
@@ -96,26 +100,28 @@ def package_versions_table(package_names: list[str]) -> str:
     str
         A string containing the Markdown-formatted table.
     """
-
     # List containing the items in the different rows.
     table_items = get_package_versions(package_names=package_names)
 
     # Widths of the table columns.
-    package_width = max(max(len(item[0]) for item in table_items), 7)
-    version_width = max(max(len(item[1]) for item in table_items), 7)
+    all_items = [*table_items, ("Package", "Version")]
+    min_column_count = 2
+    package_width = max(len(item[0]) for item in all_items if len(item) >= min_column_count)
+    version_width = max(len(item[1]) for item in all_items if len(item) >= min_column_count)
 
     # Add headers and Python version at top of table.
     table_items = [
         ("Package", "Version"),
         ("-" * package_width, "-" * version_width),
-    ] + table_items
+        *table_items,
+    ]
 
     # Build table.
     return "\n".join(
         [
             f"| {name:{package_width}s} | {version_:{version_width}s} |"
             for name, version_ in table_items
-        ]
+        ],
     )
 
 
@@ -144,9 +150,8 @@ def _get_package_name(module: ModuleType) -> str:
         return _package_names_mapping[module.__name__][0]
 
     # The package is in editable mode: look in pyproject.toml to get the package name.
-    with open(
-        Path.joinpath(Path(module.__path__[0]).parent, "pyproject.toml"), "rb"
-    ) as file:
+    toml_path = Path(module.__path__[0]).parent / "pyproject.toml"
+    with toml_path.open("rb") as file:
         config = tomli.load(file)
         return config["project"]["name"]
 
@@ -165,7 +170,6 @@ def get_package_versions(package_names: list[str]) -> list[tuple[str, str]]:
     list[tuple[str, str]]
         The package name and package version.
     """
-
     package_versions = [
         (
             _get_package_name(sys.modules[module_name]),
@@ -174,10 +178,10 @@ def get_package_versions(package_names: list[str]) -> list[tuple[str, str]]:
         for module_name in package_names
         if module_name in sys.modules
     ]
-    package_versions = [
+    return [
         (
             "Python",
             f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}",
-        )
-    ] + package_versions
-    return package_versions
+        ),
+        *package_versions,
+    ]