diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index a79f2621..79b3216c 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -24,11 +24,22 @@ repos: - id: poetry-check - id: poetry-lock - # - repo: https://github.com/pre-commit/mirrors-mypy - # rev: v1.15.0 - # hooks: - # - id: mypy - # pass_filenames: false + - repo: https://github.com/pre-commit/mirrors-mypy + rev: v1.15.0 + hooks: + - id: mypy + pass_filenames: false + args: ["src/"] + additional_dependencies: + - types-six + - types-python-dateutil + - types-requests + - types-deprecated + - pydantic + - aiohttp + - aiohttp-retry + - httpx + - astor - repo: https://github.com/astral-sh/ruff-pre-commit rev: v0.12.3 diff --git a/poetry.lock b/poetry.lock index fe61b7a8..427f32ee 100644 --- a/poetry.lock +++ b/poetry.lock @@ -984,6 +984,79 @@ files = [ [package.dependencies] typing-extensions = {version = ">=4.1.0", markers = "python_version < \"3.11\""} +[[package]] +name = "mypy" +version = "1.18.2" +description = "Optional static typing for Python" +optional = false +python-versions = ">=3.9" +groups = ["dev"] +files = [ + {file = "mypy-1.18.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c1eab0cf6294dafe397c261a75f96dc2c31bffe3b944faa24db5def4e2b0f77c"}, + {file = "mypy-1.18.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:7a780ca61fc239e4865968ebc5240bb3bf610ef59ac398de9a7421b54e4a207e"}, + {file = "mypy-1.18.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:448acd386266989ef11662ce3c8011fd2a7b632e0ec7d61a98edd8e27472225b"}, + {file = "mypy-1.18.2-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f9e171c465ad3901dc652643ee4bffa8e9fef4d7d0eece23b428908c77a76a66"}, + {file = "mypy-1.18.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:592ec214750bc00741af1f80cbf96b5013d81486b7bb24cb052382c19e40b428"}, + {file = "mypy-1.18.2-cp310-cp310-win_amd64.whl", hash = "sha256:7fb95f97199ea11769ebe3638c29b550b5221e997c63b14ef93d2e971606ebed"}, + {file = "mypy-1.18.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:807d9315ab9d464125aa9fcf6d84fde6e1dc67da0b6f80e7405506b8ac72bc7f"}, + {file = "mypy-1.18.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:776bb00de1778caf4db739c6e83919c1d85a448f71979b6a0edd774ea8399341"}, + {file = "mypy-1.18.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1379451880512ffce14505493bd9fe469e0697543717298242574882cf8cdb8d"}, + {file = "mypy-1.18.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1331eb7fd110d60c24999893320967594ff84c38ac6d19e0a76c5fd809a84c86"}, + {file = "mypy-1.18.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3ca30b50a51e7ba93b00422e486cbb124f1c56a535e20eff7b2d6ab72b3b2e37"}, + {file = "mypy-1.18.2-cp311-cp311-win_amd64.whl", hash = "sha256:664dc726e67fa54e14536f6e1224bcfce1d9e5ac02426d2326e2bb4e081d1ce8"}, + {file = "mypy-1.18.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:33eca32dd124b29400c31d7cf784e795b050ace0e1f91b8dc035672725617e34"}, + {file = "mypy-1.18.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a3c47adf30d65e89b2dcd2fa32f3aeb5e94ca970d2c15fcb25e297871c8e4764"}, + {file = "mypy-1.18.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d6c838e831a062f5f29d11c9057c6009f60cb294fea33a98422688181fe2893"}, + {file = "mypy-1.18.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01199871b6110a2ce984bde85acd481232d17413868c9807e95c1b0739a58914"}, + {file = "mypy-1.18.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a2afc0fa0b0e91b4599ddfe0f91e2c26c2b5a5ab263737e998d6817874c5f7c8"}, + {file = "mypy-1.18.2-cp312-cp312-win_amd64.whl", hash = "sha256:d8068d0afe682c7c4897c0f7ce84ea77f6de953262b12d07038f4d296d547074"}, + {file = "mypy-1.18.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:07b8b0f580ca6d289e69209ec9d3911b4a26e5abfde32228a288eb79df129fcc"}, + {file = "mypy-1.18.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:ed4482847168439651d3feee5833ccedbf6657e964572706a2adb1f7fa4dfe2e"}, + {file = "mypy-1.18.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c3ad2afadd1e9fea5cf99a45a822346971ede8685cc581ed9cd4d42eaf940986"}, + {file = "mypy-1.18.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a431a6f1ef14cf8c144c6b14793a23ec4eae3db28277c358136e79d7d062f62d"}, + {file = "mypy-1.18.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7ab28cc197f1dd77a67e1c6f35cd1f8e8b73ed2217e4fc005f9e6a504e46e7ba"}, + {file = "mypy-1.18.2-cp313-cp313-win_amd64.whl", hash = "sha256:0e2785a84b34a72ba55fb5daf079a1003a34c05b22238da94fcae2bbe46f3544"}, + {file = "mypy-1.18.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:62f0e1e988ad41c2a110edde6c398383a889d95b36b3e60bcf155f5164c4fdce"}, + {file = "mypy-1.18.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:8795a039bab805ff0c1dfdb8cd3344642c2b99b8e439d057aba30850b8d3423d"}, + {file = "mypy-1.18.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6ca1e64b24a700ab5ce10133f7ccd956a04715463d30498e64ea8715236f9c9c"}, + {file = "mypy-1.18.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d924eef3795cc89fecf6bedc6ed32b33ac13e8321344f6ddbf8ee89f706c05cb"}, + {file = "mypy-1.18.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:20c02215a080e3a2be3aa50506c67242df1c151eaba0dcbc1e4e557922a26075"}, + {file = "mypy-1.18.2-cp314-cp314-win_amd64.whl", hash = "sha256:749b5f83198f1ca64345603118a6f01a4e99ad4bf9d103ddc5a3200cc4614adf"}, + {file = "mypy-1.18.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:25a9c8fb67b00599f839cf472713f54249a62efd53a54b565eb61956a7e3296b"}, + {file = "mypy-1.18.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c2b9c7e284ee20e7598d6f42e13ca40b4928e6957ed6813d1ab6348aa3f47133"}, + {file = "mypy-1.18.2-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d6985ed057513e344e43a26cc1cd815c7a94602fb6a3130a34798625bc2f07b6"}, + {file = "mypy-1.18.2-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:22f27105f1525ec024b5c630c0b9f36d5c1cc4d447d61fe51ff4bd60633f47ac"}, + {file = "mypy-1.18.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:030c52d0ea8144e721e49b1f68391e39553d7451f0c3f8a7565b59e19fcb608b"}, + {file = "mypy-1.18.2-cp39-cp39-win_amd64.whl", hash = "sha256:aa5e07ac1a60a253445797e42b8b2963c9675563a94f11291ab40718b016a7a0"}, + {file = "mypy-1.18.2-py3-none-any.whl", hash = "sha256:22a1748707dd62b58d2ae53562ffc4d7f8bcc727e8ac7cbc69c053ddc874d47e"}, + {file = "mypy-1.18.2.tar.gz", hash = "sha256:06a398102a5f203d7477b2923dda3634c36727fa5c237d8f859ef90c42a9924b"}, +] + +[package.dependencies] +mypy_extensions = ">=1.0.0" +pathspec = ">=0.9.0" +tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""} +typing_extensions = ">=4.6.0" + +[package.extras] +dmypy = ["psutil (>=4.0)"] +faster-cache = ["orjson"] +install-types = ["pip"] +mypyc = ["setuptools (>=50)"] +reports = ["lxml"] + +[[package]] +name = "mypy-extensions" +version = "1.1.0" +description = "Type system extensions for programs checked with the mypy type checker." +optional = false +python-versions = ">=3.8" +groups = ["dev"] +files = [ + {file = "mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505"}, + {file = "mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558"}, +] + [[package]] name = "nodeenv" version = "1.9.1" @@ -1008,6 +1081,18 @@ files = [ {file = "packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f"}, ] +[[package]] +name = "pathspec" +version = "0.12.1" +description = "Utility library for gitignore style pattern matching of file paths." +optional = false +python-versions = ">=3.8" +groups = ["dev"] +files = [ + {file = "pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08"}, + {file = "pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712"}, +] + [[package]] name = "platformdirs" version = "4.3.8" @@ -1965,4 +2050,4 @@ propcache = ">=0.2.1" [metadata] lock-version = "2.1" python-versions = ">=3.9" -content-hash = "143daf87979e591c10779700ba2910a80adb2fbd96b68ad2004d093690cb7c85" +content-hash = "726b9ad928addfb0a202e87814e891b838333b2effd5e4c04e7902af78601172" diff --git a/pyproject.toml b/pyproject.toml index 18ea7411..d2b59cb5 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -49,6 +49,7 @@ setuptools = "^80.9.0" pytest = "^8.4.1" pytest-mock = "^3.14.1" pytest-asyncio = "^1.1.0" +mypy = "^1.18.2" [tool.ruff] target-version = "py39" @@ -205,3 +206,59 @@ markers = [ "v5_2_6: mark test to run for version 5.2.6", "v3_21_16: mark test to run for version 3.21.16" ] + +[tool.mypy] +python_version = "3.9" +follow_imports = "silent" + +plugins = [ + "pydantic.mypy" +] +disable_error_code = [ + "no-redef", + "return-value", + "var-annotated", + "assignment", + "call-arg", + "arg-type", + "override", + "dict-item", + "index", + "operator", + "call-overload", + "misc", + "attr-defined", + "union-attr", + "name-defined", +] + +[[tool.mypy.overrides]] +module = [ + "conductor.client.http.*", + "conductor.client.codegen.*", + "conductor.client.orkes.api.*", + "conductor.asyncio_client.http.*" +] +ignore_errors = true + +[[tool.mypy.overrides]] +module = [ + "tests.*", + "examples.*" +] +disable_error_code = [ + "attr-defined", + "no-untyped-def" +] + +[[tool.mypy.overrides]] +module = [ + "prometheus_client.*", + "shortuuid", + "dacite.*", + "aiohttp.*", + "aiohttp_retry.*", + "httpx.*", + "astor.*" +] +ignore_missing_imports = true diff --git a/setup.py b/setup.py index 2c914902..70f9efad 100644 --- a/setup.py +++ b/setup.py @@ -1,6 +1,7 @@ -import setuptools import os +import setuptools + version = os.environ["CONDUCTOR_PYTHON_VERSION"] if version is None: version = "0.0.0-SNAPSHOT" diff --git a/src/conductor/asyncio_client/adapters/api/application_resource_api.py b/src/conductor/asyncio_client/adapters/api/application_resource_api.py index d02ba2e5..47ff4ba2 100644 --- a/src/conductor/asyncio_client/adapters/api/application_resource_api.py +++ b/src/conductor/asyncio_client/adapters/api/application_resource_api.py @@ -1,97 +1,374 @@ -from typing import List +from __future__ import annotations -from pydantic import StrictStr +from typing import Annotated, Any, Dict, List, Optional, Tuple, Union +from pydantic import Field, StrictFloat, StrictInt, StrictStr + +from conductor.asyncio_client.adapters.models.create_or_update_application_request_adapter import ( + CreateOrUpdateApplicationRequestAdapter, +) +from conductor.asyncio_client.adapters.models.extended_conductor_application_adapter import ( + ExtendedConductorApplicationAdapter, +) +from conductor.asyncio_client.adapters.models.tag_adapter import TagAdapter from conductor.asyncio_client.http.api import ApplicationResourceApi -from conductor.asyncio_client.http.models import Tag class ApplicationResourceApiAdapter(ApplicationResourceApi): async def create_access_key( self, id: StrictStr, - *args, - **kwargs, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ): - # Convert empty application id to None to prevent sending invalid data to server if not id: id = None - return await super().create_access_key(id, *args, **kwargs) + return await super().create_access_key( + id, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) async def add_role_to_application_user( - self, application_id: StrictStr, role: StrictStr, *args, **kwargs + self, + application_id: StrictStr, + role: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ): - # Convert empty application_id and role to None to prevent sending invalid data to server if not application_id: application_id = None if not role: role = None - return await super().add_role_to_application_user(application_id, role, *args, **kwargs) + return await super().add_role_to_application_user( + application_id, + role, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) async def delete_access_key( self, application_id: StrictStr, key_id: StrictStr, - *args, - **kwargs, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ): - # Convert empty application_id and key_id to None to prevent sending invalid data to server if not application_id: application_id = None if not key_id: key_id = None - return await super().delete_access_key(application_id, key_id, *args, **kwargs) + return await super().delete_access_key( + application_id, + key_id, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) async def remove_role_from_application_user( self, application_id: StrictStr, role: StrictStr, - *args, - **kwargs, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ): - # Convert empty application_id and role to None to prevent sending invalid data to server if not application_id: application_id = None if not role: role = None return await super().remove_role_from_application_user( - application_id, role, *args, **kwargs + application_id, + role, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, ) - async def get_app_by_access_key_id(self, access_key_id: StrictStr, *args, **kwargs): - # Convert empty access_key_id to None to prevent sending invalid data to server + async def get_app_by_access_key_id( + self, + access_key_id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> Optional[ExtendedConductorApplicationAdapter]: if not access_key_id: access_key_id = None - return await super().get_app_by_access_key_id(access_key_id, *args, **kwargs) + result = await super().get_app_by_access_key_id( + access_key_id, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result - async def get_access_keys(self, id: StrictStr, *args, **kwargs): - # Convert empty application id to None to prevent sending invalid data to server + async def get_access_keys( + self, + id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ): if not id: id = None - return await super().get_access_keys(id, *args, **kwargs) + return await super().get_access_keys( + id, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) async def toggle_access_key_status( - self, application_id: StrictStr, key_id: StrictStr, *args, **kwargs + self, + application_id: StrictStr, + key_id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ): - # Convert empty application_id and key_id to None to prevent sending invalid data to server if not application_id: application_id = None if not key_id: key_id = None - return await super().toggle_access_key_status(application_id, key_id, *args, **kwargs) + return await super().toggle_access_key_status( + application_id, + key_id, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) - async def get_tags_for_application(self, application_id: StrictStr, *args, **kwargs): - # Convert empty application_id to None to prevent sending invalid data to server - if not application_id: - application_id = None - return await super().get_tags_for_application(application_id, *args, **kwargs) + async def get_tags_for_application( + self, + id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[TagAdapter]: + if not id: + id = None + result = await super().get_tags_for_application( + id, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def put_tag_for_application( + self, + id: StrictStr, + tag: List[TagAdapter], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> None: + if not id: + id = None + if not tag: + tag = None + return await super().put_tag_for_application( + id, + tag, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) async def delete_tag_for_application( - self, id: StrictStr, tag: List[Tag], *args, **kwargs + self, + id: StrictStr, + tag: List[TagAdapter], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> None: - # Convert empty application id and tag list to None to prevent sending invalid data to server if not id: id = None if not tag: tag = None - return await super().delete_tag_for_application(id, tag, *args, **kwargs) + return await super().delete_tag_for_application( + id, + tag, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + async def create_application( + self, + create_or_update_application_request: CreateOrUpdateApplicationRequestAdapter, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> ExtendedConductorApplicationAdapter: + result = await super().create_application( + create_or_update_application_request, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def update_application( + self, + id: StrictStr, + create_or_update_application_request: CreateOrUpdateApplicationRequestAdapter, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> ExtendedConductorApplicationAdapter: + result = await super().update_application( + id, + create_or_update_application_request, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def get_application( + self, + id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> ExtendedConductorApplicationAdapter: + result = await super().get_application( + id, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def list_applications( + self, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[ExtendedConductorApplicationAdapter]: + result = await super().list_applications( + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result diff --git a/src/conductor/asyncio_client/adapters/api/group_resource_api.py b/src/conductor/asyncio_client/adapters/api/group_resource_api.py index 4d3484e2..0f07e506 100644 --- a/src/conductor/asyncio_client/adapters/api/group_resource_api.py +++ b/src/conductor/asyncio_client/adapters/api/group_resource_api.py @@ -1,4 +1,83 @@ +from __future__ import annotations + +from typing import Annotated, Any, Dict, List, Optional, Tuple, Union + +from pydantic import Field, StrictFloat, StrictInt, StrictStr + +from conductor.asyncio_client.adapters.models.group_adapter import GroupAdapter +from conductor.asyncio_client.adapters.models.upsert_group_request_adapter import ( + UpsertGroupRequestAdapter, +) from conductor.asyncio_client.http.api import GroupResourceApi -class GroupResourceApiAdapter(GroupResourceApi): ... +class GroupResourceApiAdapter(GroupResourceApi): + async def list_groups( + self, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[GroupAdapter]: + result = await super().list_groups( + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def get_group( + self, + id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> GroupAdapter: + result = await super().get_group( + id, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def upsert_group( + self, + id: StrictStr, + upsert_group_request: UpsertGroupRequestAdapter, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> GroupAdapter: + result = await super().upsert_group( + id, + upsert_group_request, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + return result diff --git a/src/conductor/asyncio_client/adapters/api/integration_resource_api.py b/src/conductor/asyncio_client/adapters/api/integration_resource_api.py index 8ef94c2d..eb8b3785 100644 --- a/src/conductor/asyncio_client/adapters/api/integration_resource_api.py +++ b/src/conductor/asyncio_client/adapters/api/integration_resource_api.py @@ -1,4 +1,451 @@ +from __future__ import annotations + +from typing import Annotated, Any, Dict, List, Optional, Tuple, Union + +from pydantic import Field, StrictBool, StrictFloat, StrictInt, StrictStr + +from conductor.asyncio_client.adapters.models.event_log_adapter import EventLogAdapter +from conductor.asyncio_client.adapters.models.integration_adapter import IntegrationAdapter +from conductor.asyncio_client.adapters.models.integration_api_adapter import IntegrationApiAdapter +from conductor.asyncio_client.adapters.models.integration_def_adapter import IntegrationDefAdapter +from conductor.asyncio_client.adapters.models.message_template_adapter import MessageTemplateAdapter +from conductor.asyncio_client.adapters.models.tag_adapter import TagAdapter from conductor.asyncio_client.http.api import IntegrationResourceApi -class IntegrationResourceApiAdapter(IntegrationResourceApi): ... +class IntegrationResourceApiAdapter(IntegrationResourceApi): + async def get_integration_provider( + self, + name: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> IntegrationAdapter: + result = await super().get_integration_provider( + name, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def get_integration_providers( + self, + category: Optional[StrictStr] = None, + active_only: Optional[StrictBool] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[IntegrationAdapter]: + result = await super().get_integration_providers( + category, + active_only, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def get_integration_provider_defs( + self, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[IntegrationDefAdapter]: + result = await super().get_integration_provider_defs( + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def get_integration_api( + self, + name: StrictStr, + integration_name: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> IntegrationApiAdapter: + result = await super().get_integration_api( + name, + integration_name, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def get_integration_apis( + self, + name: StrictStr, + active_only: Optional[StrictBool] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[IntegrationApiAdapter]: + result = await super().get_integration_apis( + name, + active_only, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + return result + + async def get_integration_available_apis( + self, + name: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[str]: + result = await super().get_integration_available_apis( + name, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + return result + + async def save_all_integrations( + self, + integration: List[IntegrationAdapter], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> None: + return await super().save_all_integrations( + integration, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + async def get_all_integrations( + self, + category: Optional[StrictStr] = None, + active_only: Optional[StrictBool] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[IntegrationAdapter]: + result = await super().get_all_integrations( + category, + active_only, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + return result + + async def get_providers_and_integrations( + self, + type: Optional[StrictStr] = None, + active_only: Optional[StrictBool] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[str]: + return await super().get_providers_and_integrations( + type, + active_only, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + async def put_tag_for_integration( + self, + name: StrictStr, + integration_name: StrictStr, + tag: List[TagAdapter], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> None: + return await super().put_tag_for_integration( + name, + integration_name, + tag, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + async def get_tags_for_integration( + self, + name: StrictStr, + integration_name: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[TagAdapter]: + result = await super().get_tags_for_integration( + name, + integration_name, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + return result + + async def delete_tag_for_integration( + self, + name: StrictStr, + integration_name: StrictStr, + tag: List[TagAdapter], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> None: + return await super().delete_tag_for_integration( + name, + integration_name, + tag, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + async def put_tag_for_integration_provider( + self, + name: StrictStr, + tag: List[TagAdapter], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> None: + return await super().put_tag_for_integration_provider( + name, + tag, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + async def get_tags_for_integration_provider( + self, + name: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[TagAdapter]: + result = await super().get_tags_for_integration_provider( + name, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def delete_tag_for_integration_provider( + self, + name: StrictStr, + tag: List[TagAdapter], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> None: + return await super().delete_tag_for_integration_provider( + name, + tag, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + async def get_token_usage_for_integration_provider( + self, + name: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> Dict[str, str]: + return await super().get_token_usage_for_integration_provider( + name, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + async def get_prompts_with_integration( + self, + integration_provider: StrictStr, + integration_name: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[MessageTemplateAdapter]: + result = await super().get_prompts_with_integration( + integration_provider, + integration_name, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def record_event_stats( + self, + type: StrictStr, + event_log: List[EventLogAdapter], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> None: + return await super().record_event_stats( + type, + event_log, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) diff --git a/src/conductor/asyncio_client/adapters/api/metadata_resource_api.py b/src/conductor/asyncio_client/adapters/api/metadata_resource_api.py index 476d1d07..e8be4451 100644 --- a/src/conductor/asyncio_client/adapters/api/metadata_resource_api.py +++ b/src/conductor/asyncio_client/adapters/api/metadata_resource_api.py @@ -1,4 +1,155 @@ +from __future__ import annotations + +from typing import Annotated, Any, Dict, List, Optional, Tuple, Union + +from pydantic import Field, StrictBool, StrictFloat, StrictInt, StrictStr + +from conductor.asyncio_client.adapters.models.extended_workflow_def_adapter import ( + ExtendedWorkflowDefAdapter, +) +from conductor.asyncio_client.adapters.models.task_def_adapter import TaskDefAdapter +from conductor.asyncio_client.adapters.models.workflow_def_adapter import WorkflowDefAdapter from conductor.asyncio_client.http.api import MetadataResourceApi -class MetadataResourceApiAdapter(MetadataResourceApi): ... +class MetadataResourceApiAdapter(MetadataResourceApi): + async def get_task_def( + self, + tasktype: StrictStr, + metadata: Optional[StrictBool] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> TaskDefAdapter: + result = await super().get_task_def( + tasktype, + metadata, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def get_task_defs( + self, + access: Optional[StrictStr] = None, + metadata: Optional[StrictBool] = None, + tag_key: Optional[StrictStr] = None, + tag_value: Optional[StrictStr] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[TaskDefAdapter]: + result = await super().get_task_defs( + access, + metadata, + tag_key, + tag_value, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def update( + self, + extended_workflow_def: List[ExtendedWorkflowDefAdapter], + overwrite: Optional[StrictBool] = None, + new_version: Optional[StrictBool] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> object: + result = await super().update( + extended_workflow_def, + overwrite, + new_version, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def get( + self, + name: StrictStr, + version: Optional[StrictInt] = None, + metadata: Optional[StrictBool] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> WorkflowDefAdapter: + result = await super().get( + name, + version, + metadata, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def get_workflow_defs( + self, + access: Optional[StrictStr] = None, + metadata: Optional[StrictBool] = None, + tag_key: Optional[StrictStr] = None, + tag_value: Optional[StrictStr] = None, + name: Optional[StrictStr] = None, + short: Optional[StrictBool] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[WorkflowDefAdapter]: + result = await super().get_workflow_defs( + access, + metadata, + tag_key, + tag_value, + name, + short, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result diff --git a/src/conductor/asyncio_client/adapters/api/prompt_resource_api.py b/src/conductor/asyncio_client/adapters/api/prompt_resource_api.py index f60beba9..14bb9eb9 100644 --- a/src/conductor/asyncio_client/adapters/api/prompt_resource_api.py +++ b/src/conductor/asyncio_client/adapters/api/prompt_resource_api.py @@ -1,4 +1,149 @@ +from __future__ import annotations + +from typing import Annotated, Any, Dict, List, Optional, Tuple, Union + +from pydantic import Field, StrictFloat, StrictInt, StrictStr + +from conductor.asyncio_client.adapters.models.message_template_adapter import ( + MessageTemplateAdapter, +) +from conductor.asyncio_client.adapters.models.tag_adapter import TagAdapter from conductor.asyncio_client.http.api import PromptResourceApi -class PromptResourceApiAdapter(PromptResourceApi): ... +class PromptResourceApiAdapter(PromptResourceApi): + async def get_message_template( + self, + name: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> MessageTemplateAdapter: + result = await super().get_message_template( + name, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def get_message_templates( + self, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[MessageTemplateAdapter]: + result = await super().get_message_templates( + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def create_message_templates( + self, + message_template: List[MessageTemplateAdapter], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> None: + return await super().create_message_templates( + message_template, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + async def put_tag_for_prompt_template( + self, + name: StrictStr, + tag: List[TagAdapter], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> None: + return await super().put_tag_for_prompt_template( + name, + tag, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + async def get_tags_for_prompt_template( + self, + name: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[TagAdapter]: + result = await super().get_tags_for_prompt_template( + name, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def delete_tag_for_prompt_template( + self, + name: StrictStr, + tag: List[TagAdapter], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> None: + return await super().delete_tag_for_prompt_template( + name, + tag, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) diff --git a/src/conductor/asyncio_client/adapters/api/scheduler_resource_api.py b/src/conductor/asyncio_client/adapters/api/scheduler_resource_api.py index 5fe984d3..f12a351f 100644 --- a/src/conductor/asyncio_client/adapters/api/scheduler_resource_api.py +++ b/src/conductor/asyncio_client/adapters/api/scheduler_resource_api.py @@ -1,4 +1,190 @@ +from __future__ import annotations + +from typing import Annotated, Any, Dict, List, Optional, Tuple, Union + +from pydantic import Field, StrictFloat, StrictInt, StrictStr + +from conductor.asyncio_client.adapters.models.search_result_workflow_schedule_execution_model_adapter import ( + SearchResultWorkflowScheduleExecutionModelAdapter, +) +from conductor.asyncio_client.adapters.models.tag_adapter import TagAdapter +from conductor.asyncio_client.adapters.models.workflow_schedule_adapter import ( + WorkflowScheduleAdapter, +) +from conductor.asyncio_client.adapters.models.workflow_schedule_model_adapter import ( + WorkflowScheduleModelAdapter, +) from conductor.asyncio_client.http.api import SchedulerResourceApi -class SchedulerResourceApiAdapter(SchedulerResourceApi): ... +class SchedulerResourceApiAdapter(SchedulerResourceApi): + async def get_schedule( + self, + name: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> WorkflowScheduleAdapter: + result = await super().get_schedule( + name, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def get_all_schedules( + self, + workflow_name: Optional[StrictStr] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[WorkflowScheduleModelAdapter]: + result = await super().get_all_schedules( + workflow_name, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def search_v2( + self, + start: Optional[StrictInt] = None, + size: Optional[StrictInt] = None, + sort: Optional[StrictStr] = None, + free_text: Optional[StrictStr] = None, + query: Optional[StrictStr] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> SearchResultWorkflowScheduleExecutionModelAdapter: + result = await super().search_v2( + start, + size, + sort, + free_text, + query, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def get_schedules_by_tag( + self, + tag: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[WorkflowScheduleModelAdapter]: + result = await super().get_schedules_by_tag( + tag, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def put_tag_for_schedule( + self, + name: StrictStr, + tag: List[TagAdapter], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> None: + return await super().put_tag_for_schedule( + name, + tag, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + async def get_tags_for_schedule( + self, + name: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[TagAdapter]: + result = await super().get_tags_for_schedule( + name, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def delete_tag_for_schedule( + self, + name: StrictStr, + tag: List[TagAdapter], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> None: + return await super().delete_tag_for_schedule( + name, + tag, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) diff --git a/src/conductor/asyncio_client/adapters/api/schema_resource_api.py b/src/conductor/asyncio_client/adapters/api/schema_resource_api.py index 36e6fc94..54642b57 100644 --- a/src/conductor/asyncio_client/adapters/api/schema_resource_api.py +++ b/src/conductor/asyncio_client/adapters/api/schema_resource_api.py @@ -1,4 +1,80 @@ +from __future__ import annotations + +from typing import Annotated, Any, Dict, List, Optional, Tuple, Union + +from pydantic import Field, StrictBool, StrictFloat, StrictInt, StrictStr + +from conductor.asyncio_client.adapters.models.schema_def_adapter import SchemaDefAdapter from conductor.asyncio_client.http.api import SchemaResourceApi -class SchemaResourceApiAdapter(SchemaResourceApi): ... +class SchemaResourceApiAdapter(SchemaResourceApi): + async def save( + self, + schema_def: List[SchemaDefAdapter], + new_version: Optional[StrictBool] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> None: + return await super().save( + schema_def, + new_version, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + async def get_schema_by_name_and_version( + self, + name: StrictStr, + version: StrictInt, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> SchemaDefAdapter: + result = await super().get_schema_by_name_and_version( + name, + version, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def get_all_schemas( + self, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[SchemaDefAdapter]: + result = await super().get_all_schemas( + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result diff --git a/src/conductor/asyncio_client/adapters/api/secret_resource_api.py b/src/conductor/asyncio_client/adapters/api/secret_resource_api.py index ca750bef..dc23eb90 100644 --- a/src/conductor/asyncio_client/adapters/api/secret_resource_api.py +++ b/src/conductor/asyncio_client/adapters/api/secret_resource_api.py @@ -1,4 +1,146 @@ +from __future__ import annotations + +from typing import Annotated, Any, Dict, List, Optional, Tuple, Union + +from pydantic import Field, StrictFloat, StrictInt, StrictStr + +from conductor.asyncio_client.adapters.models.extended_secret_adapter import ExtendedSecretAdapter +from conductor.asyncio_client.adapters.models.tag_adapter import TagAdapter from conductor.asyncio_client.http.api import SecretResourceApi -class SecretResourceApiAdapter(SecretResourceApi): ... +class SecretResourceApiAdapter(SecretResourceApi): + async def secret_exists( + self, + key: Annotated[str, Field(strict=True)], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> bool: + result = await super().secret_exists( + key, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def list_all_secret_names( + self, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[str]: + return await super().list_all_secret_names( + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + async def list_secrets_with_tags_that_user_can_grant_access_to( + self, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[ExtendedSecretAdapter]: + result = await super().list_secrets_with_tags_that_user_can_grant_access_to( + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def put_tag_for_secret( + self, + key: Annotated[str, Field(strict=True)], + tag: List[TagAdapter], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> None: + return await super().put_tag_for_secret( + key, + tag, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + async def get_tags( + self, + key: Annotated[str, Field(strict=True)], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[TagAdapter]: + result = await super().get_tags( + key, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def delete_tag_for_secret( + self, + key: Annotated[str, Field(strict=True)], + tag: List[TagAdapter], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> None: + return await super().delete_tag_for_secret( + key, + tag, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) diff --git a/src/conductor/asyncio_client/adapters/api/tags_api.py b/src/conductor/asyncio_client/adapters/api/tags_api.py index ed6afe28..90d9c05b 100644 --- a/src/conductor/asyncio_client/adapters/api/tags_api.py +++ b/src/conductor/asyncio_client/adapters/api/tags_api.py @@ -1,4 +1,106 @@ +from __future__ import annotations + +from typing import Annotated, Any, Dict, List, Optional, Tuple, Union + +from pydantic import Field, StrictFloat, StrictInt, StrictStr + +from conductor.asyncio_client.adapters.models.tag_adapter import TagAdapter from conductor.asyncio_client.http.api import TagsApi -class TagsApiAdapter(TagsApi): ... +class TagsApiAdapter(TagsApi): + async def get_workflow_tags( + self, + name: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[TagAdapter]: + result = await super().get_workflow_tags( + name, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def set_workflow_tags( + self, + name: StrictStr, + tag: List[TagAdapter], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> object: + result = await super().set_workflow_tags( + name, + tag, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def get_task_tags( + self, + task_name: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[TagAdapter]: + result = await super().get_task_tags( + task_name, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def set_task_tags( + self, + task_name: StrictStr, + tag: List[TagAdapter], + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> object: + result = await super().set_task_tags( + task_name, + tag, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result diff --git a/src/conductor/asyncio_client/adapters/api/task_resource_api.py b/src/conductor/asyncio_client/adapters/api/task_resource_api.py index 6efc63ea..52cc2c36 100644 --- a/src/conductor/asyncio_client/adapters/api/task_resource_api.py +++ b/src/conductor/asyncio_client/adapters/api/task_resource_api.py @@ -1,14 +1,178 @@ from __future__ import annotations -from typing import Optional, Dict, Union, Annotated, Any, Tuple +from typing import Annotated, Any, Dict, List, Optional, Tuple, Union -from pydantic import validate_call, StrictStr, StrictFloat, Field, StrictInt +from pydantic import Field, StrictFloat, StrictInt, StrictStr, validate_call +from conductor.asyncio_client.adapters.models.poll_data_adapter import PollDataAdapter +from conductor.asyncio_client.adapters.models.search_result_task_summary_adapter import ( + SearchResultTaskSummaryAdapter, +) +from conductor.asyncio_client.adapters.models.task_adapter import TaskAdapter +from conductor.asyncio_client.adapters.models.task_exec_log_adapter import TaskExecLogAdapter from conductor.asyncio_client.adapters.models.workflow_adapter import WorkflowAdapter from conductor.asyncio_client.http.api import TaskResourceApi class TaskResourceApiAdapter(TaskResourceApi): + async def poll( + self, + tasktype: StrictStr, + workerid: Optional[StrictStr] = None, + domain: Optional[StrictStr] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> Optional[TaskAdapter]: + result = await super().poll( + tasktype, + workerid, + domain, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def batch_poll( + self, + tasktype: StrictStr, + workerid: Optional[StrictStr] = None, + domain: Optional[StrictStr] = None, + count: Optional[StrictInt] = None, + timeout: Optional[StrictInt] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[TaskAdapter]: + result = await super().batch_poll( + tasktype, + workerid, + domain, + count, + timeout, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def get_task( + self, + task_id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> TaskAdapter: + result = await super().get_task( + task_id, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def get_poll_data( + self, + task_type: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[PollDataAdapter]: + result = await super().get_poll_data( + task_type, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def get_task_logs( + self, + task_id: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[TaskExecLogAdapter]: + result = await super().get_task_logs( + task_id, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def search1( + self, + start: Optional[StrictInt] = None, + size: Optional[StrictInt] = None, + sort: Optional[StrictStr] = None, + free_text: Optional[StrictStr] = None, + query: Optional[StrictStr] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> SearchResultTaskSummaryAdapter: + result = await super().search1( + start, + size, + sort, + free_text, + query, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + @validate_call async def update_task_sync( self, diff --git a/src/conductor/asyncio_client/adapters/api/user_resource_api.py b/src/conductor/asyncio_client/adapters/api/user_resource_api.py index 9c4167b8..ae25ccb9 100644 --- a/src/conductor/asyncio_client/adapters/api/user_resource_api.py +++ b/src/conductor/asyncio_client/adapters/api/user_resource_api.py @@ -1,51 +1,138 @@ -from pydantic import StrictStr +from __future__ import annotations + +from typing import Annotated, Any, Dict, List, Optional, Tuple, Union + +from pydantic import Field, StrictBool, StrictFloat, StrictInt, StrictStr -from conductor.asyncio_client.http.api import UserResourceApi from conductor.asyncio_client.adapters.models import UpsertUserRequestAdapter as UpsertUserRequest +from conductor.asyncio_client.adapters.models.conductor_user_adapter import ConductorUserAdapter +from conductor.asyncio_client.http.api import UserResourceApi class UserResourceApiAdapter(UserResourceApi): async def get_granted_permissions( self, user_id: StrictStr, - *args, - **kwargs, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> object: # Convert empty user_id to None to prevent sending invalid data to server if not user_id: user_id = None - return await super().get_granted_permissions(user_id, *args, **kwargs) + return await super().get_granted_permissions( + user_id, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) async def get_user( self, id: StrictStr, - *args, - **kwargs, - ) -> object: + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> ConductorUserAdapter: # Convert empty user id to None to prevent sending invalid data to server if not id: id = None - return await super().get_user(id, *args, **kwargs) + result = await super().get_user( + id, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result async def upsert_user( self, id: StrictStr, upsert_user_request: UpsertUserRequest, - *args, - **kwargs, - ) -> object: + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> ConductorUserAdapter: # Convert empty user id to None to prevent sending invalid data to server if not id: id = None - return await super().upsert_user(id, upsert_user_request, *args, **kwargs) + result = await super().upsert_user( + id, + upsert_user_request, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def list_users( + self, + apps: Optional[StrictBool] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[ConductorUserAdapter]: + result = await super().list_users( + apps, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result async def delete_user( self, id: StrictStr, - *args, - **kwargs, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, ) -> object: # Convert empty user id to None to prevent sending invalid data to server if not id: id = None - return await super().delete_user(id, *args, **kwargs) + return await super().delete_user( + id, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) diff --git a/src/conductor/asyncio_client/adapters/api/workflow_resource_api.py b/src/conductor/asyncio_client/adapters/api/workflow_resource_api.py index 4f417f8a..bce7a7f2 100644 --- a/src/conductor/asyncio_client/adapters/api/workflow_resource_api.py +++ b/src/conductor/asyncio_client/adapters/api/workflow_resource_api.py @@ -1,13 +1,340 @@ from __future__ import annotations -from typing import Dict, Any, Union, Optional, Annotated, Tuple -from pydantic import validate_call, Field, StrictStr, StrictFloat, StrictInt -from conductor.asyncio_client.adapters.models.workflow_adapter import Workflow +from typing import Annotated, Any, Dict, List, Optional, Tuple, Union +from pydantic import Field, StrictBool, StrictFloat, StrictInt, StrictStr, validate_call + +from conductor.asyncio_client.adapters.models.correlation_ids_search_request_adapter import ( + CorrelationIdsSearchRequestAdapter, +) +from conductor.asyncio_client.adapters.models.rerun_workflow_request_adapter import ( + RerunWorkflowRequestAdapter, +) +from conductor.asyncio_client.adapters.models.scrollable_search_result_workflow_summary_adapter import ( + ScrollableSearchResultWorkflowSummaryAdapter, +) +from conductor.asyncio_client.adapters.models.start_workflow_request_adapter import ( + StartWorkflowRequestAdapter, +) +from conductor.asyncio_client.adapters.models.workflow_adapter import WorkflowAdapter +from conductor.asyncio_client.adapters.models.workflow_run_adapter import WorkflowRunAdapter +from conductor.asyncio_client.adapters.models.workflow_state_update_adapter import ( + WorkflowStateUpdateAdapter, +) +from conductor.asyncio_client.adapters.models.workflow_status_adapter import WorkflowStatusAdapter +from conductor.asyncio_client.adapters.models.workflow_test_request_adapter import ( + WorkflowTestRequestAdapter, +) from conductor.asyncio_client.http.api import WorkflowResourceApi class WorkflowResourceApiAdapter(WorkflowResourceApi): + async def execute_workflow( + self, + name: StrictStr, + version: StrictInt, + request_id: StrictStr, + start_workflow_request: StartWorkflowRequestAdapter, + wait_until_task_ref: Optional[StrictStr] = None, + wait_for_seconds: Optional[StrictInt] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> WorkflowRunAdapter: + result = await super().execute_workflow( + name, + version, + request_id, + start_workflow_request, + wait_until_task_ref, + wait_for_seconds, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def get_execution_status( + self, + workflow_id: StrictStr, + include_tasks: Optional[StrictBool] = None, + summarize: Optional[StrictBool] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> WorkflowAdapter: + result = await super().get_execution_status( + workflow_id, + include_tasks, + summarize, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def get_workflow_status_summary( + self, + workflow_id: StrictStr, + include_output: Optional[StrictBool] = None, + include_variables: Optional[StrictBool] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> WorkflowStatusAdapter: + result = await super().get_workflow_status_summary( + workflow_id, + include_output, + include_variables, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def get_running_workflow( + self, + name: StrictStr, + version: Optional[StrictInt] = None, + start_time: Optional[StrictInt] = None, + end_time: Optional[StrictInt] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> List[str]: + return await super().get_running_workflow( + name, + version, + start_time, + end_time, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + async def get_workflows( + self, + name: StrictStr, + request_body: List[StrictStr], + include_closed: Optional[StrictBool] = None, + include_tasks: Optional[StrictBool] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> Dict[str, List[WorkflowAdapter]]: + result = await super().get_workflows( + name, + request_body, + include_closed, + include_tasks, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def get_workflows1( + self, + correlation_ids_search_request: CorrelationIdsSearchRequestAdapter, + include_closed: Optional[StrictBool] = None, + include_tasks: Optional[StrictBool] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> Dict[str, List[WorkflowAdapter]]: + result = await super().get_workflows1( + correlation_ids_search_request, + include_closed, + include_tasks, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def search( + self, + start: Optional[StrictInt] = None, + size: Optional[StrictInt] = None, + sort: Optional[StrictStr] = None, + free_text: Optional[StrictStr] = None, + query: Optional[StrictStr] = None, + skip_cache: Optional[StrictBool] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> ScrollableSearchResultWorkflowSummaryAdapter: + result = await super().search( + start, + size, + sort, + free_text, + query, + skip_cache, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def rerun( + self, + workflow_id: StrictStr, + rerun_workflow_request: RerunWorkflowRequestAdapter, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> str: + return await super().rerun( + workflow_id, + rerun_workflow_request, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + async def restart( + self, + workflow_id: StrictStr, + use_latest_definitions: Optional[StrictBool] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> None: + await super().restart( + workflow_id, + use_latest_definitions, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + async def update_workflow_and_task_state( + self, + workflow_id: StrictStr, + request_id: StrictStr, + workflow_state_update: WorkflowStateUpdateAdapter, + wait_until_task_ref: Optional[StrictStr] = None, + wait_for_seconds: Optional[StrictInt] = None, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> WorkflowRunAdapter: + result = await super().update_workflow_and_task_state( + workflow_id, + request_id, + workflow_state_update, + wait_until_task_ref, + wait_for_seconds, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + + async def test_workflow( + self, + workflow_test_request: WorkflowTestRequestAdapter, + _request_timeout: Union[ # noqa: PT019 + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, # noqa: PT019 + _content_type: Optional[StrictStr] = None, # noqa: PT019 + _headers: Optional[Dict[StrictStr, Any]] = None, # noqa: PT019 + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, # noqa: PT019 + ) -> WorkflowAdapter: + result = await super().test_workflow( + workflow_test_request, + _request_timeout=_request_timeout, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + return result + @validate_call async def update_workflow_state( self, @@ -22,7 +349,7 @@ async def update_workflow_state( _content_type: Optional[StrictStr] = None, _headers: Optional[Dict[StrictStr, Any]] = None, _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, - ) -> Workflow: + ) -> WorkflowAdapter: """Update workflow variables Updates the workflow variables and triggers evaluation. diff --git a/src/conductor/asyncio_client/adapters/api_client_adapter.py b/src/conductor/asyncio_client/adapters/api_client_adapter.py index 112ed4b7..7832fd37 100644 --- a/src/conductor/asyncio_client/adapters/api_client_adapter.py +++ b/src/conductor/asyncio_client/adapters/api_client_adapter.py @@ -11,10 +11,9 @@ from conductor.asyncio_client.configuration import Configuration from conductor.asyncio_client.http import rest from conductor.asyncio_client.http.api_client import ApiClient -from conductor.asyncio_client.http.api_response import ApiResponse -from conductor.asyncio_client.http.api_response import T as ApiResponseT +from conductor.asyncio_client.http.api_response import ApiResponse, T as ApiResponseT from conductor.asyncio_client.http.exceptions import ApiException -from conductor.client.exceptions.auth_401_policy import Auth401Policy, Auth401Handler +from conductor.client.exceptions.auth_401_policy import Auth401Handler, Auth401Policy logger = logging.getLogger(Configuration.get_logging_formatted_name(__name__)) diff --git a/src/conductor/asyncio_client/adapters/models/action_adapter.py b/src/conductor/asyncio_client/adapters/models/action_adapter.py index 73d96fce..0e240e24 100644 --- a/src/conductor/asyncio_client/adapters/models/action_adapter.py +++ b/src/conductor/asyncio_client/adapters/models/action_adapter.py @@ -1,6 +1,8 @@ from __future__ import annotations -from typing import Any, Dict, Optional, Self +from typing import Any, Dict, Optional + +from typing_extensions import Self from conductor.asyncio_client.http.models import Action diff --git a/src/conductor/asyncio_client/adapters/models/any_adapter.py b/src/conductor/asyncio_client/adapters/models/any_adapter.py index a1992277..f71c95a4 100644 --- a/src/conductor/asyncio_client/adapters/models/any_adapter.py +++ b/src/conductor/asyncio_client/adapters/models/any_adapter.py @@ -1,7 +1,6 @@ from __future__ import annotations -from typing import Any as AnyType -from typing import Dict, Optional +from typing import Any as AnyType, Dict, Optional from pydantic import Field from typing_extensions import Self diff --git a/src/conductor/asyncio_client/adapters/models/descriptor_proto_or_builder_adapter.py b/src/conductor/asyncio_client/adapters/models/descriptor_proto_or_builder_adapter.py index 10396da0..91d4fbf9 100644 --- a/src/conductor/asyncio_client/adapters/models/descriptor_proto_or_builder_adapter.py +++ b/src/conductor/asyncio_client/adapters/models/descriptor_proto_or_builder_adapter.py @@ -232,6 +232,9 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: from conductor.asyncio_client.adapters.models.message_adapter import ( # noqa: E402 MessageAdapter, ) +from conductor.asyncio_client.adapters.models.message_options_adapter import ( # noqa: E402 + MessageOptionsAdapter, +) from conductor.asyncio_client.adapters.models.message_options_or_builder_adapter import ( # noqa: E402 MessageOptionsOrBuilderAdapter, ) @@ -250,8 +253,5 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: from conductor.asyncio_client.adapters.models.unknown_field_set_adapter import ( # noqa: E402 UnknownFieldSetAdapter, ) -from conductor.asyncio_client.adapters.models.message_options_adapter import ( # noqa: E402 - MessageOptionsAdapter, -) DescriptorProtoOrBuilderAdapter.model_rebuild(raise_errors=False) diff --git a/src/conductor/asyncio_client/adapters/models/schema_def_adapter.py b/src/conductor/asyncio_client/adapters/models/schema_def_adapter.py index aa5d2c7e..b5cb63f2 100644 --- a/src/conductor/asyncio_client/adapters/models/schema_def_adapter.py +++ b/src/conductor/asyncio_client/adapters/models/schema_def_adapter.py @@ -1,6 +1,6 @@ from __future__ import annotations -from enum import Enum +from enum import Enum from typing import Any, Dict, Optional from conductor.asyncio_client.http.models import SchemaDef diff --git a/src/conductor/asyncio_client/adapters/models/service_descriptor_adapter.py b/src/conductor/asyncio_client/adapters/models/service_descriptor_adapter.py index e34f9cfb..c58e6aba 100644 --- a/src/conductor/asyncio_client/adapters/models/service_descriptor_adapter.py +++ b/src/conductor/asyncio_client/adapters/models/service_descriptor_adapter.py @@ -1,6 +1,8 @@ from __future__ import annotations -from typing import Any, Dict, List, Optional, Self +from typing import Any, Dict, List, Optional + +from typing_extensions import Self from conductor.asyncio_client.http.models import ServiceDescriptor diff --git a/src/conductor/asyncio_client/adapters/models/task_result_adapter.py b/src/conductor/asyncio_client/adapters/models/task_result_adapter.py index c8eec6b7..c2816664 100644 --- a/src/conductor/asyncio_client/adapters/models/task_result_adapter.py +++ b/src/conductor/asyncio_client/adapters/models/task_result_adapter.py @@ -1,8 +1,9 @@ from __future__ import annotations -from typing import Any, Dict, List, Optional, Self +from typing import Any, Dict, List, Optional from pydantic import Field +from typing_extensions import Self from conductor.asyncio_client.http.models import TaskResult diff --git a/src/conductor/asyncio_client/adapters/models/workflow_adapter.py b/src/conductor/asyncio_client/adapters/models/workflow_adapter.py index 2b7dab6e..c2afe942 100644 --- a/src/conductor/asyncio_client/adapters/models/workflow_adapter.py +++ b/src/conductor/asyncio_client/adapters/models/workflow_adapter.py @@ -1,6 +1,6 @@ from __future__ import annotations -from typing import Any, Dict, List, Optional, TYPE_CHECKING +from typing import TYPE_CHECKING, Any, Dict, List, Optional if TYPE_CHECKING: from conductor.asyncio_client.adapters.models.task_adapter import TaskAdapter diff --git a/src/conductor/asyncio_client/ai/orchestrator.py b/src/conductor/asyncio_client/ai/orchestrator.py index 106fa8ec..d38914dc 100644 --- a/src/conductor/asyncio_client/ai/orchestrator.py +++ b/src/conductor/asyncio_client/ai/orchestrator.py @@ -1,6 +1,6 @@ from __future__ import annotations -from typing import TYPE_CHECKING, List, Optional +from typing import TYPE_CHECKING, Dict, List, Optional from uuid import uuid4 from conductor.asyncio_client.adapters.models.integration_api_update_adapter import ( @@ -13,13 +13,13 @@ from conductor.asyncio_client.orkes.orkes_clients import OrkesClients if TYPE_CHECKING: + from conductor.asyncio_client.adapters import ApiClient from conductor.asyncio_client.adapters.models.message_template_adapter import ( MessageTemplateAdapter, ) from conductor.asyncio_client.configuration import Configuration from conductor.shared.ai.configuration.interfaces.integration_config import IntegrationConfig from conductor.shared.ai.enums import LLMProvider, VectorDB - from conductor.asyncio_client.adapters import ApiClient NOT_FOUND_STATUS = 404 @@ -142,7 +142,7 @@ async def add_vector_store( db_integration_name, index, api_details ) - async def get_token_used(self, ai_integration: str) -> int: + async def get_token_used(self, ai_integration: str) -> Dict[str, str]: return await self.integration_client.get_token_usage_for_integration_provider( ai_integration ) diff --git a/src/conductor/asyncio_client/automator/task_handler.py b/src/conductor/asyncio_client/automator/task_handler.py index 7a29cd42..29bdd684 100644 --- a/src/conductor/asyncio_client/automator/task_handler.py +++ b/src/conductor/asyncio_client/automator/task_handler.py @@ -13,7 +13,7 @@ from conductor.asyncio_client.telemetry.metrics_collector import AsyncMetricsCollector from conductor.asyncio_client.worker.worker import Worker from conductor.asyncio_client.worker.worker_interface import WorkerInterface -from conductor.shared.configuration.settings.metrics_settings import MetricsSettings +from conductor.shared.telemetry.configuration.metrics import MetricsSettings logger = logging.getLogger(Configuration.get_logging_formatted_name(__name__)) @@ -51,13 +51,14 @@ def register_decorated_fn( class TaskHandler: def __init__( self, - workers: Optional[List[WorkerInterface]] = None, - configuration: Optional[Configuration] = None, + workers: List[WorkerInterface], + configuration: Configuration, metrics_settings: Optional[MetricsSettings] = None, scan_for_annotated_workers: bool = True, import_modules: Optional[List[str]] = None, ): - workers = workers or [] + import_modules = import_modules or [] + self.metrics_provider_process: Optional[Process] = None self.logger_process, self.queue = _setup_logging_queue(configuration) # imports @@ -68,8 +69,6 @@ def __init__( logger.debug("Loading module %s", module) importlib.import_module(module) - elif not isinstance(workers, list): - workers = [workers] if scan_for_annotated_workers is True: for (task_def_name, domain), record in _decorated_functions.items(): fn = record["func"] @@ -124,10 +123,13 @@ def join_processes(self) -> None: logger.info("KeyboardInterrupt: Stopping all processes") self.stop_processes() - def __create_metrics_provider_process(self, metrics_settings: MetricsSettings) -> None: + def __create_metrics_provider_process( + self, metrics_settings: Optional[MetricsSettings] = None + ) -> None: if metrics_settings is None: self.metrics_provider_process = None return + self.metrics_provider_process = Process( target=self.coroutine_as_process_target, args=(AsyncMetricsCollector.provide_metrics, metrics_settings), @@ -138,9 +140,9 @@ def __create_task_runner_processes( self, workers: List[WorkerInterface], configuration: Configuration, - metrics_settings: MetricsSettings, + metrics_settings: Optional[MetricsSettings] = None, ) -> None: - self.task_runner_processes = [] + self.task_runner_processes: List[Process] = [] for worker in workers: self.__create_task_runner_process(worker, configuration, metrics_settings) @@ -148,7 +150,7 @@ def __create_task_runner_process( self, worker: WorkerInterface, configuration: Configuration, - metrics_settings: MetricsSettings, + metrics_settings: Optional[MetricsSettings] = None, ) -> None: task_runner = AsyncTaskRunner(worker, configuration, metrics_settings) process = Process(target=self.coroutine_as_process_target, args=(task_runner.run,)) @@ -208,7 +210,7 @@ def __stop_process(self, process: Process): # Setup centralized logging queue def _setup_logging_queue(configuration: Configuration): - queue = Queue() + queue: Queue[Optional[logging.LogRecord]] = Queue() if configuration: configuration.apply_logging_config() log_level = configuration.log_level diff --git a/src/conductor/asyncio_client/automator/task_runner.py b/src/conductor/asyncio_client/automator/task_runner.py index b12f51bf..5a8ea422 100644 --- a/src/conductor/asyncio_client/automator/task_runner.py +++ b/src/conductor/asyncio_client/automator/task_runner.py @@ -23,7 +23,7 @@ from conductor.asyncio_client.http.exceptions import UnauthorizedException from conductor.asyncio_client.telemetry.metrics_collector import AsyncMetricsCollector from conductor.asyncio_client.worker.worker_interface import WorkerInterface -from conductor.shared.configuration.settings.metrics_settings import MetricsSettings +from conductor.shared.telemetry.configuration.metrics import MetricsSettings logger = logging.getLogger(Configuration.get_logging_formatted_name(__name__)) @@ -32,8 +32,8 @@ class AsyncTaskRunner: def __init__( self, worker: WorkerInterface, - configuration: Configuration = None, - metrics_settings: MetricsSettings = None, + configuration: Optional[Configuration] = None, + metrics_settings: Optional[MetricsSettings] = None, ): if not isinstance(worker, WorkerInterface): raise Exception("Invalid worker") @@ -78,7 +78,8 @@ async def run_once(self) -> None: task = await self.__poll_task() if task is not None and task.task_id is not None: task_result = await self.__execute_task(task) - await self.__update_task(task_result) + if task_result is not None: + await self.__update_task(task_result) await self.__wait_for_polling_interval() self.worker.clear_task_definition_name_cache() except Exception: @@ -95,10 +96,9 @@ async def __poll_task(self) -> Optional[TaskAdapter]: try: start_time = time.time() domain = self.worker.get_domain() - params = {"workerid": self.worker.get_identity()} - if domain is not None: - params["domain"] = domain - task = await self.task_client.poll(tasktype=task_definition_name, **params) + task = await self.task_client.poll( + tasktype=task_definition_name, workerid=self.worker.get_identity(), domain=domain + ) finish_time = time.time() time_spent = finish_time - start_time if self.metrics_collector is not None: diff --git a/src/conductor/asyncio_client/configuration/configuration.py b/src/conductor/asyncio_client/configuration/configuration.py index 6a5dd6e9..55102039 100644 --- a/src/conductor/asyncio_client/configuration/configuration.py +++ b/src/conductor/asyncio_client/configuration/configuration.py @@ -173,7 +173,7 @@ def __init__( # Proxy configuration - can be set via parameter or environment variable self.proxy = proxy or os.getenv("CONDUCTOR_PROXY") # Proxy headers - can be set via parameter or environment variable - self.proxy_headers = proxy_headers + self.proxy_headers: Optional[Dict[str, Any]] = proxy_headers if not self.proxy_headers and os.getenv("CONDUCTOR_PROXY_HEADERS"): try: self.proxy_headers = json.loads(os.getenv("CONDUCTOR_PROXY_HEADERS")) @@ -466,7 +466,7 @@ def get_poll_interval_seconds(self) -> int: # Properties for commonly used HTTP configuration attributes @property - def host(self) -> str: + def host(self) -> Optional[str]: """Get server host URL.""" if getattr(self, "_http_config", None) is not None: return self._http_config.host diff --git a/src/conductor/asyncio_client/event/event_client.py b/src/conductor/asyncio_client/event/event_client.py index dc07ef7e..879cb563 100644 --- a/src/conductor/asyncio_client/event/event_client.py +++ b/src/conductor/asyncio_client/event/event_client.py @@ -1,12 +1,10 @@ -from __future__ import annotations - from typing import List +from conductor.asyncio_client.adapters import ApiClient from conductor.asyncio_client.adapters.api.event_resource_api import ( EventResourceApiAdapter, ) from conductor.asyncio_client.adapters.models.tag_adapter import TagAdapter -from conductor.asyncio_client.adapters import ApiClient from conductor.shared.event.configuration import QueueConfiguration diff --git a/src/conductor/asyncio_client/orkes/orkes_authorization_client.py b/src/conductor/asyncio_client/orkes/orkes_authorization_client.py index af3283f7..b06e915d 100644 --- a/src/conductor/asyncio_client/orkes/orkes_authorization_client.py +++ b/src/conductor/asyncio_client/orkes/orkes_authorization_client.py @@ -1,22 +1,25 @@ from __future__ import annotations -from typing import List +from typing import Any, Dict, List, Optional, cast from conductor.asyncio_client.adapters import ApiClient from conductor.asyncio_client.adapters.models.authorization_request_adapter import ( AuthorizationRequestAdapter as AuthorizationRequest, ) from conductor.asyncio_client.adapters.models.conductor_user_adapter import ( - ConductorUserAdapter as ConductorUser, + ConductorUserAdapter, +) +from conductor.asyncio_client.adapters.models.create_or_update_application_request_adapter import ( + CreateOrUpdateApplicationRequestAdapter, ) from conductor.asyncio_client.adapters.models.extended_conductor_application_adapter import ( - ExtendedConductorApplicationAdapter as ExtendedConductorApplication, + ExtendedConductorApplicationAdapter, ) from conductor.asyncio_client.adapters.models.granted_access_adapter import ( GrantedAccessAdapter as GrantedAccess, ) -from conductor.asyncio_client.adapters.models.group_adapter import GroupAdapter as Group -from conductor.asyncio_client.adapters.models.tag_adapter import TagAdapter as Tag +from conductor.asyncio_client.adapters.models.group_adapter import GroupAdapter +from conductor.asyncio_client.adapters.models.tag_adapter import TagAdapter from conductor.asyncio_client.adapters.models.target_ref_adapter import ( TargetRefAdapter as TargetRef, ) @@ -38,86 +41,91 @@ def __init__(self, configuration: Configuration, api_client: ApiClient): # User Operations async def create_user( self, user_id: str, upsert_user_request: UpsertUserRequest - ) -> ConductorUser: + ) -> ConductorUserAdapter: """Create a new user""" return await self.user_api.upsert_user(id=user_id, upsert_user_request=upsert_user_request) async def update_user( self, user_id: str, upsert_user_request: UpsertUserRequest - ) -> ConductorUser: + ) -> ConductorUserAdapter: """Update an existing user""" return await self.user_api.upsert_user(id=user_id, upsert_user_request=upsert_user_request) - async def get_user(self, user_id: str) -> ConductorUser: + async def get_user(self, user_id: str) -> Optional[ConductorUserAdapter]: """Get user by ID""" - user = await self.user_api.get_user(id=user_id) - - return ConductorUser.from_dict(user) + result = await self.user_api.get_user(id=user_id) + return ConductorUserAdapter.from_dict(result) async def delete_user(self, user_id: str) -> None: """Delete user by ID""" await self.user_api.delete_user(id=user_id) - async def list_users(self, include_apps: bool = False) -> List[ConductorUser]: + async def list_users(self, include_apps: bool = False) -> List[ConductorUserAdapter]: """List all users""" return await self.user_api.list_users(apps=include_apps) # Application Operations async def create_application( - self, application: ExtendedConductorApplication - ) -> ExtendedConductorApplication: + self, application: CreateOrUpdateApplicationRequestAdapter + ) -> Optional[ExtendedConductorApplicationAdapter]: """Create a new application""" - app = await self.application_api.create_application( + result = await self.application_api.create_application( create_or_update_application_request=application ) - return ExtendedConductorApplication.from_dict(app) + return ExtendedConductorApplicationAdapter.from_dict(result) async def update_application( - self, application_id: str, application: ExtendedConductorApplication - ) -> ExtendedConductorApplication: + self, application_id: str, application: CreateOrUpdateApplicationRequestAdapter + ) -> Optional[ExtendedConductorApplicationAdapter]: """Update an existing application""" - app = await self.application_api.update_application( + result = await self.application_api.update_application( id=application_id, create_or_update_application_request=application ) - return ExtendedConductorApplication.from_dict(app) + return ExtendedConductorApplicationAdapter.from_dict(result) - async def get_application(self, application_id: str) -> ExtendedConductorApplication: + async def get_application( + self, application_id: str + ) -> Optional[ExtendedConductorApplicationAdapter]: """Get application by ID""" - app = await self.application_api.get_application(id=application_id) - return ExtendedConductorApplication.from_dict(app) + result = await self.application_api.get_application(id=application_id) + return ExtendedConductorApplicationAdapter.from_dict(result) async def delete_application(self, application_id: str) -> None: """Delete application by ID""" await self.application_api.delete_application(id=application_id) - async def list_applications(self) -> List[ExtendedConductorApplication]: + async def list_applications(self) -> List[ExtendedConductorApplicationAdapter]: """List all applications""" return await self.application_api.list_applications() # Group Operations - async def create_group(self, group_id: str, upsert_group_request: UpsertGroupRequest) -> Group: + async def create_group( + self, group_id: str, upsert_group_request: UpsertGroupRequest + ) -> GroupAdapter: """Create a new group""" return await self.group_api.upsert_group( id=group_id, upsert_group_request=upsert_group_request ) - async def update_group(self, group_id: str, upsert_group_request: UpsertGroupRequest) -> Group: + async def update_group( + self, group_id: str, upsert_group_request: UpsertGroupRequest + ) -> Optional[GroupAdapter]: """Update an existing group""" - group = await self.group_api.upsert_group( + result = await self.group_api.upsert_group( id=group_id, upsert_group_request=upsert_group_request ) - return Group.from_dict(group) + return GroupAdapter.from_dict(result) - async def get_group(self, group_id: str) -> Group: + async def get_group(self, group_id: str) -> Optional[GroupAdapter]: """Get group by ID""" - group = await self.group_api.get_group(id=group_id) - return Group.from_dict(group) + result = await self.group_api.get_group(id=group_id) + return GroupAdapter.from_dict(result) async def delete_group(self, group_id: str) -> None: """Delete group by ID""" await self.group_api.delete_group(id=group_id) - async def list_groups(self) -> List[Group]: + async def list_groups(self) -> List[GroupAdapter]: """List all groups""" return await self.group_api.list_groups() @@ -130,11 +138,11 @@ async def remove_user_from_group(self, group_id: str, user_id: str) -> object: """Remove a user from a group""" return await self.group_api.remove_user_from_group(group_id=group_id, user_id=user_id) - async def add_users_to_group(self, group_id: str, user_ids: List[str]) -> object: + async def add_users_to_group(self, group_id: str, user_ids: List[str]) -> None: """Add multiple users to a group""" return await self.group_api.add_users_to_group(group_id=group_id, request_body=user_ids) - async def remove_users_from_group(self, group_id: str, user_ids: List[str]) -> object: + async def remove_users_from_group(self, group_id: str, user_ids: List[str]) -> None: """Remove multiple users from a group""" return await self.group_api.remove_users_from_group( group_id=group_id, request_body=user_ids @@ -168,23 +176,25 @@ async def get_group_permissions(self, group_id: str) -> object: # Convenience Methods async def upsert_user( self, user_id: str, upsert_user_request: UpsertUserRequest - ) -> ConductorUser: + ) -> Optional[ConductorUserAdapter]: """Alias for create_user/update_user""" - user = await self.create_user(user_id, upsert_user_request) - return ConductorUser.from_dict(user) + result = await self.create_user(user_id, upsert_user_request) + return ConductorUserAdapter.from_dict(result) - async def upsert_group(self, group_id: str, upsert_group_request: UpsertGroupRequest) -> Group: + async def upsert_group( + self, group_id: str, upsert_group_request: UpsertGroupRequest + ) -> Optional[GroupAdapter]: """Alias for create_group/update_group""" - group = await self.create_group(group_id, upsert_group_request) - return Group.from_dict(group) + result = await self.create_group(group_id, upsert_group_request) + return GroupAdapter.from_dict(result) - async def set_application_tags(self, tags: List[Tag], application_id: str): + async def set_application_tags(self, tags: List[TagAdapter], application_id: str): await self.application_api.put_tag_for_application(application_id, tags) - async def get_application_tags(self, application_id: str) -> List[Tag]: + async def get_application_tags(self, application_id: str) -> List[TagAdapter]: return await self.application_api.get_tags_for_application(application_id) - async def delete_application_tags(self, tags: List[Tag], application_id: str): + async def delete_application_tags(self, tags: List[TagAdapter], application_id: str): await self.application_api.delete_tag_for_application(application_id, tags) async def create_access_key(self, application_id: str) -> AccessKey: @@ -210,15 +220,25 @@ async def remove_role_from_application_user(self, application_id: str, role: str async def get_granted_permissions_for_group(self, group_id: str) -> List[GrantedAccess]: granted_access_obj = await self.group_api.get_granted_permissions1(group_id) + + if not granted_access_obj.granted_access: + return [] + granted_permissions = [] for ga in granted_access_obj.granted_access: + if not ga.target: + continue + target = TargetRef(type=ga.target.type, id=ga.target.id) access = ga.access granted_permissions.append(GrantedAccess(target=target, access=access)) + return granted_permissions async def get_granted_permissions_for_user(self, user_id: str) -> List[GrantedAccess]: - granted_access_obj = await self.user_api.get_granted_permissions(user_id) + granted_access_obj = cast( + Dict[str, Any], await self.user_api.get_granted_permissions(user_id) + ) granted_permissions = [] for ga in granted_access_obj["grantedAccess"]: target = TargetRef(type=ga["target"]["type"], id=ga["target"]["id"]) @@ -228,8 +248,6 @@ async def get_granted_permissions_for_user(self, user_id: str) -> List[GrantedAc async def get_app_by_access_key_id( self, access_key_id: str, *args, **kwargs - ) -> ExtendedConductorApplication: - application_access_key_obj = await self.application_api.get_app_by_access_key_id( - access_key_id, *args, **kwargs - ) - return ExtendedConductorApplication.from_dict(application_access_key_obj) + ) -> Optional[ExtendedConductorApplicationAdapter]: + result = await self.application_api.get_app_by_access_key_id(access_key_id, *args, **kwargs) + return ExtendedConductorApplicationAdapter.from_dict(result) diff --git a/src/conductor/asyncio_client/orkes/orkes_base_client.py b/src/conductor/asyncio_client/orkes/orkes_base_client.py index acae1844..fd389178 100644 --- a/src/conductor/asyncio_client/orkes/orkes_base_client.py +++ b/src/conductor/asyncio_client/orkes/orkes_base_client.py @@ -1,5 +1,6 @@ import logging +from conductor.asyncio_client.adapters import ApiClient from conductor.asyncio_client.adapters.api.application_resource_api import ( ApplicationResourceApiAdapter, ) @@ -24,7 +25,6 @@ EventExecutionResourceApiAdapter, ) from conductor.asyncio_client.configuration.configuration import Configuration -from conductor.asyncio_client.adapters import ApiClient class OrkesBaseClient: diff --git a/src/conductor/asyncio_client/orkes/orkes_clients.py b/src/conductor/asyncio_client/orkes/orkes_clients.py index 0b74ac69..fd2a1049 100644 --- a/src/conductor/asyncio_client/orkes/orkes_clients.py +++ b/src/conductor/asyncio_client/orkes/orkes_clients.py @@ -2,8 +2,8 @@ from typing import Optional -from conductor.asyncio_client.configuration.configuration import Configuration from conductor.asyncio_client.adapters import ApiClient +from conductor.asyncio_client.configuration.configuration import Configuration from conductor.asyncio_client.orkes.orkes_authorization_client import OrkesAuthorizationClient from conductor.asyncio_client.orkes.orkes_integration_client import OrkesIntegrationClient from conductor.asyncio_client.orkes.orkes_metadata_client import OrkesMetadataClient diff --git a/src/conductor/asyncio_client/orkes/orkes_integration_client.py b/src/conductor/asyncio_client/orkes/orkes_integration_client.py index 9753a2ba..e96b31a0 100644 --- a/src/conductor/asyncio_client/orkes/orkes_integration_client.py +++ b/src/conductor/asyncio_client/orkes/orkes_integration_client.py @@ -1,8 +1,9 @@ from __future__ import annotations -from typing import Optional, List, Dict + +from typing import Dict, List, Optional from conductor.asyncio_client.adapters import ApiClient -from conductor.asyncio_client.http.configuration import Configuration +from conductor.asyncio_client.adapters.models.event_log_adapter import EventLogAdapter from conductor.asyncio_client.adapters.models.integration_adapter import IntegrationAdapter from conductor.asyncio_client.adapters.models.integration_api_adapter import IntegrationApiAdapter from conductor.asyncio_client.adapters.models.integration_api_update_adapter import ( @@ -12,8 +13,9 @@ from conductor.asyncio_client.adapters.models.integration_update_adapter import ( IntegrationUpdateAdapter, ) +from conductor.asyncio_client.adapters.models.message_template_adapter import MessageTemplateAdapter from conductor.asyncio_client.adapters.models.tag_adapter import TagAdapter -from conductor.asyncio_client.adapters.models.event_log_adapter import EventLogAdapter +from conductor.asyncio_client.configuration.configuration import Configuration from conductor.asyncio_client.http.exceptions import NotFoundException from conductor.asyncio_client.orkes.orkes_base_client import OrkesBaseClient @@ -34,11 +36,11 @@ async def save_integration( ) -> None: await self.integration_api.save_integration_provider(integration_name, integration_details) - async def get_integration_provider(self, name: str) -> IntegrationDefAdapter: + async def get_integration_provider(self, name: str) -> IntegrationAdapter: """Get integration provider by name""" return await self.integration_api.get_integration_provider(name) - async def get_integration(self, integration_name: str) -> IntegrationDefAdapter | None: + async def get_integration(self, integration_name: str) -> Optional[IntegrationAdapter]: try: return await self.get_integration_provider(integration_name) except NotFoundException: @@ -50,7 +52,7 @@ async def delete_integration_provider(self, name: str) -> None: async def get_integration_providers( self, category: Optional[str] = None, active_only: Optional[bool] = None - ) -> List[IntegrationDefAdapter]: + ) -> List[IntegrationAdapter]: """Get all integration providers""" return await self.integration_api.get_integration_providers( category=category, active_only=active_only @@ -81,12 +83,12 @@ async def get_integration_apis(self, integration_name: str) -> List[IntegrationA """Get all APIs for a specific integration""" return await self.integration_api.get_integration_apis(integration_name) - async def get_integration_available_apis(self, name: str) -> List[IntegrationApiAdapter]: + async def get_integration_available_apis(self, name: str) -> List[str]: """Get available APIs for an integration""" return await self.integration_api.get_integration_available_apis(name) # Integration Operations - async def save_all_integrations(self, request_body: List[IntegrationUpdateAdapter]) -> None: + async def save_all_integrations(self, request_body: List[IntegrationAdapter]) -> None: """Save all integrations""" await self.integration_api.save_all_integrations(request_body) @@ -100,7 +102,7 @@ async def get_all_integrations( async def get_providers_and_integrations( self, integration_type: Optional[str] = None, active_only: Optional[bool] = None - ) -> Dict[str, object]: + ) -> List[str]: """Get providers and integrations together""" return await self.integration_api.get_providers_and_integrations( type=integration_type, active_only=active_only @@ -146,7 +148,7 @@ async def get_token_usage_for_integration(self, name: str, integration_name: str """Get token usage for a specific integration""" return await self.integration_api.get_token_usage_for_integration(name, integration_name) - async def get_token_usage_for_integration_provider(self, name: str) -> int: + async def get_token_usage_for_integration_provider(self, name: str) -> Dict[str, str]: """Get token usage for an integration provider""" return await self.integration_api.get_token_usage_for_integration_provider(name) @@ -165,7 +167,7 @@ async def associate_prompt_with_integration( async def get_prompts_with_integration( self, integration_provider: str, integration_name: str - ) -> List[str]: + ) -> List[MessageTemplateAdapter]: """Get prompts associated with an integration""" return await self.integration_api.get_prompts_with_integration( integration_provider, integration_name @@ -189,10 +191,10 @@ async def get_active_integrations(self) -> List[IntegrationAdapter]: async def get_integration_provider_by_category( self, category: str, active_only: bool = True - ) -> List[IntegrationDefAdapter]: + ) -> List[IntegrationAdapter]: """Get integration providers filtered by category""" return await self.get_integration_providers(category=category, active_only=active_only) - async def get_active_integration_providers(self) -> List[IntegrationDefAdapter]: + async def get_active_integration_providers(self) -> List[IntegrationAdapter]: """Get only active integration providers""" return await self.get_integration_providers(active_only=True) diff --git a/src/conductor/asyncio_client/orkes/orkes_metadata_client.py b/src/conductor/asyncio_client/orkes/orkes_metadata_client.py index 63928b4c..2bce4de0 100644 --- a/src/conductor/asyncio_client/orkes/orkes_metadata_client.py +++ b/src/conductor/asyncio_client/orkes/orkes_metadata_client.py @@ -2,17 +2,17 @@ from typing import List, Optional +from conductor.asyncio_client.adapters import ApiClient from conductor.asyncio_client.adapters.models.extended_task_def_adapter import ( ExtendedTaskDefAdapter, ) from conductor.asyncio_client.adapters.models.extended_workflow_def_adapter import ( ExtendedWorkflowDefAdapter, ) +from conductor.asyncio_client.adapters.models.tag_adapter import TagAdapter from conductor.asyncio_client.adapters.models.task_def_adapter import TaskDefAdapter from conductor.asyncio_client.adapters.models.workflow_def_adapter import WorkflowDefAdapter -from conductor.asyncio_client.adapters.models.tag_adapter import TagAdapter -from conductor.asyncio_client.adapters import ApiClient -from conductor.asyncio_client.http.configuration import Configuration +from conductor.asyncio_client.configuration.configuration import Configuration from conductor.asyncio_client.orkes.orkes_base_client import OrkesBaseClient diff --git a/src/conductor/asyncio_client/orkes/orkes_prompt_client.py b/src/conductor/asyncio_client/orkes/orkes_prompt_client.py index 20e04391..c103aaaa 100644 --- a/src/conductor/asyncio_client/orkes/orkes_prompt_client.py +++ b/src/conductor/asyncio_client/orkes/orkes_prompt_client.py @@ -2,6 +2,7 @@ from typing import List, Optional +from conductor.asyncio_client.adapters import ApiClient from conductor.asyncio_client.adapters.models.message_template_adapter import ( MessageTemplateAdapter, ) @@ -9,8 +10,7 @@ PromptTemplateTestRequestAdapter, ) from conductor.asyncio_client.adapters.models.tag_adapter import TagAdapter -from conductor.asyncio_client.adapters import ApiClient -from conductor.asyncio_client.http.configuration import Configuration +from conductor.asyncio_client.configuration.configuration import Configuration from conductor.asyncio_client.orkes.orkes_base_client import OrkesBaseClient @@ -94,11 +94,13 @@ async def get_templates_by_tag( matching_templates = [] for template in all_templates: + if not template.name: + continue try: tags = await self.get_tags_for_prompt_template(template.name) if any(tag.key == tag_key and tag.value == tag_value for tag in tags): matching_templates.append(template) - except Exception: # noqa: PERF203 + except Exception: continue return matching_templates @@ -113,7 +115,7 @@ async def clone_template( await self.save_message_template( target_name, description, - source_template.template, + source_template.template or "", models=(source_template.models if hasattr(source_template, "models") else None), ) @@ -152,7 +154,9 @@ async def search_templates_by_name(self, name_pattern: str) -> List[MessageTempl """Search templates by name pattern (case-insensitive)""" all_templates = await self.get_message_templates() return [ - template for template in all_templates if name_pattern.lower() in template.name.lower() + template + for template in all_templates + if template.name and name_pattern.lower() in template.name.lower() ] async def get_templates_with_model(self, model_name: str) -> List[MessageTemplateAdapter]: diff --git a/src/conductor/asyncio_client/orkes/orkes_scheduler_client.py b/src/conductor/asyncio_client/orkes/orkes_scheduler_client.py index 3935483f..88d99d30 100644 --- a/src/conductor/asyncio_client/orkes/orkes_scheduler_client.py +++ b/src/conductor/asyncio_client/orkes/orkes_scheduler_client.py @@ -2,6 +2,7 @@ from typing import Dict, List, Optional +from conductor.asyncio_client.adapters import ApiClient from conductor.asyncio_client.adapters.models.save_schedule_request_adapter import ( SaveScheduleRequestAdapter, ) @@ -18,8 +19,7 @@ from conductor.asyncio_client.adapters.models.workflow_schedule_model_adapter import ( WorkflowScheduleModelAdapter, ) -from conductor.asyncio_client.adapters import ApiClient -from conductor.asyncio_client.http.configuration import Configuration +from conductor.asyncio_client.configuration.configuration import Configuration from conductor.asyncio_client.orkes.orkes_base_client import OrkesBaseClient @@ -77,11 +77,9 @@ async def search_schedules( start=start, size=size, sort=sort, free_text=free_text, query=query ) - async def get_schedules_by_tag( - self, tag_key: str, tag_value: str - ) -> List[WorkflowScheduleModelAdapter]: + async def get_schedules_by_tag(self, tag_value: str) -> List[WorkflowScheduleModelAdapter]: """Get schedules filtered by tag key and value""" - return await self.scheduler_api.get_schedules_by_tag(tag_key, tag_value) + return await self.scheduler_api.get_schedules_by_tag(tag_value) # Schedule Planning & Analysis async def get_next_few_schedules( @@ -172,10 +170,12 @@ async def update_schedule( cron_expression=cron_expression or existing_schedule.cron_expression, start_workflow_request=existing_schedule.start_workflow_request, paused=paused if paused is not None else existing_schedule.paused, - run_catch_up=( - run_catch_up if run_catch_up is not None else existing_schedule.run_catch_up + run_catchup_schedule_instances=( + run_catch_up + if run_catch_up is not None + else existing_schedule.run_catchup_schedule_instances ), - timezone=timezone or existing_schedule.timezone, + zone_id=timezone or existing_schedule.zone_id, ) return await self.save_schedule(save_request) @@ -252,8 +252,6 @@ async def get_schedule_count(self) -> int: schedules = await self.get_all_schedules() return len(schedules) - async def get_schedules_with_tag( - self, tag_key: str, tag_value: str - ) -> List[WorkflowScheduleModelAdapter]: + async def get_schedules_with_tag(self, tag_value: str) -> List[WorkflowScheduleModelAdapter]: """Get schedules that have a specific tag (alias for get_schedules_by_tag)""" - return await self.get_schedules_by_tag(tag_key, tag_value) + return await self.get_schedules_by_tag(tag_value) diff --git a/src/conductor/asyncio_client/orkes/orkes_schema_client.py b/src/conductor/asyncio_client/orkes/orkes_schema_client.py index 39a67ef8..06d4792e 100644 --- a/src/conductor/asyncio_client/orkes/orkes_schema_client.py +++ b/src/conductor/asyncio_client/orkes/orkes_schema_client.py @@ -2,9 +2,9 @@ from typing import List, Optional -from conductor.asyncio_client.adapters.models.schema_def_adapter import SchemaDefAdapter from conductor.asyncio_client.adapters import ApiClient -from conductor.asyncio_client.http.configuration import Configuration +from conductor.asyncio_client.adapters.models.schema_def_adapter import SchemaDefAdapter +from conductor.asyncio_client.configuration.configuration import Configuration from conductor.asyncio_client.orkes.orkes_base_client import OrkesBaseClient @@ -47,14 +47,14 @@ async def create_schema( name: str, version: int, schema_definition: dict, - description: Optional[str] = None, + schema_type: str = "JSON", ) -> None: """Create a new schema with simplified parameters""" schema_def = SchemaDefAdapter( name=name, version=version, - schema=schema_definition, - description=description, + data=schema_definition, + type=schema_type, ) await self.save_schema(schema_def) @@ -63,15 +63,15 @@ async def update_schema( name: str, version: int, schema_definition: dict, - description: Optional[str] = None, + schema_type: str = "JSON", create_new_version: bool = False, ) -> None: """Update an existing schema""" schema_def = SchemaDefAdapter( name=name, version=version, - schema=schema_definition, - description=description, + data=schema_definition, + type=schema_type, ) await self.save_schema(schema_def, new_version=create_new_version) @@ -129,8 +129,8 @@ async def bulk_save_schemas( schema_def = SchemaDefAdapter( name=schema_dict.get("name"), version=schema_dict.get("version"), - schema=schema_dict.get("schema"), - description=schema_dict.get("description"), + data=schema_dict.get("data"), + type=schema_dict.get("type", "JSON"), ) schema_defs.append(schema_def) @@ -149,8 +149,8 @@ async def clone_schema( cloned_schema = SchemaDefAdapter( name=target_name, version=target_version, - schema=source_schema.schema, - description=f"Clone of {source_schema.name} v{source_schema.version}", + data=source_schema.data, + type=source_schema.type, ) await self.save_schema(cloned_schema) @@ -166,15 +166,15 @@ async def search_schemas_by_name(self, name_pattern: str) -> List[SchemaDefAdapt schema for schema in all_schemas if name_pattern.lower() in (schema.name or "").lower() ] - async def get_schemas_with_description( - self, description_pattern: str + async def get_schemas_with_external_ref( + self, external_ref_pattern: str ) -> List[SchemaDefAdapter]: - """Find schemas that contain a specific text in their description""" + """Find schemas that contain a specific text in their external ref""" all_schemas = await self.get_all_schemas() return [ schema for schema in all_schemas - if schema.description and description_pattern.lower() in schema.description.lower() + if schema.external_ref and external_ref_pattern.lower() in schema.external_ref.lower() ] async def validate_schema_structure(self, schema_definition: dict) -> bool: @@ -187,7 +187,7 @@ async def get_schema_statistics(self) -> dict: all_schemas = await self.get_all_schemas() unique_names = set() - version_counts = {} + version_counts: dict[str, int] = {} for schema in all_schemas: if schema.name: @@ -197,7 +197,7 @@ async def get_schema_statistics(self) -> dict: return { "total_schemas": len(all_schemas), "unique_schema_names": len(unique_names), - "schemas_with_descriptions": len([s for s in all_schemas if s.description]), + "schemas_with_external_ref": len([s for s in all_schemas if s.external_ref]), "version_counts": version_counts, "schema_names": sorted(unique_names), } @@ -215,11 +215,11 @@ async def delete_schema(self, name: str, version: Optional[int] = None) -> None: await self.delete_schema_by_name(name) async def create_schema_version( - self, name: str, schema_definition: dict, description: Optional[str] = None + self, name: str, schema_definition: dict, schema_type: str = "JSON" ) -> None: """Create a new version of an existing schema""" # Get the highest version number for this schema versions = await self.get_schema_versions(name) new_version = max(versions) + 1 if versions else 1 - await self.create_schema(name, new_version, schema_definition, description) + await self.create_schema(name, new_version, schema_definition, schema_type) diff --git a/src/conductor/asyncio_client/orkes/orkes_secret_client.py b/src/conductor/asyncio_client/orkes/orkes_secret_client.py index 597485b5..d465824a 100644 --- a/src/conductor/asyncio_client/orkes/orkes_secret_client.py +++ b/src/conductor/asyncio_client/orkes/orkes_secret_client.py @@ -2,10 +2,10 @@ from typing import Dict, List +from conductor.asyncio_client.adapters import ApiClient from conductor.asyncio_client.adapters.models.extended_secret_adapter import ExtendedSecretAdapter from conductor.asyncio_client.adapters.models.tag_adapter import TagAdapter -from conductor.asyncio_client.adapters import ApiClient -from conductor.asyncio_client.http.configuration import Configuration +from conductor.asyncio_client.configuration.configuration import Configuration from conductor.asyncio_client.orkes.orkes_base_client import OrkesBaseClient diff --git a/src/conductor/asyncio_client/orkes/orkes_task_client.py b/src/conductor/asyncio_client/orkes/orkes_task_client.py index 683a3def..a5f2bfe8 100644 --- a/src/conductor/asyncio_client/orkes/orkes_task_client.py +++ b/src/conductor/asyncio_client/orkes/orkes_task_client.py @@ -2,6 +2,7 @@ from typing import Any, Dict, List, Optional +from conductor.asyncio_client.adapters import ApiClient from conductor.asyncio_client.adapters.models.poll_data_adapter import PollDataAdapter from conductor.asyncio_client.adapters.models.search_result_task_summary_adapter import ( SearchResultTaskSummaryAdapter, @@ -9,8 +10,8 @@ from conductor.asyncio_client.adapters.models.task_adapter import TaskAdapter from conductor.asyncio_client.adapters.models.task_exec_log_adapter import TaskExecLogAdapter from conductor.asyncio_client.adapters.models.task_result_adapter import TaskResultAdapter -from conductor.asyncio_client.adapters import ApiClient -from conductor.asyncio_client.http.configuration import Configuration +from conductor.asyncio_client.adapters.models.workflow_adapter import WorkflowAdapter +from conductor.asyncio_client.configuration.configuration import Configuration from conductor.asyncio_client.orkes.orkes_base_client import OrkesBaseClient @@ -77,7 +78,7 @@ async def update_task_sync( status: str, output: Dict[str, Any], worker_id: Optional[str] = None, - ) -> str: + ) -> WorkflowAdapter: """Update task synchronously by workflow ID and task reference name""" body = {"result": output} return await self.task_api.update_task_sync( diff --git a/src/conductor/asyncio_client/orkes/orkes_workflow_client.py b/src/conductor/asyncio_client/orkes/orkes_workflow_client.py index ec5586c6..b0f16f33 100644 --- a/src/conductor/asyncio_client/orkes/orkes_workflow_client.py +++ b/src/conductor/asyncio_client/orkes/orkes_workflow_client.py @@ -1,8 +1,9 @@ from __future__ import annotations import uuid -from typing import Any, Dict, List, Optional +from typing import Any, Dict, List, Optional, cast +from conductor.asyncio_client.adapters import ApiClient from conductor.asyncio_client.adapters.models.correlation_ids_search_request_adapter import ( CorrelationIdsSearchRequestAdapter, ) @@ -27,8 +28,7 @@ from conductor.asyncio_client.adapters.models.workflow_test_request_adapter import ( WorkflowTestRequestAdapter, ) -from conductor.asyncio_client.adapters import ApiClient -from conductor.asyncio_client.http.configuration import Configuration +from conductor.asyncio_client.configuration.configuration import Configuration from conductor.asyncio_client.orkes.orkes_base_client import OrkesBaseClient @@ -72,7 +72,7 @@ async def execute_workflow( """Execute a workflow synchronously""" return await self.workflow_api.execute_workflow( name=start_workflow_request.name, - version=start_workflow_request.version, + version=start_workflow_request.version or 1, request_id=request_id, start_workflow_request=start_workflow_request, wait_until_task_ref=wait_until_task_ref, @@ -228,7 +228,7 @@ async def skip_task_from_workflow( self, workflow_id: str, task_reference_name: str, - skip_task_request: SkipTaskRequestAdapter, + skip_task_request: Optional[SkipTaskRequestAdapter] = None, ) -> None: """Skip a task in a workflow""" await self.workflow_api.skip_task_from_workflow( @@ -256,11 +256,10 @@ async def update_workflow_state( ) -> WorkflowAdapter: """Update workflow state""" # Convert the adapter to dict for the API call - request_body = ( - workflow_state_update.to_dict() - if hasattr(workflow_state_update, "to_dict") - else workflow_state_update - ) + if hasattr(workflow_state_update, "to_dict"): + request_body: Dict[str, Any] = workflow_state_update.to_dict() + else: + request_body = cast(Dict[str, Any], workflow_state_update) return await self.workflow_api.update_workflow_state( workflow_id=workflow_id, request_body=request_body ) diff --git a/src/conductor/asyncio_client/telemetry/metrics_collector.py b/src/conductor/asyncio_client/telemetry/metrics_collector.py index 65e0cc21..da644f7a 100644 --- a/src/conductor/asyncio_client/telemetry/metrics_collector.py +++ b/src/conductor/asyncio_client/telemetry/metrics_collector.py @@ -234,7 +234,7 @@ async def __increment_counter( if not self.must_collect_metrics: return counter = await self.__get_counter( - name=name, documentation=documentation, labelnames=labels.keys() + name=name, documentation=documentation, labelnames=list(labels.keys()) ) counter.labels(*labels.values()).inc() @@ -249,7 +249,7 @@ async def __record_gauge( if not self.must_collect_metrics: return gauge = await self.__get_gauge( - name=name, documentation=documentation, labelnames=labels.keys() + name=name, documentation=documentation, labelnames=list(labels.keys()) ) gauge.labels(*labels.values()).set(value) diff --git a/src/conductor/asyncio_client/worker/worker.py b/src/conductor/asyncio_client/worker/worker.py index 0b00e1e4..8db00c83 100644 --- a/src/conductor/asyncio_client/worker/worker.py +++ b/src/conductor/asyncio_client/worker/worker.py @@ -8,6 +8,7 @@ from copy import deepcopy from typing import Any, Callable, Optional, Union +from conductor.asyncio_client.adapters import ApiClient from conductor.asyncio_client.adapters.models.task_adapter import TaskAdapter from conductor.asyncio_client.adapters.models.task_exec_log_adapter import ( TaskExecLogAdapter, @@ -16,7 +17,6 @@ TaskResultAdapter, ) from conductor.asyncio_client.configuration import Configuration -from conductor.asyncio_client.adapters import ApiClient from conductor.asyncio_client.worker.worker_interface import WorkerInterface from conductor.shared.automator import utils from conductor.shared.automator.utils import convert_from_dict_or_list @@ -80,7 +80,8 @@ def execute(self, task: TaskAdapter) -> TaskResultAdapter: task_input[input_name] = task.input_data[input_name] else: task_input[input_name] = convert_from_dict_or_list( - typ, task.input_data[input_name] + typ, + task.input_data[input_name], ) elif default_value is not inspect.Parameter.empty: task_input[input_name] = default_value diff --git a/src/conductor/asyncio_client/workflow/conductor_workflow.py b/src/conductor/asyncio_client/workflow/conductor_workflow.py index 9f1d1ae0..184d423a 100644 --- a/src/conductor/asyncio_client/workflow/conductor_workflow.py +++ b/src/conductor/asyncio_client/workflow/conductor_workflow.py @@ -43,22 +43,22 @@ def __init__( version: Optional[int] = None, description: Optional[str] = None, ): - self._executor = executor - self.name = name - self.version = version - self.description = description - self._tasks = [] - self._owner_email = None - self._timeout_policy = None - self._timeout_seconds = 60 - self._failure_workflow = "" - self._input_parameters = [] - self._output_parameters = {} - self._input_template = {} - self._variables = {} - self._restartable = True - self._workflow_status_listener_enabled = False - self._workflow_status_listener_sink = None + self._executor: AsyncWorkflowExecutor = executor + self.name: str = name + self._version: Optional[int] = version + self._description: Optional[str] = description + self._tasks: List[TaskInterface] = [] + self._owner_email: Optional[str] = None + self._timeout_policy: Optional[TimeoutPolicy] = None + self._timeout_seconds: int = 60 + self._failure_workflow: str = "" + self._input_parameters: List[str] = [] + self._output_parameters: Dict[str, Any] = {} + self._input_template: Dict[str, Any] = {} + self._variables: Dict[str, Any] = {} + self._restartable: bool = True + self._workflow_status_listener_enabled: bool = False + self._workflow_status_listener_sink: Optional[str] = None @property def name(self) -> str: @@ -71,7 +71,7 @@ def name(self, name: str) -> None: self._name = deepcopy(name) @property - def version(self) -> int: + def version(self) -> Union[int, None]: return self._version @version.setter @@ -81,7 +81,7 @@ def version(self, version: int) -> None: self._version = deepcopy(version) @property - def description(self) -> str: + def description(self) -> Union[str, None]: return self._description @description.setter @@ -103,7 +103,7 @@ def timeout_seconds(self, timeout_seconds: int): return self def owner_email(self, owner_email: str): - if not isinstance(owner_email, str): + if not isinstance(owner_email, str) or not owner_email: raise Exception("Invalid type") self._owner_email = deepcopy(owner_email) return self @@ -124,7 +124,9 @@ def restartable(self, restartable: bool): self._restartable = deepcopy(restartable) return self - def enable_status_listener(self, sink_name: bool): + def enable_status_listener(self, sink_name: str): + if not isinstance(sink_name, str) or not sink_name: + raise Exception("Invalid type, sink_name must be a non-empty string") self._workflow_status_listener_sink = sink_name self._workflow_status_listener_enabled = True @@ -342,22 +344,22 @@ def to_workflow_task(self): def __get_workflow_task_list(self) -> List[WorkflowTaskAdapter]: # Flatten tasks into workflow_task_list - workflow_task_list = [ - wt - for task in self._tasks - for wt in ( - task.to_workflow_task() - if isinstance(task.to_workflow_task(), list) - else [task.to_workflow_task()] - ) - ] + workflow_task_list: List[WorkflowTaskAdapter] = [] + + for task in self._tasks: + wf_task = task.to_workflow_task() + + if isinstance(wf_task, list): + workflow_task_list.extend(wf_task) + else: + workflow_task_list.append(wf_task) - updated_task_list = [] + updated_task_list: List[WorkflowTaskAdapter] = [] for current, next_task in zip(workflow_task_list, [*workflow_task_list[1:], None]): updated_task_list.append(current) if current.type == "FORK_JOIN" and next_task is not None and next_task.type != "JOIN": - join_on = [ft[-1].task_reference_name for ft in current.fork_tasks] + join_on = [ft[-1].task_reference_name for ft in (current.fork_tasks or [])] join_task = JoinTask( task_ref_name=f"join_{current.task_reference_name}", join_on=join_on ) diff --git a/src/conductor/asyncio_client/workflow/executor/workflow_executor.py b/src/conductor/asyncio_client/workflow/executor/workflow_executor.py index 2d3b4e97..91282355 100644 --- a/src/conductor/asyncio_client/workflow/executor/workflow_executor.py +++ b/src/conductor/asyncio_client/workflow/executor/workflow_executor.py @@ -3,6 +3,7 @@ import uuid from typing import Any, Dict, List, Optional +from conductor.asyncio_client.adapters import ApiClient from conductor.asyncio_client.adapters.api.metadata_resource_api import MetadataResourceApiAdapter from conductor.asyncio_client.adapters.api.task_resource_api import TaskResourceApiAdapter from conductor.asyncio_client.adapters.models.correlation_ids_search_request_adapter import ( @@ -23,12 +24,12 @@ from conductor.asyncio_client.adapters.models.start_workflow_request_adapter import ( StartWorkflowRequestAdapter, ) +from conductor.asyncio_client.adapters.models.task_adapter import TaskAdapter from conductor.asyncio_client.adapters.models.task_result_adapter import TaskResultAdapter from conductor.asyncio_client.adapters.models.workflow_adapter import WorkflowAdapter from conductor.asyncio_client.adapters.models.workflow_run_adapter import WorkflowRunAdapter from conductor.asyncio_client.adapters.models.workflow_status_adapter import WorkflowStatusAdapter from conductor.asyncio_client.configuration.configuration import Configuration -from conductor.asyncio_client.adapters import ApiClient from conductor.asyncio_client.orkes.orkes_workflow_client import OrkesWorkflowClient @@ -168,9 +169,9 @@ async def get_workflow_status( async def search( self, - start: Optional[int] = None, - size: Optional[int] = None, - free_text: Optional[str] = None, + start: int = 0, + size: int = 100, + free_text: str = "*", query: Optional[str] = None, skip_cache: Optional[bool] = None, ) -> ScrollableSearchResultWorkflowSummaryAdapter: @@ -187,8 +188,8 @@ async def get_by_correlation_ids( self, workflow_name: str, correlation_ids: List[str], - include_closed: Optional[bool] = None, - include_tasks: Optional[bool] = None, + include_closed: bool = False, + include_tasks: bool = False, ) -> Dict[str, List[WorkflowAdapter]]: """Lists workflows for the given correlation id list""" return await self.workflow_client.get_by_correlation_ids( @@ -201,8 +202,8 @@ async def get_by_correlation_ids( async def get_by_correlation_ids_and_names( self, batch_request: CorrelationIdsSearchRequestAdapter, - include_closed: Optional[bool] = None, - include_tasks: Optional[bool] = None, + include_closed: bool = False, + include_tasks: bool = False, ) -> Dict[str, List[WorkflowAdapter]]: """ Given the list of correlation ids and list of workflow names, find and return workflows Returns a map with @@ -265,7 +266,7 @@ async def skip_task_from_workflow( self, workflow_id: str, task_reference_name: str, - skip_task_request: SkipTaskRequestAdapter = None, + skip_task_request: Optional[SkipTaskRequestAdapter] = None, ) -> None: """Skips a given task from a current running workflow""" return await self.workflow_client.skip_task_from_workflow( @@ -313,7 +314,7 @@ async def update_task_by_ref_name_sync( status=status, ) - async def get_task(self, task_id: str) -> str: + async def get_task(self, task_id: str) -> Optional[TaskAdapter]: """Get task by Id""" return await self.task_client.get_task(task_id=task_id) diff --git a/src/conductor/asyncio_client/workflow/task/do_while_task.py b/src/conductor/asyncio_client/workflow/task/do_while_task.py index 7d736529..ee97abc7 100644 --- a/src/conductor/asyncio_client/workflow/task/do_while_task.py +++ b/src/conductor/asyncio_client/workflow/task/do_while_task.py @@ -1,7 +1,7 @@ from __future__ import annotations from copy import deepcopy -from typing import List, Optional, Sequence, Union +from typing import List, Optional, Sequence from conductor.asyncio_client.adapters.models.workflow_task_adapter import WorkflowTaskAdapter from conductor.asyncio_client.workflow.task.task import ( @@ -35,7 +35,7 @@ def __init__( self, task_ref_name: str, iterations: int, - tasks: Union[TaskInterface, Sequence[TaskInterface]], + tasks: List[TaskInterface], ): super().__init__( task_ref_name=task_ref_name, @@ -48,7 +48,7 @@ class ForEachTask(DoWhileTask): def __init__( self, task_ref_name: str, - tasks: Union[TaskInterface, Sequence[TaskInterface]], + tasks: List[TaskInterface], iterate_over: str, variables: Optional[Sequence[str]] = None, ): diff --git a/src/conductor/asyncio_client/workflow/task/http_task.py b/src/conductor/asyncio_client/workflow/task/http_task.py index 949eef77..e1cbd45b 100644 --- a/src/conductor/asyncio_client/workflow/task/http_task.py +++ b/src/conductor/asyncio_client/workflow/task/http_task.py @@ -20,7 +20,7 @@ def __init__(self, task_ref_name: str, http_input: HttpInput | dict): }, ) - def status_code(self) -> int: + def status_code(self) -> str: return "${" + f"{self.task_reference_name}.output.response.statusCode" + "}" def headers(self, json_path: Optional[str] = None) -> str: diff --git a/src/conductor/asyncio_client/workflow/task/javascript_task.py b/src/conductor/asyncio_client/workflow/task/javascript_task.py index d1a911ec..6dedac7a 100644 --- a/src/conductor/asyncio_client/workflow/task/javascript_task.py +++ b/src/conductor/asyncio_client/workflow/task/javascript_task.py @@ -28,6 +28,6 @@ def output(self, json_path: Optional[str] = None) -> str: base_path = f"{self.task_reference_name}.output.result" return f"${{{base_path if json_path is None else f'{base_path}.{json_path}'}}}" - def evaluator_type(self, evaluator_type: str): + @TaskInterface.evaluator_type.setter + def evaluator_type(self, evaluator_type: str) -> None: self.input_parameters["evaluatorType"] = evaluator_type - return self diff --git a/src/conductor/asyncio_client/workflow/task/llm_tasks/llm_index_documents.py b/src/conductor/asyncio_client/workflow/task/llm_tasks/llm_index_documents.py index a05578fd..264ef75b 100644 --- a/src/conductor/asyncio_client/workflow/task/llm_tasks/llm_index_documents.py +++ b/src/conductor/asyncio_client/workflow/task/llm_tasks/llm_index_documents.py @@ -1,6 +1,6 @@ from __future__ import annotations -from typing import Optional +from typing import Any, Dict, Optional from conductor.asyncio_client.workflow.task.task import TaskInterface from conductor.shared.workflow.enums import TaskType @@ -41,7 +41,7 @@ def __init__( metadata: Optional[dict] = None, ): metadata = metadata or {} - input_params = { + input_params: Dict[str, Any] = { "vectorDB": vector_db, "namespace": namespace, "index": index, @@ -52,7 +52,7 @@ def __init__( "metadata": metadata, } - optional_input_params = {} + optional_input_params: Dict[str, Any] = {} if chunk_size is not None: optional_input_params.update({"chunkSize": chunk_size}) diff --git a/src/conductor/asyncio_client/workflow/task/llm_tasks/llm_text_complete.py b/src/conductor/asyncio_client/workflow/task/llm_tasks/llm_text_complete.py index 9a43557b..6fe0e0b5 100644 --- a/src/conductor/asyncio_client/workflow/task/llm_tasks/llm_text_complete.py +++ b/src/conductor/asyncio_client/workflow/task/llm_tasks/llm_text_complete.py @@ -1,6 +1,6 @@ from __future__ import annotations -from typing import Dict, List, Optional +from typing import Any, Dict, List, Optional from conductor.asyncio_client.workflow.task.task import TaskInterface from conductor.shared.workflow.enums import TaskType @@ -20,7 +20,7 @@ def __init__( task_name: Optional[str] = None, ): stop_words = stop_words or [] - optional_input_params = {} + optional_input_params: Dict[str, Any] = {} if stop_words: optional_input_params.update({"stopWords": stop_words}) @@ -31,7 +31,7 @@ def __init__( if not task_name: task_name = "llm_text_complete" - input_params = { + input_params: Dict[str, Any] = { "llmProvider": llm_provider, "model": model, "promptName": prompt_name, diff --git a/src/conductor/asyncio_client/workflow/task/switch_task.py b/src/conductor/asyncio_client/workflow/task/switch_task.py index 6cef4434..b64d621f 100644 --- a/src/conductor/asyncio_client/workflow/task/switch_task.py +++ b/src/conductor/asyncio_client/workflow/task/switch_task.py @@ -1,5 +1,7 @@ +from __future__ import annotations + from copy import deepcopy -from typing import List +from typing import Dict, List, Optional from conductor.asyncio_client.adapters.models.workflow_task_adapter import WorkflowTaskAdapter from conductor.asyncio_client.workflow.task.task import ( @@ -15,8 +17,8 @@ def __init__(self, task_ref_name: str, case_expression: str, use_javascript: boo task_reference_name=task_ref_name, task_type=TaskType.SWITCH, ) - self._default_case = None - self._decision_cases = {} + self._default_case: Optional[List[TaskInterface]] = None + self._decision_cases: Dict[str, List[TaskInterface]] = {} self._expression = deepcopy(case_expression) self._use_javascript = deepcopy(use_javascript) diff --git a/src/conductor/asyncio_client/workflow/task/task.py b/src/conductor/asyncio_client/workflow/task/task.py index 16d31936..163a5b38 100644 --- a/src/conductor/asyncio_client/workflow/task/task.py +++ b/src/conductor/asyncio_client/workflow/task/task.py @@ -31,16 +31,16 @@ def __init__( cache_key: Optional[str] = None, cache_ttl_second: int = 0, ): - self.task_reference_name = task_reference_name - self.task_type = task_type - self.name = task_name or task_reference_name - self.description = description - self.optional = optional - self.input_parameters = input_parameters - self._cache_key = cache_key - self._cache_ttl_second = cache_ttl_second - self._expression = None - self._evaluator_type = None + self.task_reference_name: str = task_reference_name + self.task_type: TaskType = task_type + self.name: str = task_name or task_reference_name + self.description: Optional[str] = description + self.optional: Optional[bool] = optional + self._input_parameters: Dict[str, Any] = input_parameters or {} + self._cache_key: Optional[str] = cache_key + self._cache_ttl_second: int = cache_ttl_second + self._expression: Optional[str] = None + self._evaluator_type: Optional[str] = None @property def task_reference_name(self) -> str: @@ -73,7 +73,7 @@ def name(self, name: str) -> None: self._name = name @property - def expression(self) -> str: + def expression(self) -> Optional[str]: return self._expression @expression.setter @@ -81,7 +81,7 @@ def expression(self, expression: str) -> None: self._expression = expression @property - def evaluator_type(self) -> str: + def evaluator_type(self) -> Optional[str]: return self._evaluator_type @evaluator_type.setter @@ -93,7 +93,7 @@ def cache(self, cache_key: str, cache_ttl_second: int): self._cache_ttl_second = cache_ttl_second @property - def description(self) -> str: + def description(self) -> Optional[str]: return self._description @description.setter @@ -103,7 +103,7 @@ def description(self, description: str) -> None: self._description = deepcopy(description) @property - def optional(self) -> bool: + def optional(self) -> Optional[bool]: return self._optional @optional.setter @@ -127,7 +127,7 @@ def input_parameters(self, input_parameters: Dict[str, Any]) -> None: except AttributeError as err: raise ValueError(f"Invalid type: {type(input_parameters)}") from err - self._input_parameters = deepcopy(input_parameters) + self._input_parameters: Dict[str, Any] = deepcopy(input_parameters) def input_parameter(self, key: str, value: Any): if not isinstance(key, str): diff --git a/src/conductor/client/adapters/api/application_resource_api_adapter.py b/src/conductor/client/adapters/api/application_resource_api_adapter.py index f6840e26..4e92b1bb 100644 --- a/src/conductor/client/adapters/api/application_resource_api_adapter.py +++ b/src/conductor/client/adapters/api/application_resource_api_adapter.py @@ -1,14 +1,18 @@ +from typing import List + from conductor.client.codegen.api.application_resource_api import ApplicationResourceApi +from conductor.client.http.models.extended_conductor_application import ExtendedConductorApplication +from conductor.client.orkes.models.metadata_tag import MetadataTag class ApplicationResourceApiAdapter(ApplicationResourceApi): - def create_access_key(self, id, **kwargs): + def create_access_key(self, id: str, **kwargs): # Convert empty application id to None to prevent sending invalid data to server if not id: id = None return super().create_access_key(id, **kwargs) - def add_role_to_application_user(self, application_id, role, **kwargs): + def add_role_to_application_user(self, application_id: str, role: str, **kwargs): # Convert empty application_id and role to None to prevent sending invalid data to server if not application_id: application_id = None @@ -16,7 +20,7 @@ def add_role_to_application_user(self, application_id, role, **kwargs): role = None return super().add_role_to_application_user(application_id, role, **kwargs) - def delete_access_key(self, application_id, key_id, **kwargs): + def delete_access_key(self, application_id: str, key_id: str, **kwargs): # Convert empty application_id and key_id to None to prevent sending invalid data to server if not application_id: application_id = None @@ -24,7 +28,7 @@ def delete_access_key(self, application_id, key_id, **kwargs): key_id = None return super().delete_access_key(application_id, key_id, **kwargs) - def remove_role_from_application_user(self, application_id, role, **kwargs): + def remove_role_from_application_user(self, application_id: str, role: str, **kwargs): # Convert empty application_id and role to None to prevent sending invalid data to server if not application_id: application_id = None @@ -32,7 +36,9 @@ def remove_role_from_application_user(self, application_id, role, **kwargs): role = None return super().remove_role_from_application_user(application_id, role, **kwargs) - def get_app_by_access_key_id(self, access_key_id: str, **kwargs): + def get_app_by_access_key_id( + self, access_key_id: str, **kwargs + ) -> ExtendedConductorApplication: # Convert empty access_key_id to None to prevent sending invalid data to server if not access_key_id: access_key_id = None @@ -44,7 +50,7 @@ def get_access_keys(self, id: str, **kwargs): id = None return super().get_access_keys(id=id, **kwargs) - def toggle_access_key_status(self, application_id, key_id, **kwargs): + def toggle_access_key_status(self, application_id: str, key_id: str, **kwargs): # Convert empty application_id and key_id to None to prevent sending invalid data to server if not application_id: application_id = None @@ -52,16 +58,16 @@ def toggle_access_key_status(self, application_id, key_id, **kwargs): key_id = None return super().toggle_access_key_status(application_id, key_id, **kwargs) - def get_tags_for_application(self, application_id, **kwargs): + def get_tags_for_application(self, application_id: str, **kwargs) -> List[MetadataTag]: # Convert empty application_id to None to prevent sending invalid data to server if not application_id: application_id = None return super().get_tags_for_application(application_id, **kwargs) - def delete_tag_for_application(self, body, id, **kwargs): - # Convert empty tag list (body) and application id to None to prevent sending invalid data to server - if not body: - body = None + def delete_tag_for_application(self, tag: List[MetadataTag], id: str, **kwargs) -> None: + # Convert empty application id and tag list to None to prevent sending invalid data to server if not id: id = None - return super().delete_tag_for_application(body, id, **kwargs) + if not tag: + tag = None + return super().delete_tag_for_application(tag, id, **kwargs) diff --git a/src/conductor/client/adapters/api_client_adapter.py b/src/conductor/client/adapters/api_client_adapter.py index 7ace9140..3bb1a6a1 100644 --- a/src/conductor/client/adapters/api_client_adapter.py +++ b/src/conductor/client/adapters/api_client_adapter.py @@ -1,12 +1,11 @@ import logging import time +from conductor.client.adapters.rest_adapter import RESTClientObjectAdapter from conductor.client.codegen.api_client import ApiClient +from conductor.client.codegen.rest import ApiException, AuthorizationException from conductor.client.configuration.configuration import Configuration -from conductor.client.adapters.rest_adapter import RESTClientObjectAdapter -from conductor.client.exceptions.auth_401_policy import Auth401Policy, Auth401Handler - -from conductor.client.codegen.rest import AuthorizationException, ApiException +from conductor.client.exceptions.auth_401_policy import Auth401Handler, Auth401Policy logger = logging.getLogger(Configuration.get_logging_formatted_name(__name__)) diff --git a/src/conductor/client/adapters/models/bulk_response_adapter.py b/src/conductor/client/adapters/models/bulk_response_adapter.py index 64f3c8d6..7e40d3f3 100644 --- a/src/conductor/client/adapters/models/bulk_response_adapter.py +++ b/src/conductor/client/adapters/models/bulk_response_adapter.py @@ -1,17 +1,17 @@ from typing import ClassVar, Dict + from conductor.client.codegen.models import BulkResponse class BulkResponseAdapter(BulkResponse): swagger_types: ClassVar[Dict[str, str]] = { - "bulk_error_results": "dict(str, str)", + **BulkResponse.swagger_types, "bulk_successful_results": "list[str]", "message": "str", } attribute_map: ClassVar[Dict[str, str]] = { - "bulk_error_results": "bulkErrorResults", - "bulk_successful_results": "bulkSuccessfulResults", + **BulkResponse.attribute_map, "message": "message", } diff --git a/src/conductor/client/adapters/models/health.py b/src/conductor/client/adapters/models/health.py index a4220b7c..233c5e48 100644 --- a/src/conductor/client/adapters/models/health.py +++ b/src/conductor/client/adapters/models/health.py @@ -1,6 +1,6 @@ -from typing import ClassVar, Dict import pprint import re # noqa: F401 +from typing import ClassVar, Dict import six diff --git a/src/conductor/client/adapters/models/health_check_status.py b/src/conductor/client/adapters/models/health_check_status.py index 225a2b71..d3a8e374 100644 --- a/src/conductor/client/adapters/models/health_check_status.py +++ b/src/conductor/client/adapters/models/health_check_status.py @@ -1,5 +1,5 @@ -from typing import ClassVar, Dict import pprint +from typing import ClassVar, Dict import six diff --git a/src/conductor/client/adapters/models/integration_adapter.py b/src/conductor/client/adapters/models/integration_adapter.py index 54437f6a..d3eee9f8 100644 --- a/src/conductor/client/adapters/models/integration_adapter.py +++ b/src/conductor/client/adapters/models/integration_adapter.py @@ -7,41 +7,15 @@ class IntegrationAdapter(Integration): swagger_types: ClassVar[Dict[str, str]] = { - "apis": "list[IntegrationApi]", - "category": "str", - "configuration": "dict(str, object)", - "create_time": "int", + **Integration.swagger_types, "created_on": "int", - "created_by": "str", - "description": "str", - "enabled": "bool", - "models_count": "int", - "name": "str", - "owner_app": "str", - "tags": "list[Tag]", - "type": "str", - "update_time": "int", "updated_on": "int", - "updated_by": "str", } attribute_map: ClassVar[Dict[str, str]] = { - "apis": "apis", - "category": "category", - "configuration": "configuration", - "create_time": "createTime", + **Integration.attribute_map, "created_on": "createdOn", - "created_by": "createdBy", - "description": "description", - "enabled": "enabled", - "models_count": "modelsCount", - "name": "name", - "owner_app": "ownerApp", - "tags": "tags", - "type": "type", - "update_time": "updateTime", "updated_on": "updatedOn", - "updated_by": "updatedBy", } def __init__( diff --git a/src/conductor/client/adapters/models/integration_api_adapter.py b/src/conductor/client/adapters/models/integration_api_adapter.py index 79cbacd4..534b7920 100644 --- a/src/conductor/client/adapters/models/integration_api_adapter.py +++ b/src/conductor/client/adapters/models/integration_api_adapter.py @@ -7,35 +7,15 @@ class IntegrationApiAdapter(IntegrationApi): swagger_types: ClassVar[Dict[str, str]] = { - "api": "str", - "configuration": "dict(str, object)", - "create_time": "int", + **IntegrationApi.swagger_types, "created_on": "int", - "created_by": "str", - "description": "str", - "enabled": "bool", - "integration_name": "str", - "owner_app": "str", - "tags": "list[Tag]", - "update_time": "int", "updated_on": "int", - "updated_by": "str", } attribute_map: ClassVar[Dict[str, str]] = { - "api": "api", - "configuration": "configuration", - "create_time": "createTime", + **IntegrationApi.attribute_map, "created_on": "createdOn", - "created_by": "createdBy", - "description": "description", - "enabled": "enabled", - "integration_name": "integrationName", - "owner_app": "ownerApp", - "tags": "tags", - "update_time": "updateTime", "updated_on": "updatedOn", - "updated_by": "updatedBy", } def __init__( diff --git a/src/conductor/client/adapters/models/integration_def_adapter.py b/src/conductor/client/adapters/models/integration_def_adapter.py index 4cfecc8a..7fbce214 100644 --- a/src/conductor/client/adapters/models/integration_def_adapter.py +++ b/src/conductor/client/adapters/models/integration_def_adapter.py @@ -7,28 +7,12 @@ class IntegrationDefAdapter(IntegrationDef): swagger_types: ClassVar[Dict[str, str]] = { - "category": "str", - "category_label": "str", - "configuration": "list[IntegrationDefFormField]", - "description": "str", - "enabled": "bool", - "icon_name": "str", - "name": "str", - "tags": "list[str]", - "type": "str", + **IntegrationDef.swagger_types, "apis": "list[IntegrationDefApi]", } attribute_map: ClassVar[Dict[str, str]] = { - "category": "category", - "category_label": "categoryLabel", - "configuration": "configuration", - "description": "description", - "enabled": "enabled", - "icon_name": "iconName", - "name": "name", - "tags": "tags", - "type": "type", + **IntegrationDef.attribute_map, "apis": "apis", } diff --git a/src/conductor/client/adapters/models/integration_def_api_adapter.py b/src/conductor/client/adapters/models/integration_def_api_adapter.py index af35b172..f44e190c 100644 --- a/src/conductor/client/adapters/models/integration_def_api_adapter.py +++ b/src/conductor/client/adapters/models/integration_def_api_adapter.py @@ -1,5 +1,5 @@ -from typing import ClassVar, Dict import pprint +from typing import ClassVar, Dict import six diff --git a/src/conductor/client/adapters/models/parser_adapter.py b/src/conductor/client/adapters/models/parser_adapter.py index d23b6f06..5b99f4a5 100644 --- a/src/conductor/client/adapters/models/parser_adapter.py +++ b/src/conductor/client/adapters/models/parser_adapter.py @@ -1,5 +1,4 @@ -from conductor.client.adapters.models.parser_adapter import ParserAdapter +from conductor.client.codegen.models.parser import Parser -Parser = ParserAdapter -__all__ = ["Parser"] +class ParserAdapter(Parser): ... diff --git a/src/conductor/client/adapters/models/prompt_test_request_adapter.py b/src/conductor/client/adapters/models/prompt_test_request_adapter.py index cf89a85a..dbf0a76c 100644 --- a/src/conductor/client/adapters/models/prompt_test_request_adapter.py +++ b/src/conductor/client/adapters/models/prompt_test_request_adapter.py @@ -1,4 +1,4 @@ -from src.conductor.client.adapters.models.prompt_template_adapter import PromptTemplate +from conductor.client.adapters.models.prompt_template_adapter import PromptTemplate class PromptTemplateRequestAdapter(PromptTemplate): diff --git a/src/conductor/client/adapters/models/proto_registry_entry_adapter.py b/src/conductor/client/adapters/models/proto_registry_entry_adapter.py index d7a5c9d9..49cbcdcb 100644 --- a/src/conductor/client/adapters/models/proto_registry_entry_adapter.py +++ b/src/conductor/client/adapters/models/proto_registry_entry_adapter.py @@ -1,4 +1,4 @@ -from src.conductor.client.codegen.models.proto_registry_entry import ProtoRegistryEntry +from conductor.client.codegen.models.proto_registry_entry import ProtoRegistryEntry class ProtoRegistryEntryAdapter(ProtoRegistryEntry): diff --git a/src/conductor/client/adapters/models/state_change_event_adapter.py b/src/conductor/client/adapters/models/state_change_event_adapter.py index 2d98df91..a1ec35bc 100644 --- a/src/conductor/client/adapters/models/state_change_event_adapter.py +++ b/src/conductor/client/adapters/models/state_change_event_adapter.py @@ -1,9 +1,7 @@ from __future__ import annotations from enum import Enum -from typing import ClassVar, Dict, List, Union, Optional - -from typing_extensions import Self +from typing import Any, ClassVar, Dict, List, Optional, Union from conductor.client.codegen.models.state_change_event import StateChangeEvent @@ -24,7 +22,7 @@ class StateChangeConfig: # Keep original init for backward compatibility def __init__( self, - event_type: Union[str, StateChangeEventType, List[StateChangeEventType]] = None, + event_type: Optional[Union[StateChangeEventType, List[StateChangeEventType]]] = None, events: Optional[List[StateChangeEvent]] = None, ) -> None: if event_type is None: @@ -40,7 +38,7 @@ def type(self): return self._type @type.setter - def type(self, event_type: StateChangeEventType) -> Self: + def type(self, event_type: StateChangeEventType) -> None: self._type = event_type.name @property @@ -48,12 +46,12 @@ def events(self): return self._events @events.setter - def events(self, events: List[StateChangeEvent]) -> Self: + def events(self, events: List[StateChangeEvent]) -> None: self._events = events def to_dict(self) -> Dict: """Returns the model properties as a dict""" - result = {} + result: Dict[str, Any] = {} for attr in self.swagger_types.keys(): value = getattr(self, attr) if isinstance(value, list): diff --git a/src/conductor/client/adapters/models/task_summary_adapter.py b/src/conductor/client/adapters/models/task_summary_adapter.py index 2719a70c..41a9a48f 100644 --- a/src/conductor/client/adapters/models/task_summary_adapter.py +++ b/src/conductor/client/adapters/models/task_summary_adapter.py @@ -7,50 +7,12 @@ class TaskSummaryAdapter(TaskSummary): swagger_types: ClassVar[Dict[str, str]] = { - "correlation_id": "str", - "end_time": "str", - "execution_time": "int", - "external_input_payload_storage_path": "str", - "external_output_payload_storage_path": "str", - "input": "str", - "output": "str", - "queue_wait_time": "int", - "reason_for_incompletion": "str", - "scheduled_time": "str", - "start_time": "str", - "status": "str", - "task_def_name": "str", - "task_id": "str", - "task_reference_name": "str", - "task_type": "str", - "update_time": "str", - "workflow_id": "str", - "workflow_priority": "int", - "workflow_type": "str", + **TaskSummary.swagger_types, "domain": "str", } attribute_map: ClassVar[Dict[str, str]] = { - "correlation_id": "correlationId", - "end_time": "endTime", - "execution_time": "executionTime", - "external_input_payload_storage_path": "externalInputPayloadStoragePath", - "external_output_payload_storage_path": "externalOutputPayloadStoragePath", - "input": "input", - "output": "output", - "queue_wait_time": "queueWaitTime", - "reason_for_incompletion": "reasonForIncompletion", - "scheduled_time": "scheduledTime", - "start_time": "startTime", - "status": "status", - "task_def_name": "taskDefName", - "task_id": "taskId", - "task_reference_name": "taskReferenceName", - "task_type": "taskType", - "update_time": "updateTime", - "workflow_id": "workflowId", - "workflow_priority": "workflowPriority", - "workflow_type": "workflowType", + **TaskSummary.attribute_map, "domain": "domain", } diff --git a/src/conductor/client/adapters/models/workflow_run_adapter.py b/src/conductor/client/adapters/models/workflow_run_adapter.py index 25465c8f..a2a54d68 100644 --- a/src/conductor/client/adapters/models/workflow_run_adapter.py +++ b/src/conductor/client/adapters/models/workflow_run_adapter.py @@ -71,8 +71,8 @@ def __init__( self.workflow_id = workflow_id @property - def current_task(self) -> TaskAdapter: - current = None + def current_task(self) -> Optional[TaskAdapter]: + current: Optional[TaskAdapter] = None for task in self.tasks: if task.status in ("SCHEDULED", "IN_PROGRESS"): current = task @@ -80,7 +80,7 @@ def current_task(self) -> TaskAdapter: def get_task( self, name: Optional[str] = None, task_reference_name: Optional[str] = None - ) -> TaskAdapter: + ) -> Optional[TaskAdapter]: if name is None and task_reference_name is None: raise Exception( "ONLY one of name or task_reference_name MUST be provided. None were provided" @@ -90,7 +90,7 @@ def get_task( "ONLY one of name or task_reference_name MUST be provided. both were provided" ) - current = None + current: Optional[TaskAdapter] = None for task in self.tasks: if ( task.task_def_name == name diff --git a/src/conductor/client/adapters/rest_adapter.py b/src/conductor/client/adapters/rest_adapter.py index f5e5ea45..a5e430a7 100644 --- a/src/conductor/client/adapters/rest_adapter.py +++ b/src/conductor/client/adapters/rest_adapter.py @@ -1,8 +1,9 @@ from __future__ import annotations + import io import logging import ssl -from typing import Any, Dict, Optional, Tuple, Union +from typing import Any, Dict, Optional, Union import httpx from httpx import HTTPStatusError, RequestError, Response, TimeoutException @@ -132,7 +133,7 @@ def request( body: Optional[Union[str, bytes, Dict[str, Any]]] = None, post_params: Optional[Dict[str, Any]] = None, _preload_content: bool = True, - _request_timeout: Optional[Union[float, Tuple[float, float]]] = None, + _request_timeout: Optional[float] = None, ) -> RESTResponse: """Perform HTTP request using httpx. @@ -233,7 +234,7 @@ def GET( headers: Optional[Dict[str, str]] = None, query_params: Optional[Dict[str, Any]] = None, _preload_content: bool = True, - _request_timeout: Optional[Union[float, Tuple[float, float]]] = None, + _request_timeout: Optional[float] = None, ) -> RESTResponse: """Perform GET request.""" return self.request( @@ -251,7 +252,7 @@ def HEAD( headers: Optional[Dict[str, str]] = None, query_params: Optional[Dict[str, Any]] = None, _preload_content: bool = True, - _request_timeout: Optional[Union[float, Tuple[float, float]]] = None, + _request_timeout: Optional[float] = None, ) -> RESTResponse: """Perform HEAD request.""" return self.request( @@ -271,7 +272,7 @@ def OPTIONS( post_params: Optional[Dict[str, Any]] = None, body: Optional[Union[str, bytes, Dict[str, Any]]] = None, _preload_content: bool = True, - _request_timeout: Optional[Union[float, Tuple[float, float]]] = None, + _request_timeout: Optional[float] = None, ) -> RESTResponse: """Perform OPTIONS request.""" return self.request( @@ -292,7 +293,7 @@ def DELETE( query_params: Optional[Dict[str, Any]] = None, body: Optional[Union[str, bytes, Dict[str, Any]]] = None, _preload_content: bool = True, - _request_timeout: Optional[Union[float, Tuple[float, float]]] = None, + _request_timeout: Optional[float] = None, ) -> RESTResponse: """Perform DELETE request.""" return self.request( @@ -313,7 +314,7 @@ def POST( post_params: Optional[Dict[str, Any]] = None, body: Optional[Union[str, bytes, Dict[str, Any]]] = None, _preload_content: bool = True, - _request_timeout: Optional[Union[float, Tuple[float, float]]] = None, + _request_timeout: Optional[float] = None, ) -> RESTResponse: """Perform POST request.""" return self.request( @@ -335,7 +336,7 @@ def PUT( post_params: Optional[Dict[str, Any]] = None, body: Optional[Union[str, bytes, Dict[str, Any]]] = None, _preload_content: bool = True, - _request_timeout: Optional[Union[float, Tuple[float, float]]] = None, + _request_timeout: Optional[float] = None, ) -> RESTResponse: """Perform PUT request.""" return self.request( @@ -357,7 +358,7 @@ def PATCH( post_params: Optional[Dict[str, Any]] = None, body: Optional[Union[str, bytes, Dict[str, Any]]] = None, _preload_content: bool = True, - _request_timeout: Optional[Union[float, Tuple[float, float]]] = None, + _request_timeout: Optional[float] = None, ) -> RESTResponse: """Perform PATCH request.""" return self.request( diff --git a/src/conductor/client/ai/orchestrator.py b/src/conductor/client/ai/orchestrator.py index dcb1bdd0..eaccb635 100644 --- a/src/conductor/client/ai/orchestrator.py +++ b/src/conductor/client/ai/orchestrator.py @@ -1,20 +1,17 @@ from __future__ import annotations -from typing import Optional, List, TYPE_CHECKING +from typing import TYPE_CHECKING, List, Optional from uuid import uuid4 -from typing_extensions import Self - -from conductor.client.http.models import IntegrationApiUpdate, IntegrationUpdate from conductor.client.codegen.rest import ApiException +from conductor.client.http.models import IntegrationApiUpdate, IntegrationUpdate from conductor.client.orkes_clients import OrkesClients if TYPE_CHECKING: - from conductor.client.http.models import PromptTemplate from conductor.client.configuration.configuration import Configuration + from conductor.client.http.models import PromptTemplate from conductor.shared.ai.configuration.interfaces.integration_config import IntegrationConfig - from conductor.shared.ai.enums import VectorDB - from conductor.shared.ai.enums import LLMProvider + from conductor.shared.ai.enums import LLMProvider, VectorDB NOT_FOUND_STATUS = 404 @@ -22,7 +19,7 @@ class AIOrchestrator: def __init__( self, api_configuration: Configuration, prompt_test_workflow_name: str = "" - ) -> Self: + ) -> None: orkes_clients = OrkesClients(api_configuration) self.integration_client = orkes_clients.get_integration_client() @@ -38,7 +35,7 @@ def add_prompt_template(self, name: str, prompt_template: str, description: str) self.prompt_client.save_prompt(name, description, prompt_template) return self - def get_prompt_template(self, template_name: str) -> PromptTemplate: + def get_prompt_template(self, template_name: str) -> Optional[PromptTemplate]: try: return self.prompt_client.get_prompt(template_name) except ApiException as e: diff --git a/src/conductor/client/authorization_client.py b/src/conductor/client/authorization_client.py index 1991543e..9fc2f3b3 100644 --- a/src/conductor/client/authorization_client.py +++ b/src/conductor/client/authorization_client.py @@ -1,21 +1,23 @@ from __future__ import annotations + from abc import ABC, abstractmethod from typing import Dict, List, Optional -from conductor.client.orkes.models.metadata_tag import MetadataTag -from conductor.client.orkes.models.access_type import AccessType -from conductor.client.orkes.models.granted_permission import GrantedPermission -from conductor.client.orkes.models.access_key import AccessKey -from conductor.client.orkes.models.created_access_key import CreatedAccessKey -from conductor.client.http.models.group import Group -from conductor.client.http.models.target_ref import TargetRef -from conductor.client.http.models.subject_ref import SubjectRef -from conductor.client.http.models.conductor_user import ConductorUser + from conductor.client.http.models.conductor_application import ConductorApplication -from conductor.client.http.models.upsert_user_request import UpsertUserRequest -from conductor.client.http.models.upsert_group_request import UpsertGroupRequest +from conductor.client.http.models.conductor_user import ConductorUser from conductor.client.http.models.create_or_update_application_request import ( CreateOrUpdateApplicationRequest, ) +from conductor.client.http.models.group import Group +from conductor.client.http.models.subject_ref import SubjectRef +from conductor.client.http.models.target_ref import TargetRef +from conductor.client.http.models.upsert_group_request import UpsertGroupRequest +from conductor.client.http.models.upsert_user_request import UpsertUserRequest +from conductor.client.orkes.models.access_key import AccessKey +from conductor.client.orkes.models.access_type import AccessType +from conductor.client.orkes.models.created_access_key import CreatedAccessKey +from conductor.client.orkes.models.granted_permission import GrantedPermission +from conductor.client.orkes.models.metadata_tag import MetadataTag class AuthorizationClient(ABC): diff --git a/src/conductor/client/automator/task_handler.py b/src/conductor/client/automator/task_handler.py index 1b33297d..10797494 100644 --- a/src/conductor/client/automator/task_handler.py +++ b/src/conductor/client/automator/task_handler.py @@ -85,8 +85,10 @@ def __init__( logger.info("Created worker with name=%s and domain=%s", task_def_name, domain) workers.append(worker) - self.__create_task_runner_processes(workers, configuration, metrics_settings) - self.__create_metrics_provider_process(metrics_settings) + self.__create_task_runner_processes( + workers, configuration or Configuration(), metrics_settings or MetricsSettings() + ) + self.__create_metrics_provider_process(metrics_settings or MetricsSettings()) logger.info("TaskHandler initialized") def __enter__(self): @@ -118,9 +120,11 @@ def join_processes(self) -> None: logger.info("KeyboardInterrupt: Stopping all processes") self.stop_processes() - def __create_metrics_provider_process(self, metrics_settings: MetricsSettings) -> None: + def __create_metrics_provider_process( + self, metrics_settings: Optional[MetricsSettings] = None + ) -> None: if metrics_settings is None: - self.metrics_provider_process = None + self.metrics_provider_process: Optional[Process] = None return self.metrics_provider_process = Process( target=MetricsCollector.provide_metrics, args=(metrics_settings,) @@ -133,7 +137,7 @@ def __create_task_runner_processes( configuration: Configuration, metrics_settings: MetricsSettings, ) -> None: - self.task_runner_processes = [] + self.task_runner_processes: List[Process] = [] for worker in workers: self.__create_task_runner_process(worker, configuration, metrics_settings) @@ -200,8 +204,8 @@ def __stop_process(self, process: Process): # Setup centralized logging queue -def _setup_logging_queue(configuration: Configuration): - queue = Queue() +def _setup_logging_queue(configuration: Optional[Configuration]): + queue: Queue = Queue() if configuration: configuration.apply_logging_config() log_level = configuration.log_level diff --git a/src/conductor/client/automator/task_runner.py b/src/conductor/client/automator/task_runner.py index 49174584..9bc7d97b 100644 --- a/src/conductor/client/automator/task_runner.py +++ b/src/conductor/client/automator/task_runner.py @@ -1,10 +1,13 @@ +from __future__ import annotations + import logging import os import sys import time import traceback +from typing import Optional -from conductor.client.codegen.rest import AuthorizationException, ApiException +from conductor.client.codegen.rest import ApiException, AuthorizationException from conductor.client.configuration.configuration import Configuration from conductor.client.http.api.task_resource_api import TaskResourceApi from conductor.client.http.api_client import ApiClient @@ -22,8 +25,8 @@ class TaskRunner: def __init__( self, worker: WorkerInterface, - configuration: Configuration = None, - metrics_settings: MetricsSettings = None, + configuration: Optional[Configuration] = None, + metrics_settings: Optional[MetricsSettings] = None, ): if not isinstance(worker, WorkerInterface): raise Exception("Invalid worker") @@ -74,7 +77,7 @@ def run_once(self) -> None: except Exception: pass - def __poll_task(self) -> Task: + def __poll_task(self) -> Optional[Task]: task_definition_name = self.worker.get_task_definition_name() if self.worker.paused(): logger.debug("Stop polling task for: %s", task_definition_name) @@ -96,7 +99,7 @@ def __poll_task(self) -> Task: except AuthorizationException as auth_exception: if self.metrics_collector is not None: self.metrics_collector.increment_task_poll_error( - task_definition_name, type(auth_exception) + task_definition_name, auth_exception ) if auth_exception.invalid_token: logger.error( @@ -113,7 +116,7 @@ def __poll_task(self) -> Task: return None except ApiException as e: if self.metrics_collector is not None: - self.metrics_collector.increment_task_poll_error(task_definition_name, type(e)) + self.metrics_collector.increment_task_poll_error(task_definition_name, e) logger.error( "Failed to poll task: %s, reason: %s, code: %s", task_definition_name, @@ -123,7 +126,7 @@ def __poll_task(self) -> Task: return None except Exception as e: if self.metrics_collector is not None: - self.metrics_collector.increment_task_poll_error(task_definition_name, type(e)) + self.metrics_collector.increment_task_poll_error(task_definition_name, e) logger.error("Failed to poll task: %s; reason: %s", task_definition_name, e) return None @@ -164,7 +167,7 @@ def __execute_task(self, task: Task) -> TaskResult: ) except Exception as e: if self.metrics_collector is not None: - self.metrics_collector.increment_task_execution_error(task_definition_name, type(e)) + self.metrics_collector.increment_task_execution_error(task_definition_name, e) task_result = TaskResult( task_id=task.task_id, workflow_instance_id=task.workflow_instance_id, @@ -210,9 +213,7 @@ def __update_task(self, task_result: TaskResult): return response except Exception as e: if self.metrics_collector is not None: - self.metrics_collector.increment_task_update_error( - task_definition_name, type(e) - ) + self.metrics_collector.increment_task_update_error(task_definition_name, e) logger.error( "Failed to update task id: %s; workflow_instance_id: %s; task_definition_name: %s; reason: %s", task_result.task_id, diff --git a/src/conductor/client/configuration/configuration.py b/src/conductor/client/configuration/configuration.py index c4b09a23..57a8b254 100644 --- a/src/conductor/client/configuration/configuration.py +++ b/src/conductor/client/configuration/configuration.py @@ -1,13 +1,12 @@ from __future__ import annotations import json - import logging import os import re import time +from typing import Dict, Optional, Union import warnings -from typing import Optional, Dict, Union from conductor.shared.configuration.settings.authentication_settings import ( AuthenticationSettings, @@ -74,7 +73,7 @@ def __init__( self, base_url: Optional[str] = None, debug: bool = False, - authentication_settings: AuthenticationSettings = None, + authentication_settings: Optional[AuthenticationSettings] = None, server_api_url: Optional[str] = None, auth_token_ttl_min: int = 45, proxy: Optional[str] = None, @@ -113,6 +112,8 @@ def __init__( CONDUCTOR_PROXY: Proxy URL for HTTP requests CONDUCTOR_PROXY_HEADERS: Proxy headers as JSON string or single header value """ + self.host: Optional[str] = None + if server_api_url is not None: self.host = server_api_url elif base_url is not None: @@ -175,10 +176,10 @@ def __init__( self.proxy_headers = proxy_headers if not self.proxy_headers and os.getenv("CONDUCTOR_PROXY_HEADERS"): try: - self.proxy_headers = json.loads(os.getenv("CONDUCTOR_PROXY_HEADERS")) + self.proxy_headers = json.loads(os.getenv("CONDUCTOR_PROXY_HEADERS") or "{}") except (json.JSONDecodeError, TypeError): # If JSON parsing fails, treat as a single header value - self.proxy_headers = {"Authorization": os.getenv("CONDUCTOR_PROXY_HEADERS")} + self.proxy_headers = {"Authorization": os.getenv("CONDUCTOR_PROXY_HEADERS") or ""} # Safe chars for path_param self.safe_chars_for_path_param = "" diff --git a/src/conductor/client/event/event_client.py b/src/conductor/client/event/event_client.py index 0213b0c8..5d345297 100644 --- a/src/conductor/client/event/event_client.py +++ b/src/conductor/client/event/event_client.py @@ -24,7 +24,7 @@ def get_kafka_queue_configuration(self, queue_topic: str) -> QueueConfiguration: queue_name=queue_topic, ) - def get_queue_configuration(self, queue_type: str, queue_name: str): + def get_queue_configuration(self, queue_type: str, queue_name: str) -> QueueConfiguration: return self.client.get_queue_config(queue_type, queue_name) def put_queue_configuration(self, queue_configuration: QueueConfiguration): diff --git a/src/conductor/client/event/queue/queue_configuration.py b/src/conductor/client/event/queue/queue_configuration.py index a92407ca..f1ee6147 100644 --- a/src/conductor/client/event/queue/queue_configuration.py +++ b/src/conductor/client/event/queue/queue_configuration.py @@ -9,9 +9,9 @@ class QueueConfiguration(ABC): WORKER_PRODUCER_KEY: ClassVar[str] = "producer" def __init__(self, queue_name: str, queue_type: str): - self.queue_name = queue_name - self.queue_type = queue_type - self.worker_configuration = {} + self.queue_name: str = queue_name + self.queue_type: str = queue_type + self.worker_configuration: Dict[str, QueueWorkerConfiguration] = {} def add_consumer(self, worker_configuration: QueueWorkerConfiguration) -> None: self.worker_configuration[self.WORKER_CONSUMER_KEY] = worker_configuration diff --git a/src/conductor/client/exceptions/api_exception_handler.py b/src/conductor/client/exceptions/api_exception_handler.py index 0675cede..b30dc278 100644 --- a/src/conductor/client/exceptions/api_exception_handler.py +++ b/src/conductor/client/exceptions/api_exception_handler.py @@ -1,7 +1,7 @@ import json -from conductor.client.exceptions.api_error import APIError, APIErrorCode from conductor.client.codegen.rest import ApiException +from conductor.client.exceptions.api_error import APIError, APIErrorCode BAD_REQUEST_STATUS = 400 FORBIDDEN_STATUS = 403 diff --git a/src/conductor/client/exceptions/auth_401_policy.py b/src/conductor/client/exceptions/auth_401_policy.py index 8c595ef1..980848f0 100644 --- a/src/conductor/client/exceptions/auth_401_policy.py +++ b/src/conductor/client/exceptions/auth_401_policy.py @@ -1,8 +1,9 @@ from __future__ import annotations + import logging import random import time -from typing import Optional +from typing import Dict, Optional logger = logging.getLogger(__name__) @@ -28,8 +29,8 @@ def __init__( self.stop_behavior = stop_behavior # Track attempts per endpoint to allow reset on success - self._attempt_counts = {} - self._last_success_time = {} + self._attempt_counts: Dict[str, int] = {} + self._last_success_time: Dict[str, float] = {} def is_401_unauthorized(self, status_code: int) -> bool: """Check if the status code is specifically 401 (not 403 or other auth errors).""" diff --git a/src/conductor/client/helpers/helper.py b/src/conductor/client/helpers/helper.py index e227fc8c..f7ed1a70 100644 --- a/src/conductor/client/helpers/helper.py +++ b/src/conductor/client/helpers/helper.py @@ -1,14 +1,14 @@ import datetime import logging import re -from dateutil.parser import parse from typing import ClassVar, Dict, Tuple import six +from dateutil.parser import parse from requests.structures import CaseInsensitiveDict -from conductor.client.configuration.configuration import Configuration from conductor.client.codegen import rest +from conductor.client.configuration.configuration import Configuration logger = logging.getLogger(Configuration.get_logging_formatted_name(__name__)) diff --git a/src/conductor/client/integration_client.py b/src/conductor/client/integration_client.py index bfa2f622..7995e6c2 100644 --- a/src/conductor/client/integration_client.py +++ b/src/conductor/client/integration_client.py @@ -1,6 +1,7 @@ -from __future__ import absolute_import +from __future__ import annotations + from abc import ABC, abstractmethod -from typing import List +from typing import List, Optional from conductor.client.http.models.integration import Integration from conductor.client.http.models.integration_api import IntegrationApi @@ -49,13 +50,15 @@ def delete_integration(self, integration_name: str): """Delete an integration""" @abstractmethod - def get_integration_api(self, api_name: str, integration_name: str) -> IntegrationApi: ... + def get_integration_api( + self, api_name: str, integration_name: str + ) -> Optional[IntegrationApi]: ... @abstractmethod def get_integration_apis(self, integration_name: str) -> List[IntegrationApi]: ... @abstractmethod - def get_integration(self, integration_name: str) -> Integration: ... + def get_integration(self, integration_name: str) -> Optional[Integration]: ... @abstractmethod def get_integrations(self) -> List[Integration]: diff --git a/src/conductor/client/metadata_client.py b/src/conductor/client/metadata_client.py index 3c0b44bc..21508acc 100644 --- a/src/conductor/client/metadata_client.py +++ b/src/conductor/client/metadata_client.py @@ -1,8 +1,10 @@ from __future__ import annotations + from abc import ABC, abstractmethod from typing import List, Optional -from conductor.client.http.models.workflow_def import WorkflowDef + from conductor.client.http.models.task_def import TaskDef +from conductor.client.http.models.workflow_def import WorkflowDef from conductor.client.orkes.models.metadata_tag import MetadataTag diff --git a/src/conductor/client/orkes/models/access_key.py b/src/conductor/client/orkes/models/access_key.py index 137b8101..318bde76 100644 --- a/src/conductor/client/orkes/models/access_key.py +++ b/src/conductor/client/orkes/models/access_key.py @@ -1,19 +1,21 @@ -from typing_extensions import Self +from __future__ import annotations + +from typing import Optional from conductor.client.orkes.models.access_key_status import AccessKeyStatus class AccessKey: - def __init__(self, id: str, status: AccessKeyStatus, created_at: int) -> Self: - self._id = id - self._status = status - self._created_at = created_at + def __init__(self, id: str, status: AccessKeyStatus, created_at: int) -> None: + self._id: str = id + self._status: Optional[AccessKeyStatus] = status + self._created_at: int = created_at if self._status is None: self._status = AccessKeyStatus.ACTIVE @property - def id(self): + def id(self) -> str: """Gets the id of this CreatedAccessKey. # noqa: E501 :return: The id of this CreatedAccessKey. # noqa: E501 @@ -22,7 +24,7 @@ def id(self): return self._id @id.setter - def id(self, id): + def id(self, id: str) -> None: """Sets the id of this CreatedAccessKey. :param id: The id of this CreatedAccessKey. # noqa: E501 @@ -31,7 +33,7 @@ def id(self, id): self._id = id @property - def status(self): + def status(self) -> Optional[AccessKeyStatus]: """Gets the status of this CreatedAccessKey. # noqa: E501 :return: The status of this CreatedAccessKey. # noqa: E501 @@ -40,7 +42,7 @@ def status(self): return self._status @status.setter - def status(self, status): + def status(self, status: AccessKeyStatus) -> None: """Sets the status of this CreatedAccessKey. :param id: The status of this CreatedAccessKey. # noqa: E501 @@ -49,7 +51,7 @@ def status(self, status): self._status = status @property - def created_at(self): + def created_at(self) -> int: """Gets the created_at of this CreatedAccessKey. # noqa: E501 :return: The created_at of this CreatedAccessKey. # noqa: E501 @@ -57,13 +59,13 @@ def created_at(self): """ return self._created_at - def __eq__(self, other): + def __eq__(self, other: object) -> bool: """Returns true if both objects are equal""" if not isinstance(other, AccessKey): return False return self.id == other.id and self.status == other.status - def __ne__(self, other): + def __ne__(self, other: object) -> bool: """Returns true if both objects are not equal""" return not self == other diff --git a/src/conductor/client/orkes/models/created_access_key.py b/src/conductor/client/orkes/models/created_access_key.py index c9b5e554..3eb020dc 100644 --- a/src/conductor/client/orkes/models/created_access_key.py +++ b/src/conductor/client/orkes/models/created_access_key.py @@ -1,13 +1,10 @@ -from typing_extensions import Self - - class CreatedAccessKey: - def __init__(self, id: str, secret: str) -> Self: - self._id = id - self._secret = secret + def __init__(self, id: str, secret: str) -> None: + self._id: str = id + self._secret: str = secret @property - def id(self): + def id(self) -> str: """Gets the id of this CreatedAccessKey. # noqa: E501 :return: The id of this CreatedAccessKey. # noqa: E501 @@ -16,7 +13,7 @@ def id(self): return self._id @id.setter - def id(self, id): + def id(self, id: str) -> None: """Sets the id of this CreatedAccessKey. :param id: The id of this CreatedAccessKey. # noqa: E501 @@ -25,7 +22,7 @@ def id(self, id): self._id = id @property - def secret(self): + def secret(self) -> str: """Gets the secret of this CreatedAccessKey. # noqa: E501 :return: The secret of this CreatedAccessKey. # noqa: E501 @@ -34,7 +31,7 @@ def secret(self): return self._secret @secret.setter - def secret(self, secret): + def secret(self, secret: str) -> None: """Sets the secret of this CreatedAccessKey. :param id: The secret of this CreatedAccessKey. # noqa: E501 @@ -42,13 +39,13 @@ def secret(self, secret): """ self._secret = secret - def __eq__(self, other): + def __eq__(self, other: object) -> bool: """Returns true if both objects are equal""" if not isinstance(other, CreatedAccessKey): return False return self.id == other.id and self.secret == other.secret - def __ne__(self, other): + def __ne__(self, other: object) -> bool: """Returns true if both objects are not equal""" return not self == other diff --git a/src/conductor/client/orkes/models/granted_permission.py b/src/conductor/client/orkes/models/granted_permission.py index 92f6b3f4..18b325dc 100644 --- a/src/conductor/client/orkes/models/granted_permission.py +++ b/src/conductor/client/orkes/models/granted_permission.py @@ -1,12 +1,10 @@ from typing import List -from typing_extensions import Self - from conductor.client.http.models.target_ref import TargetRef class GrantedPermission: - def __init__(self, target: TargetRef, access: List[str]) -> Self: + def __init__(self, target: TargetRef, access: List[str]) -> None: self._target = target self._access = access diff --git a/src/conductor/client/orkes/models/metadata_tag.py b/src/conductor/client/orkes/models/metadata_tag.py index e3d1aed1..d44eb78f 100644 --- a/src/conductor/client/orkes/models/metadata_tag.py +++ b/src/conductor/client/orkes/models/metadata_tag.py @@ -1,8 +1,6 @@ -from typing_extensions import Self - from conductor.client.http.models.tag_object import TagObject class MetadataTag(TagObject): - def __init__(self, key: str, value: str) -> Self: + def __init__(self, key: str, value: str) -> None: super().__init__(key=key, type="METADATA", value=value) diff --git a/src/conductor/client/orkes/models/ratelimit_tag.py b/src/conductor/client/orkes/models/ratelimit_tag.py index 9c0c5b70..bb7fc7fc 100644 --- a/src/conductor/client/orkes/models/ratelimit_tag.py +++ b/src/conductor/client/orkes/models/ratelimit_tag.py @@ -1,8 +1,6 @@ -from typing_extensions import Self - from conductor.client.http.models.tag_object import TagObject class RateLimitTag(TagObject): - def __init__(self, key: str, value: int) -> Self: + def __init__(self, key: str, value: int) -> None: super().__init__(key=key, type="RATE_LIMIT", value=value) diff --git a/src/conductor/client/orkes/orkes_authorization_client.py b/src/conductor/client/orkes/orkes_authorization_client.py index 1e453c93..2b71f591 100644 --- a/src/conductor/client/orkes/orkes_authorization_client.py +++ b/src/conductor/client/orkes/orkes_authorization_client.py @@ -1,4 +1,5 @@ from __future__ import annotations + from typing import Dict, List, Optional from conductor.client.authorization_client import AuthorizationClient diff --git a/src/conductor/client/orkes/orkes_base_client.py b/src/conductor/client/orkes/orkes_base_client.py index ab18dcf3..08adbc49 100644 --- a/src/conductor/client/orkes/orkes_base_client.py +++ b/src/conductor/client/orkes/orkes_base_client.py @@ -11,11 +11,11 @@ from conductor.client.http.api.schema_resource_api import SchemaResourceApi from conductor.client.http.api.secret_resource_api import SecretResourceApi from conductor.client.http.api.service_registry_resource_api import ServiceRegistryResourceApi +from conductor.client.http.api.tags_api import TagsApi from conductor.client.http.api.task_resource_api import TaskResourceApi from conductor.client.http.api.user_resource_api import UserResourceApi from conductor.client.http.api.workflow_resource_api import WorkflowResourceApi from conductor.client.http.api_client import ApiClient -from conductor.client.http.api.tags_api import TagsApi from conductor.client.http.api.event_resource_api import EventResourceApi diff --git a/src/conductor/client/orkes/orkes_integration_client.py b/src/conductor/client/orkes/orkes_integration_client.py index 540c0b87..7fd82ea6 100644 --- a/src/conductor/client/orkes/orkes_integration_client.py +++ b/src/conductor/client/orkes/orkes_integration_client.py @@ -1,16 +1,15 @@ -from __future__ import annotations -from __future__ import absolute_import +from __future__ import absolute_import, annotations -from typing import List, Optional, Dict +from typing import Dict, List, Optional +from conductor.client.codegen.rest import ApiException from conductor.client.configuration.configuration import Configuration from conductor.client.http.models.integration import Integration from conductor.client.http.models.integration_api import IntegrationApi from conductor.client.http.models.integration_api_update import IntegrationApiUpdate -from conductor.client.http.models.integration_update import IntegrationUpdate from conductor.client.http.models.integration_def import IntegrationDef +from conductor.client.http.models.integration_update import IntegrationUpdate from conductor.client.http.models.prompt_template import PromptTemplate -from conductor.client.codegen.rest import ApiException from conductor.client.integration_client import IntegrationClient from conductor.client.orkes.orkes_base_client import OrkesBaseClient @@ -32,7 +31,7 @@ def delete_integration_api(self, api_name: str, integration_name: str): def delete_integration(self, integration_name: str): self.integrationApi.delete_integration_provider(integration_name) - def get_integration_api(self, api_name: str, integration_name: str) -> IntegrationApi: + def get_integration_api(self, api_name: str, integration_name: str) -> Optional[IntegrationApi]: try: return self.integrationApi.get_integration_api(api_name, integration_name) except ApiException as e: @@ -43,7 +42,7 @@ def get_integration_api(self, api_name: str, integration_name: str) -> Integrati def get_integration_apis(self, integration_name: str) -> List[IntegrationApi]: return self.integrationApi.get_integration_apis(integration_name) - def get_integration(self, integration_name: str) -> Integration: + def get_integration(self, integration_name: str) -> Optional[Integration]: try: return self.integrationApi.get_integration_provider(integration_name) except ApiException as e: @@ -54,7 +53,7 @@ def get_integration(self, integration_name: str) -> Integration: def get_integrations(self) -> List[Integration]: return self.integrationApi.get_integration_providers() - def get_integration_provider(self, name: str) -> IntegrationDef: + def get_integration_provider(self, name: str) -> Optional[IntegrationDef]: """Get integration provider by name""" try: return self.integrationApi.get_integration_provider(name) diff --git a/src/conductor/client/orkes/orkes_metadata_client.py b/src/conductor/client/orkes/orkes_metadata_client.py index 2358a6e0..e206eb9d 100644 --- a/src/conductor/client/orkes/orkes_metadata_client.py +++ b/src/conductor/client/orkes/orkes_metadata_client.py @@ -1,5 +1,6 @@ from __future__ import annotations -from typing import Optional, List + +from typing import List, Optional from conductor.client.configuration.configuration import Configuration from conductor.client.http.models.tag_string import TagString diff --git a/src/conductor/client/orkes/orkes_prompt_client.py b/src/conductor/client/orkes/orkes_prompt_client.py index 342dbe0c..7ad8499a 100644 --- a/src/conductor/client/orkes/orkes_prompt_client.py +++ b/src/conductor/client/orkes/orkes_prompt_client.py @@ -2,10 +2,10 @@ from typing import List, Optional +from conductor.client.codegen.rest import ApiException from conductor.client.configuration.configuration import Configuration from conductor.client.http.models.prompt_template import PromptTemplate from conductor.client.http.models.prompt_template_test_request import PromptTemplateTestRequest -from conductor.client.codegen.rest import ApiException from conductor.client.orkes.models.metadata_tag import MetadataTag from conductor.client.orkes.orkes_base_client import OrkesBaseClient from conductor.client.prompt_client import PromptClient @@ -18,7 +18,7 @@ def __init__(self, configuration: Configuration): def save_prompt(self, prompt_name: str, description: str, prompt_template: str): self.promptApi.save_message_template(prompt_template, description, prompt_name) - def get_prompt(self, prompt_name: str) -> PromptTemplate: + def get_prompt(self, prompt_name: str) -> Optional[PromptTemplate]: try: return self.promptApi.get_message_template(prompt_name) except ApiException as e: diff --git a/src/conductor/client/orkes/orkes_scheduler_client.py b/src/conductor/client/orkes/orkes_scheduler_client.py index 402103be..1178a7d9 100644 --- a/src/conductor/client/orkes/orkes_scheduler_client.py +++ b/src/conductor/client/orkes/orkes_scheduler_client.py @@ -1,5 +1,6 @@ from __future__ import annotations -from typing import Optional, List + +from typing import List, Optional, Tuple from conductor.client.configuration.configuration import Configuration from conductor.client.http.models.save_schedule_request import SaveScheduleRequest @@ -19,7 +20,7 @@ def __init__(self, configuration: Configuration): def save_schedule(self, save_schedule_request: SaveScheduleRequest): self.schedulerResourceApi.save_schedule(save_schedule_request) - def get_schedule(self, name: str) -> WorkflowSchedule: + def get_schedule(self, name: str) -> Tuple[Optional[WorkflowSchedule], str]: return self.schedulerResourceApi.get_schedule(name) def get_all_schedules(self, workflow_name: Optional[str] = None) -> List[WorkflowSchedule]: @@ -91,4 +92,4 @@ def get_scheduler_tags(self, name: str) -> List[MetadataTag]: return self.schedulerResourceApi.get_tags_for_schedule(name) def delete_scheduler_tags(self, tags: List[MetadataTag], name: str) -> List[MetadataTag]: - self.schedulerResourceApi.delete_tag_for_schedule(tags, name) + return self.schedulerResourceApi.delete_tag_for_schedule(tags, name) diff --git a/src/conductor/client/orkes/orkes_secret_client.py b/src/conductor/client/orkes/orkes_secret_client.py index 02aed980..70e3d7a2 100644 --- a/src/conductor/client/orkes/orkes_secret_client.py +++ b/src/conductor/client/orkes/orkes_secret_client.py @@ -35,4 +35,4 @@ def get_secret_tags(self, key: str) -> List[MetadataTag]: return self.secretResourceApi.get_tags(key) def delete_secret_tags(self, tags: List[MetadataTag], key: str) -> List[MetadataTag]: - self.secretResourceApi.delete_tag_for_secret(tags, key) + return self.secretResourceApi.delete_tag_for_secret(tags, key) diff --git a/src/conductor/client/orkes/orkes_service_registry_client.py b/src/conductor/client/orkes/orkes_service_registry_client.py index 48cf1b42..697d1201 100644 --- a/src/conductor/client/orkes/orkes_service_registry_client.py +++ b/src/conductor/client/orkes/orkes_service_registry_client.py @@ -1,13 +1,14 @@ from __future__ import annotations -from typing import Optional, List + +from typing import List, Optional from conductor.client.configuration.configuration import Configuration -from conductor.client.http.models.service_registry import ServiceRegistry -from conductor.client.http.models.service_method import ServiceMethod -from conductor.client.http.models.proto_registry_entry import ProtoRegistryEntry from conductor.client.http.models.circuit_breaker_transition_response import ( CircuitBreakerTransitionResponse, ) +from conductor.client.http.models.proto_registry_entry import ProtoRegistryEntry +from conductor.client.http.models.service_method import ServiceMethod +from conductor.client.http.models.service_registry import ServiceRegistry from conductor.client.orkes.orkes_base_client import OrkesBaseClient from conductor.client.service_registry_client import ServiceRegistryClient @@ -73,4 +74,4 @@ def get_queue_sizes_for_all_tasks(self) -> dict: def is_circuit_breaker_open(self, name: str) -> bool: """Check if circuit breaker is open for a service""" status = self.get_circuit_breaker_status(name) - return status.current_state and status.current_state.upper() == "OPEN" + return bool(status.current_state and status.current_state.upper() == "OPEN") diff --git a/src/conductor/client/orkes/orkes_task_client.py b/src/conductor/client/orkes/orkes_task_client.py index 855c9072..a1245b0c 100644 --- a/src/conductor/client/orkes/orkes_task_client.py +++ b/src/conductor/client/orkes/orkes_task_client.py @@ -1,5 +1,6 @@ from __future__ import annotations -from typing import Optional, List + +from typing import List, Optional from conductor.client.configuration.configuration import Configuration from conductor.client.http.models.poll_data import PollData diff --git a/src/conductor/client/orkes/orkes_workflow_client.py b/src/conductor/client/orkes/orkes_workflow_client.py index 2506028f..aa08003e 100644 --- a/src/conductor/client/orkes/orkes_workflow_client.py +++ b/src/conductor/client/orkes/orkes_workflow_client.py @@ -1,20 +1,21 @@ from __future__ import annotations -from typing import Optional, List, Dict + import uuid +from typing import Dict, List, Optional from conductor.client.configuration.configuration import Configuration -from conductor.client.http.models.skip_task_request import SkipTaskRequest -from conductor.client.http.models.workflow_status import WorkflowStatus +from conductor.client.http.models.correlation_ids_search_request import CorrelationIdsSearchRequest +from conductor.client.http.models.rerun_workflow_request import RerunWorkflowRequest from conductor.client.http.models.scrollable_search_result_workflow_summary import ( ScrollableSearchResultWorkflowSummary, ) from conductor.client.http.models.signal_response import SignalResponse -from conductor.client.http.models.correlation_ids_search_request import CorrelationIdsSearchRequest -from conductor.client.http.models.rerun_workflow_request import RerunWorkflowRequest +from conductor.client.http.models.skip_task_request import SkipTaskRequest from conductor.client.http.models.start_workflow_request import StartWorkflowRequest from conductor.client.http.models.workflow import Workflow from conductor.client.http.models.workflow_run import WorkflowRun from conductor.client.http.models.workflow_state_update import WorkflowStateUpdate +from conductor.client.http.models.workflow_status import WorkflowStatus from conductor.client.http.models.workflow_test_request import WorkflowTestRequest from conductor.client.orkes.orkes_base_client import OrkesBaseClient from conductor.client.workflow_client import WorkflowClient @@ -152,7 +153,7 @@ def delete_workflow(self, workflow_id: str, archive_workflow: Optional[bool] = T self.workflowResourceApi.delete1(workflow_id, archive_workflow=archive_workflow) def skip_task_from_workflow( - self, workflow_id: str, task_reference_name: str, request: SkipTaskRequest + self, workflow_id: str, task_reference_name: str, request: Optional[SkipTaskRequest] ): self.workflowResourceApi.skip_task_from_workflow(workflow_id, task_reference_name, request) diff --git a/src/conductor/client/orkes_clients.py b/src/conductor/client/orkes_clients.py index d15bbb00..58e20b77 100644 --- a/src/conductor/client/orkes_clients.py +++ b/src/conductor/client/orkes_clients.py @@ -1,16 +1,20 @@ +from __future__ import annotations + +from typing import Optional + from conductor.client.authorization_client import AuthorizationClient from conductor.client.configuration.configuration import Configuration from conductor.client.integration_client import IntegrationClient from conductor.client.metadata_client import MetadataClient +from conductor.client.orkes.orkes_authorization_client import OrkesAuthorizationClient from conductor.client.orkes.orkes_integration_client import OrkesIntegrationClient from conductor.client.orkes.orkes_metadata_client import OrkesMetadataClient from conductor.client.orkes.orkes_prompt_client import OrkesPromptClient -from conductor.client.orkes.orkes_schema_client import OrkesSchemaClient -from conductor.client.orkes.orkes_workflow_client import OrkesWorkflowClient -from conductor.client.orkes.orkes_task_client import OrkesTaskClient from conductor.client.orkes.orkes_scheduler_client import OrkesSchedulerClient +from conductor.client.orkes.orkes_schema_client import OrkesSchemaClient from conductor.client.orkes.orkes_secret_client import OrkesSecretClient -from conductor.client.orkes.orkes_authorization_client import OrkesAuthorizationClient +from conductor.client.orkes.orkes_task_client import OrkesTaskClient +from conductor.client.orkes.orkes_workflow_client import OrkesWorkflowClient from conductor.client.orkes.orkes_event_client import OrkesEventClient from conductor.client.prompt_client import PromptClient from conductor.client.scheduler_client import SchedulerClient @@ -22,7 +26,7 @@ class OrkesClients: - def __init__(self, configuration: Configuration = None): + def __init__(self, configuration: Optional[Configuration] = None): if configuration is None: configuration = Configuration() self.configuration = configuration diff --git a/src/conductor/client/prompt_client.py b/src/conductor/client/prompt_client.py index ce62c7b5..0226600d 100644 --- a/src/conductor/client/prompt_client.py +++ b/src/conductor/client/prompt_client.py @@ -4,7 +4,6 @@ from typing import List, Optional # python 2 and python 3 compatibility library - from conductor.client.http.models.prompt_template import PromptTemplate from conductor.client.orkes.models.metadata_tag import MetadataTag diff --git a/src/conductor/client/scheduler_client.py b/src/conductor/client/scheduler_client.py index a7274249..5b0cf558 100644 --- a/src/conductor/client/scheduler_client.py +++ b/src/conductor/client/scheduler_client.py @@ -1,11 +1,13 @@ from __future__ import annotations + from abc import ABC, abstractmethod -from typing import Optional, List -from conductor.client.http.models.workflow_schedule import WorkflowSchedule +from typing import List, Optional, Tuple + from conductor.client.http.models.save_schedule_request import SaveScheduleRequest from conductor.client.http.models.search_result_workflow_schedule_execution_model import ( SearchResultWorkflowScheduleExecutionModel, ) +from conductor.client.http.models.workflow_schedule import WorkflowSchedule from conductor.client.orkes.models.metadata_tag import MetadataTag @@ -15,7 +17,7 @@ def save_schedule(self, save_schedule_request: SaveScheduleRequest): pass @abstractmethod - def get_schedule(self, name: str) -> (Optional[WorkflowSchedule], str): + def get_schedule(self, name: str) -> Tuple[Optional[WorkflowSchedule], str]: pass @abstractmethod diff --git a/src/conductor/client/schema_client.py b/src/conductor/client/schema_client.py index f7a360e0..08bec8a1 100644 --- a/src/conductor/client/schema_client.py +++ b/src/conductor/client/schema_client.py @@ -4,7 +4,6 @@ from typing import List # python 2 and python 3 compatibility library - from conductor.client.http.models.schema_def import SchemaDef diff --git a/src/conductor/client/secret_client.py b/src/conductor/client/secret_client.py index cb9d8a15..0ca3fac7 100644 --- a/src/conductor/client/secret_client.py +++ b/src/conductor/client/secret_client.py @@ -1,5 +1,6 @@ from abc import ABC, abstractmethod from typing import List, Set + from conductor.client.orkes.models.metadata_tag import MetadataTag diff --git a/src/conductor/client/service_registry_client.py b/src/conductor/client/service_registry_client.py index 97d61be6..6107f111 100644 --- a/src/conductor/client/service_registry_client.py +++ b/src/conductor/client/service_registry_client.py @@ -1,13 +1,14 @@ from __future__ import annotations + from abc import ABC, abstractmethod -from typing import Optional, List +from typing import List, Optional -from conductor.client.http.models.service_registry import ServiceRegistry -from conductor.client.http.models.service_method import ServiceMethod -from conductor.client.http.models.proto_registry_entry import ProtoRegistryEntry from conductor.client.http.models.circuit_breaker_transition_response import ( CircuitBreakerTransitionResponse, ) +from conductor.client.http.models.proto_registry_entry import ProtoRegistryEntry +from conductor.client.http.models.service_method import ServiceMethod +from conductor.client.http.models.service_registry import ServiceRegistry class ServiceRegistryClient(ABC): diff --git a/src/conductor/client/task_client.py b/src/conductor/client/task_client.py index 5b84c96f..895ad435 100644 --- a/src/conductor/client/task_client.py +++ b/src/conductor/client/task_client.py @@ -1,13 +1,14 @@ from __future__ import annotations + from abc import ABC, abstractmethod -from typing import Optional, List +from typing import List, Optional from conductor.client.http.models.poll_data import PollData -from conductor.client.http.models.workflow import Workflow from conductor.client.http.models.task import Task +from conductor.client.http.models.task_exec_log import TaskExecLog from conductor.client.http.models.task_result import TaskResult +from conductor.client.http.models.workflow import Workflow from conductor.shared.http.enums import TaskResultStatus -from conductor.client.http.models.task_exec_log import TaskExecLog class TaskClient(ABC): diff --git a/src/conductor/client/telemetry/metrics_collector.py b/src/conductor/client/telemetry/metrics_collector.py index 10dbd944..b375a3ab 100644 --- a/src/conductor/client/telemetry/metrics_collector.py +++ b/src/conductor/client/telemetry/metrics_collector.py @@ -3,17 +3,14 @@ import time from typing import Any, ClassVar, Dict, List -from prometheus_client import CollectorRegistry -from prometheus_client import Counter -from prometheus_client import Gauge -from prometheus_client import write_to_textfile +from prometheus_client import CollectorRegistry, Counter, Gauge, write_to_textfile from prometheus_client.multiprocess import MultiProcessCollector from conductor.client.configuration.configuration import Configuration -from conductor.shared.configuration.settings.metrics_settings import MetricsSettings from conductor.client.telemetry.model.metric_documentation import MetricDocumentation from conductor.client.telemetry.model.metric_label import MetricLabel from conductor.client.telemetry.model.metric_name import MetricName +from conductor.shared.configuration.settings.metrics_settings import MetricsSettings logger = logging.getLogger(Configuration.get_logging_formatted_name(__name__)) @@ -170,7 +167,7 @@ def __increment_counter( if not self.must_collect_metrics: return counter = self.__get_counter( - name=name, documentation=documentation, labelnames=labels.keys() + name=name, documentation=documentation, labelnames=list(labels.keys()) ) counter.labels(*labels.values()).inc() @@ -183,7 +180,9 @@ def __record_gauge( ) -> None: if not self.must_collect_metrics: return - gauge = self.__get_gauge(name=name, documentation=documentation, labelnames=labels.keys()) + gauge = self.__get_gauge( + name=name, documentation=documentation, labelnames=list(labels.keys()) + ) gauge.labels(*labels.values()).set(value) def __get_counter( diff --git a/src/conductor/client/worker/worker.py b/src/conductor/client/worker/worker.py index ba25f2df..083fb214 100644 --- a/src/conductor/client/worker/worker.py +++ b/src/conductor/client/worker/worker.py @@ -1,24 +1,23 @@ from __future__ import annotations + import dataclasses import inspect import logging import time import traceback from copy import deepcopy -from typing import Any, Callable, Union, Optional - -from typing_extensions import Self +from typing import Any, Callable, Optional, Union -from conductor.shared.automator import utils -from conductor.shared.automator.utils import convert_from_dict_or_list from conductor.client.configuration.configuration import Configuration from conductor.client.http.api_client import ApiClient -from conductor.client.http.models.task_exec_log import TaskExecLog from conductor.client.http.models.task import Task +from conductor.client.http.models.task_exec_log import TaskExecLog from conductor.client.http.models.task_result import TaskResult +from conductor.client.worker.worker_interface import WorkerInterface +from conductor.shared.automator import utils +from conductor.shared.automator.utils import convert_from_dict_or_list from conductor.shared.http.enums import TaskResultStatus from conductor.shared.worker.exception import NonRetryableException -from conductor.client.worker.worker_interface import WorkerInterface ExecuteTaskFunction = Callable[[Union[Task, object]], Union[TaskResult, object]] @@ -46,7 +45,7 @@ def __init__( poll_interval: Optional[float] = None, domain: Optional[str] = None, worker_id: Optional[str] = None, - ) -> Self: + ) -> None: super().__init__(task_definition_name) self.api_client = ApiClient() self.config = Configuration() diff --git a/src/conductor/client/worker/worker_interface.py b/src/conductor/client/worker/worker_interface.py index d4ca6e8e..716f9091 100644 --- a/src/conductor/client/worker/worker_interface.py +++ b/src/conductor/client/worker/worker_interface.py @@ -1,11 +1,12 @@ from __future__ import annotations + import abc import socket from typing import Union +from conductor.client.configuration.configuration import Configuration from conductor.client.http.models.task import Task from conductor.client.http.models.task_result import TaskResult -from conductor.client.configuration.configuration import Configuration DEFAULT_POLLING_INTERVAL = 100 # ms diff --git a/src/conductor/client/worker/worker_task.py b/src/conductor/client/worker/worker_task.py index 92983d2a..956dfd1e 100644 --- a/src/conductor/client/worker/worker_task.py +++ b/src/conductor/client/worker/worker_task.py @@ -1,6 +1,8 @@ from __future__ import annotations + import functools from typing import Optional + from conductor.client.automator.task_handler import register_decorated_fn from conductor.client.configuration.configuration import Configuration from conductor.client.workflow.task.simple_task import SimpleTask diff --git a/src/conductor/client/workflow/conductor_workflow.py b/src/conductor/client/workflow/conductor_workflow.py index e8338186..750714e0 100644 --- a/src/conductor/client/workflow/conductor_workflow.py +++ b/src/conductor/client/workflow/conductor_workflow.py @@ -1,22 +1,23 @@ from __future__ import annotations + from copy import deepcopy -from typing import Any, Dict, List, Union, Optional +from typing import Any, Dict, List, Optional, Union from shortuuid import uuid from typing_extensions import Self from conductor.client.http.models.start_workflow_request import StartWorkflowRequest +from conductor.client.http.models.sub_workflow_params import SubWorkflowParams from conductor.client.http.models.workflow_def import WorkflowDef from conductor.client.http.models.workflow_run import WorkflowRun from conductor.client.http.models.workflow_task import WorkflowTask -from conductor.client.http.models.sub_workflow_params import SubWorkflowParams -from conductor.shared.http.enums import IdempotencyStrategy from conductor.client.workflow.executor.workflow_executor import WorkflowExecutor from conductor.client.workflow.task.fork_task import ForkTask from conductor.client.workflow.task.join_task import JoinTask from conductor.client.workflow.task.task import TaskInterface from conductor.client.workflow.task.task_type import TaskType from conductor.client.workflow.task.timeout_policy import TimeoutPolicy +from conductor.shared.http.enums import IdempotencyStrategy class ConductorWorkflow: @@ -28,23 +29,23 @@ def __init__( name: str, version: Optional[int] = None, description: Optional[str] = None, - ) -> Self: - self._executor = executor - self.name = name - self.version = version - self.description = description - self._tasks = [] - self._owner_email = None - self._timeout_policy = None - self._timeout_seconds = 60 - self._failure_workflow = "" - self._input_parameters = [] - self._output_parameters = {} - self._input_template = {} - self._variables = {} - self._restartable = True - self._workflow_status_listener_enabled = False - self._workflow_status_listener_sink = None + ) -> None: + self._executor: WorkflowExecutor = executor + self._name: str = name + self._version: Optional[int] = version + self._description: Optional[str] = description + self._tasks: List[TaskInterface] = [] + self._owner_email: Optional[str] = None + self._timeout_policy: Optional[TimeoutPolicy] = None + self._timeout_seconds: int = 60 + self._failure_workflow: str = "" + self._input_parameters: List[str] = [] + self._output_parameters: Dict[str, Any] = {} + self._input_template: Dict[str, Any] = {} + self._variables: Dict[str, Any] = {} + self._restartable: bool = True + self._workflow_status_listener_enabled: bool = False + self._workflow_status_listener_sink: Optional[str] = None @property def name(self) -> str: @@ -57,7 +58,7 @@ def name(self, name: str) -> None: self._name = deepcopy(name) @property - def version(self) -> int: + def version(self) -> Optional[int]: return self._version @version.setter @@ -67,7 +68,7 @@ def version(self, version: int) -> None: self._version = deepcopy(version) @property - def description(self) -> str: + def description(self) -> Optional[str]: return self._description @description.setter @@ -110,11 +111,11 @@ def restartable(self, restartable: bool) -> Self: self._restartable = deepcopy(restartable) return self - def enable_status_listener(self, sink_name: bool) -> Self: + def enable_status_listener(self, sink_name: str) -> None: self._workflow_status_listener_sink = sink_name self._workflow_status_listener_enabled = True - def disable_status_listener(self) -> Self: + def disable_status_listener(self) -> None: self._workflow_status_listener_sink = None self._workflow_status_listener_enabled = False @@ -304,7 +305,7 @@ def to_workflow_task(self): return sub_workflow_task.to_workflow_task() def __get_workflow_task_list(self) -> List[WorkflowTask]: - workflow_task_list = [] + workflow_task_list: List[WorkflowTask] = [] for task in self._tasks: converted_task = task.to_workflow_task() if isinstance(converted_task, list): @@ -399,7 +400,7 @@ def output(self, json_path: Optional[str] = None) -> str: class InlineSubWorkflowTask(TaskInterface): - def __init__(self, task_ref_name: str, workflow: ConductorWorkflow) -> Self: + def __init__(self, task_ref_name: str, workflow: ConductorWorkflow) -> None: super().__init__( task_reference_name=task_ref_name, task_type=TaskType.SUB_WORKFLOW, diff --git a/src/conductor/client/workflow/executor/workflow_executor.py b/src/conductor/client/workflow/executor/workflow_executor.py index 8f968147..3c7028e8 100644 --- a/src/conductor/client/workflow/executor/workflow_executor.py +++ b/src/conductor/client/workflow/executor/workflow_executor.py @@ -1,31 +1,30 @@ from __future__ import annotations + import uuid from typing import Any, Dict, List, Optional -from typing_extensions import Self - from conductor.client.configuration.configuration import Configuration from conductor.client.http.api.metadata_resource_api import MetadataResourceApi from conductor.client.http.api.task_resource_api import TaskResourceApi from conductor.client.http.api_client import ApiClient +from conductor.client.http.models.correlation_ids_search_request import CorrelationIdsSearchRequest +from conductor.client.http.models.rerun_workflow_request import RerunWorkflowRequest +from conductor.client.http.models.scrollable_search_result_workflow_summary import ( + ScrollableSearchResultWorkflowSummary, +) +from conductor.client.http.models.signal_response import SignalResponse +from conductor.client.http.models.skip_task_request import SkipTaskRequest +from conductor.client.http.models.start_workflow_request import StartWorkflowRequest from conductor.client.http.models.task_result import TaskResult from conductor.client.http.models.workflow import Workflow from conductor.client.http.models.workflow_def import WorkflowDef from conductor.client.http.models.workflow_run import WorkflowRun from conductor.client.http.models.workflow_status import WorkflowStatus -from conductor.client.http.models.scrollable_search_result_workflow_summary import ( - ScrollableSearchResultWorkflowSummary, -) -from conductor.client.http.models.start_workflow_request import StartWorkflowRequest -from conductor.client.http.models.skip_task_request import SkipTaskRequest -from conductor.client.http.models.rerun_workflow_request import RerunWorkflowRequest -from conductor.client.http.models.signal_response import SignalResponse -from conductor.client.http.models.correlation_ids_search_request import CorrelationIdsSearchRequest from conductor.client.orkes.orkes_workflow_client import OrkesWorkflowClient class WorkflowExecutor: - def __init__(self, configuration: Configuration) -> Self: + def __init__(self, configuration: Configuration) -> None: api_client = ApiClient(configuration) self.metadata_client = MetadataResourceApi(api_client) self.task_client = TaskResourceApi(api_client) @@ -172,7 +171,9 @@ def search( skip_cache: Optional[bool] = None, ) -> ScrollableSearchResultWorkflowSummary: """Search for workflows based on payload and other parameters""" - return self.workflow_client.search(start=start, size=size, free_text=free_text, query=query) + return self.workflow_client.search( + start=start or 0, size=size or 100, free_text=free_text or "*", query=query + ) def get_by_correlation_ids( self, @@ -185,8 +186,8 @@ def get_by_correlation_ids( return self.workflow_client.get_by_correlation_ids( correlation_ids=correlation_ids, workflow_name=workflow_name, - include_tasks=include_tasks, - include_completed=include_closed, + include_tasks=include_tasks or False, + include_completed=include_closed or False, ) def get_by_correlation_ids_and_names( @@ -202,8 +203,8 @@ def get_by_correlation_ids_and_names( """ return self.workflow_client.get_by_correlation_ids_in_batch( batch_request=batch_request, - include_completed=include_closed, - include_tasks=include_tasks, + include_completed=include_closed or False, + include_tasks=include_tasks or False, ) def pause(self, workflow_id: str) -> None: @@ -224,19 +225,19 @@ def terminate( return self.workflow_client.terminate_workflow( workflow_id=workflow_id, reason=reason, - trigger_failure_workflow=trigger_failure_workflow, + trigger_failure_workflow=trigger_failure_workflow or False, ) def restart(self, workflow_id: str, use_latest_definitions: Optional[bool] = None) -> None: """Restarts a completed workflow""" return self.workflow_client.restart_workflow( - workflow_id=workflow_id, use_latest_def=use_latest_definitions + workflow_id=workflow_id, use_latest_def=use_latest_definitions or False ) def retry(self, workflow_id: str, resume_subworkflow_tasks: Optional[bool] = None) -> None: """Retries the last failed task""" return self.workflow_client.retry_workflow( - workflow_id=workflow_id, resume_subworkflow_tasks=resume_subworkflow_tasks + workflow_id=workflow_id, resume_subworkflow_tasks=resume_subworkflow_tasks or False ) def rerun(self, rerun_workflow_request: RerunWorkflowRequest, workflow_id: str) -> str: @@ -247,7 +248,10 @@ def rerun(self, rerun_workflow_request: RerunWorkflowRequest, workflow_id: str) ) def skip_task_from_workflow( - self, workflow_id: str, task_reference_name: str, skip_task_request: SkipTaskRequest = None + self, + workflow_id: str, + task_reference_name: str, + skip_task_request: Optional[SkipTaskRequest] = None, ) -> None: """Skips a given task from a current running workflow""" return self.workflow_client.skip_task_from_workflow( diff --git a/src/conductor/client/workflow/task/do_while_task.py b/src/conductor/client/workflow/task/do_while_task.py index 2e9011a8..495080da 100644 --- a/src/conductor/client/workflow/task/do_while_task.py +++ b/src/conductor/client/workflow/task/do_while_task.py @@ -1,10 +1,8 @@ from __future__ import annotations -from copy import deepcopy +from copy import deepcopy from typing import List, Optional -from typing_extensions import Self - from conductor.client.http.models.workflow_task import WorkflowTask from conductor.client.workflow.task.task import ( TaskInterface, @@ -21,7 +19,7 @@ class DoWhileTask(TaskInterface): # termination_condition is a Javascript expression that evaluates to True or False def __init__( self, task_ref_name: str, termination_condition: str, tasks: List[TaskInterface] - ) -> Self: + ) -> None: super().__init__( task_reference_name=task_ref_name, task_type=TaskType.DO_WHILE, @@ -42,7 +40,7 @@ def to_workflow_task(self) -> WorkflowTask: class LoopTask(DoWhileTask): - def __init__(self, task_ref_name: str, iterations: int, tasks: List[TaskInterface]) -> Self: + def __init__(self, task_ref_name: str, iterations: int, tasks: List[TaskInterface]) -> None: super().__init__( task_ref_name=task_ref_name, termination_condition=get_for_loop_condition( @@ -60,7 +58,7 @@ def __init__( tasks: List[TaskInterface], iterate_over: str, variables: Optional[List[str]] = None, - ) -> Self: + ) -> None: super().__init__( task_ref_name=task_ref_name, termination_condition=get_for_loop_condition( diff --git a/src/conductor/client/workflow/task/dynamic_fork_task.py b/src/conductor/client/workflow/task/dynamic_fork_task.py index 35948898..bafc0f97 100644 --- a/src/conductor/client/workflow/task/dynamic_fork_task.py +++ b/src/conductor/client/workflow/task/dynamic_fork_task.py @@ -1,6 +1,7 @@ -from copy import deepcopy +from __future__ import annotations -from typing_extensions import Self +from copy import deepcopy +from typing import List, Optional from conductor.client.http.models.workflow_task import WorkflowTask from conductor.client.workflow.task.join_task import JoinTask @@ -14,14 +15,14 @@ def __init__( task_ref_name: str, tasks_param: str = "dynamicTasks", tasks_input_param_name: str = "dynamicTasksInputs", - join_task: JoinTask = None, - ) -> Self: + join_task: Optional[JoinTask] = None, + ) -> None: super().__init__(task_reference_name=task_ref_name, task_type=TaskType.FORK_JOIN_DYNAMIC) self.tasks_param = tasks_param self.tasks_input_param_name = tasks_input_param_name self._join_task = deepcopy(join_task) - def to_workflow_task(self) -> WorkflowTask: + def to_workflow_task(self) -> List[WorkflowTask]: wf_task = super().to_workflow_task() wf_task.dynamic_fork_tasks_param = self.tasks_param wf_task.dynamic_fork_tasks_input_param_name = self.tasks_input_param_name diff --git a/src/conductor/client/workflow/task/dynamic_task.py b/src/conductor/client/workflow/task/dynamic_task.py index 374f6202..d005b435 100644 --- a/src/conductor/client/workflow/task/dynamic_task.py +++ b/src/conductor/client/workflow/task/dynamic_task.py @@ -1,5 +1,3 @@ -from typing_extensions import Self - from conductor.client.http.models import WorkflowTask from conductor.client.workflow.task.task import TaskInterface from conductor.client.workflow.task.task_type import TaskType @@ -8,7 +6,7 @@ class DynamicTask(TaskInterface): def __init__( self, dynamic_task: str, task_reference_name: str, dynamic_task_param: str = "taskToExecute" - ) -> Self: + ) -> None: super().__init__( task_reference_name=task_reference_name, task_type=TaskType.DYNAMIC, diff --git a/src/conductor/client/workflow/task/event_task.py b/src/conductor/client/workflow/task/event_task.py index a29cb8ee..ce13eec5 100644 --- a/src/conductor/client/workflow/task/event_task.py +++ b/src/conductor/client/workflow/task/event_task.py @@ -1,14 +1,12 @@ from copy import deepcopy -from typing_extensions import Self - from conductor.client.http.models.workflow_task import WorkflowTask from conductor.client.workflow.task.task import TaskInterface from conductor.client.workflow.task.task_type import TaskType class EventTaskInterface(TaskInterface): - def __init__(self, task_ref_name: str, event_prefix: str, event_suffix: str) -> Self: + def __init__(self, task_ref_name: str, event_prefix: str, event_suffix: str) -> None: super().__init__(task_reference_name=task_ref_name, task_type=TaskType.EVENT) self._sink = deepcopy(event_prefix) + ":" + deepcopy(event_suffix) @@ -19,10 +17,10 @@ def to_workflow_task(self) -> WorkflowTask: class SqsEventTask(EventTaskInterface): - def __init__(self, task_ref_name: str, queue_name: str) -> Self: + def __init__(self, task_ref_name: str, queue_name: str) -> None: super().__init__(task_ref_name, "sqs", queue_name) class ConductorEventTask(EventTaskInterface): - def __init__(self, task_ref_name: str, event_name: str) -> Self: + def __init__(self, task_ref_name: str, event_name: str) -> None: super().__init__(task_ref_name, "conductor", event_name) diff --git a/src/conductor/client/workflow/task/fork_task.py b/src/conductor/client/workflow/task/fork_task.py index 50d3ad3a..13f05f95 100644 --- a/src/conductor/client/workflow/task/fork_task.py +++ b/src/conductor/client/workflow/task/fork_task.py @@ -1,8 +1,7 @@ from __future__ import annotations -from copy import deepcopy -from typing import List, Optional -from typing_extensions import Self +from copy import deepcopy +from typing import List, Optional, Union from conductor.client.http.models.workflow_task import WorkflowTask from conductor.client.workflow.task.join_task import JoinTask @@ -20,12 +19,12 @@ def __init__( task_ref_name: str, forked_tasks: List[List[TaskInterface]], join_on: Optional[List[str]] = None, - ) -> Self: + ) -> None: super().__init__(task_reference_name=task_ref_name, task_type=TaskType.FORK_JOIN) self._forked_tasks = deepcopy(forked_tasks) self._join_on = join_on - def to_workflow_task(self) -> [WorkflowTask]: + def to_workflow_task(self) -> Union[WorkflowTask, List[WorkflowTask]]: tasks = [] workflow_task = super().to_workflow_task() workflow_task.fork_tasks = [] diff --git a/src/conductor/client/workflow/task/get_document.py b/src/conductor/client/workflow/task/get_document.py index 696d3ab7..20bb4cde 100644 --- a/src/conductor/client/workflow/task/get_document.py +++ b/src/conductor/client/workflow/task/get_document.py @@ -1,11 +1,9 @@ -from typing_extensions import Self - from conductor.client.workflow.task.task import TaskInterface from conductor.client.workflow.task.task_type import TaskType class GetDocument(TaskInterface): - def __init__(self, task_name: str, task_ref_name: str, url: str, media_type: str) -> Self: + def __init__(self, task_name: str, task_ref_name: str, url: str, media_type: str) -> None: super().__init__( task_name=task_name, task_reference_name=task_ref_name, diff --git a/src/conductor/client/workflow/task/http_poll_task.py b/src/conductor/client/workflow/task/http_poll_task.py index 6dd4d950..54c7f10a 100644 --- a/src/conductor/client/workflow/task/http_poll_task.py +++ b/src/conductor/client/workflow/task/http_poll_task.py @@ -1,10 +1,8 @@ from __future__ import annotations -from copy import deepcopy +from copy import deepcopy from typing import Any, ClassVar, Dict, List, Optional -from typing_extensions import Self - from conductor.client.workflow.task.http_task import HttpMethod from conductor.client.workflow.task.task import TaskInterface from conductor.client.workflow.task.task_type import TaskType @@ -23,7 +21,7 @@ class HttpPollInput: "_termination_condition": "str", "_polling_interval": "int", "_max_poll_count": "int", - "_polling_strategy": str, + "_polling_strategy": "str", } attribute_map: ClassVar[Dict[str, str]] = { @@ -55,7 +53,7 @@ def __init__( connection_time_out: Optional[int] = None, read_timeout: Optional[int] = None, body: Any = None, - ) -> Self: + ) -> None: self._method = deepcopy(method) self._uri = deepcopy(uri) self._headers = deepcopy(headers) @@ -71,7 +69,7 @@ def __init__( class HttpPollTask(TaskInterface): - def __init__(self, task_ref_name: str, http_input: HttpPollInput) -> Self: + def __init__(self, task_ref_name: str, http_input: HttpPollInput) -> None: super().__init__( task_reference_name=task_ref_name, task_type=TaskType.HTTP_POLL, diff --git a/src/conductor/client/workflow/task/http_task.py b/src/conductor/client/workflow/task/http_task.py index 957da85b..98c5a4ca 100644 --- a/src/conductor/client/workflow/task/http_task.py +++ b/src/conductor/client/workflow/task/http_task.py @@ -1,10 +1,9 @@ from __future__ import annotations + from copy import deepcopy from enum import Enum from typing import Any, ClassVar, Dict, List, Optional, Union -from typing_extensions import Self - from conductor.client.workflow.task.task import TaskInterface from conductor.client.workflow.task.task_type import TaskType @@ -51,7 +50,7 @@ def __init__( connection_time_out: Optional[int] = None, read_timeout: Optional[int] = None, body: Any = None, - ) -> Self: + ) -> None: self._method = deepcopy(method) self._uri = deepcopy(uri) self._headers = deepcopy(headers) @@ -63,7 +62,7 @@ def __init__( class HttpTask(TaskInterface): - def __init__(self, task_ref_name: str, http_input: Union[HttpInput, dict]) -> Self: + def __init__(self, task_ref_name: str, http_input: Union[HttpInput, dict]) -> None: if type(http_input) is dict and "method" not in http_input: http_input["method"] = "GET" super().__init__( @@ -72,7 +71,7 @@ def __init__(self, task_ref_name: str, http_input: Union[HttpInput, dict]) -> Se input_parameters={"http_request": http_input}, ) - def status_code(self) -> int: + def status_code(self) -> str: return "${" + f"{self.task_reference_name}.output.response.statusCode" + "}" def headers(self, json_path: Optional[str] = None) -> str: diff --git a/src/conductor/client/workflow/task/human_task.py b/src/conductor/client/workflow/task/human_task.py index 212b0472..669bcf3f 100644 --- a/src/conductor/client/workflow/task/human_task.py +++ b/src/conductor/client/workflow/task/human_task.py @@ -1,7 +1,7 @@ from __future__ import annotations + from enum import Enum from typing import Optional -from typing_extensions import Self from conductor.client.workflow.task.task import TaskInterface from conductor.client.workflow.task.task_type import TaskType @@ -35,7 +35,7 @@ def __init__( form_template: Optional[str] = None, form_version: int = 0, assignment_completion_strategy: AssignmentCompletionStrategy = AssignmentCompletionStrategy.LEAVE_OPEN, - ) -> Self: + ) -> None: super().__init__(task_reference_name=task_ref_name, task_type=TaskType.HUMAN) self.input_parameters.update( { diff --git a/src/conductor/client/workflow/task/inline.py b/src/conductor/client/workflow/task/inline.py index 55a66e1e..90e314f3 100644 --- a/src/conductor/client/workflow/task/inline.py +++ b/src/conductor/client/workflow/task/inline.py @@ -1,6 +1,6 @@ from __future__ import annotations + from typing import Dict, Optional -from typing_extensions import Self from conductor.client.workflow.task.task import TaskInterface from conductor.client.workflow.task.task_type import TaskType @@ -9,7 +9,7 @@ class InlineTask(TaskInterface): def __init__( self, task_ref_name: str, script: str, bindings: Optional[Dict[str, str]] = None - ) -> Self: + ) -> None: super().__init__( task_reference_name=task_ref_name, task_type=TaskType.INLINE, diff --git a/src/conductor/client/workflow/task/javascript_task.py b/src/conductor/client/workflow/task/javascript_task.py index c71e7c86..3b512277 100644 --- a/src/conductor/client/workflow/task/javascript_task.py +++ b/src/conductor/client/workflow/task/javascript_task.py @@ -1,6 +1,6 @@ from __future__ import annotations + from typing import Dict, Optional -from typing_extensions import Self from conductor.client.workflow.task.task import TaskInterface from conductor.client.workflow.task.task_type import TaskType @@ -9,7 +9,7 @@ class JavascriptTask(TaskInterface): def __init__( self, task_ref_name: str, script: str, bindings: Optional[Dict[str, str]] = None - ) -> Self: + ) -> None: super().__init__( task_reference_name=task_ref_name, task_type=TaskType.INLINE, @@ -27,6 +27,6 @@ def output(self, json_path: Optional[str] = None) -> str: else: return "${" + f"{self.task_reference_name}.output.result.{json_path}" + "}" - def evaluator_type(self, evaluator_type: str) -> Self: + @TaskInterface.evaluator_type.setter + def evaluator_type(self, evaluator_type: str) -> None: self.input_parameters["evaluatorType"] = evaluator_type - return self diff --git a/src/conductor/client/workflow/task/join_task.py b/src/conductor/client/workflow/task/join_task.py index b17a2024..8de7d926 100644 --- a/src/conductor/client/workflow/task/join_task.py +++ b/src/conductor/client/workflow/task/join_task.py @@ -1,9 +1,8 @@ from __future__ import annotations + from copy import deepcopy from typing import List, Optional -from typing_extensions import Self - from conductor.client.http.models.workflow_task import WorkflowTask from conductor.client.workflow.task.task import TaskInterface from conductor.client.workflow.task.task_type import TaskType @@ -15,7 +14,7 @@ def __init__( task_ref_name: str, join_on: Optional[List[str]] = None, join_on_script: Optional[str] = None, - ) -> Self: + ) -> None: super().__init__(task_reference_name=task_ref_name, task_type=TaskType.JOIN) self._join_on = deepcopy(join_on) if join_on_script is not None: diff --git a/src/conductor/client/workflow/task/json_jq_task.py b/src/conductor/client/workflow/task/json_jq_task.py index e47b11f0..23f2da54 100644 --- a/src/conductor/client/workflow/task/json_jq_task.py +++ b/src/conductor/client/workflow/task/json_jq_task.py @@ -1,11 +1,9 @@ -from typing_extensions import Self - from conductor.client.workflow.task.task import TaskInterface from conductor.client.workflow.task.task_type import TaskType class JsonJQTask(TaskInterface): - def __init__(self, task_ref_name: str, script: str) -> Self: + def __init__(self, task_ref_name: str, script: str) -> None: super().__init__( task_reference_name=task_ref_name, task_type=TaskType.JSON_JQ_TRANSFORM, diff --git a/src/conductor/client/workflow/task/kafka_publish.py b/src/conductor/client/workflow/task/kafka_publish.py index dde7f2dd..755ccc91 100644 --- a/src/conductor/client/workflow/task/kafka_publish.py +++ b/src/conductor/client/workflow/task/kafka_publish.py @@ -1,4 +1,6 @@ -from typing_extensions import Self +from __future__ import annotations + +from typing import Optional from conductor.client.workflow.task.kafka_publish_input import KafkaPublishInput from conductor.client.workflow.task.task import TaskInterface @@ -6,7 +8,9 @@ class KafkaPublishTask(TaskInterface): - def __init__(self, task_ref_name: str, kafka_publish_input: KafkaPublishInput = None) -> Self: + def __init__( + self, task_ref_name: str, kafka_publish_input: Optional[KafkaPublishInput] = None + ) -> None: super().__init__( task_reference_name=task_ref_name, task_type=TaskType.KAFKA_PUBLISH, diff --git a/src/conductor/client/workflow/task/kafka_publish_input.py b/src/conductor/client/workflow/task/kafka_publish_input.py index c7b9365e..cd0a0e47 100644 --- a/src/conductor/client/workflow/task/kafka_publish_input.py +++ b/src/conductor/client/workflow/task/kafka_publish_input.py @@ -1,8 +1,7 @@ from __future__ import annotations -from copy import deepcopy -from typing import Dict, Any, Optional, ClassVar -from typing_extensions import Self +from copy import deepcopy +from typing import Any, ClassVar, Dict, Optional class KafkaPublishInput: @@ -38,15 +37,15 @@ def __init__( max_block_ms: Optional[str] = None, headers: Optional[Dict[str, Any]] = None, topic: Optional[str] = None, - ) -> Self: - self._bootstrap_servers = deepcopy(bootstrap_servers) - self._key = deepcopy(key) - self._key_serializer = deepcopy(key_serializer) - self._value = deepcopy(value) - self._request_timeout_ms = deepcopy(request_timeout_ms) - self._max_block_ms = deepcopy(max_block_ms) - self._headers = deepcopy(headers) - self._topic = deepcopy(topic) + ) -> None: + self._bootstrap_servers: Optional[str] = deepcopy(bootstrap_servers) + self._key: Optional[str] = deepcopy(key) + self._key_serializer: Optional[str] = deepcopy(key_serializer) + self._value: Optional[str] = deepcopy(value) + self._request_timeout_ms: Optional[str] = deepcopy(request_timeout_ms) + self._max_block_ms: Optional[str] = deepcopy(max_block_ms) + self._headers: Optional[Dict[str, Any]] = deepcopy(headers) + self._topic: Optional[str] = deepcopy(topic) @property def bootstrap_servers(self) -> Optional[str]: diff --git a/src/conductor/client/workflow/task/llm_tasks/llm_chat_complete.py b/src/conductor/client/workflow/task/llm_tasks/llm_chat_complete.py index 9751a851..09109720 100644 --- a/src/conductor/client/workflow/task/llm_tasks/llm_chat_complete.py +++ b/src/conductor/client/workflow/task/llm_tasks/llm_chat_complete.py @@ -1,5 +1,6 @@ from __future__ import annotations -from typing import Optional, List, Dict + +from typing import Any, Dict, List, Optional from typing_extensions import Self @@ -26,11 +27,11 @@ def __init__( top_p: int = 1, instructions_template: Optional[str] = None, template_variables: Optional[Dict[str, object]] = None, - ) -> Self: + ) -> None: template_variables = template_variables or {} stop_words = stop_words or [] - optional_input_params = {} + optional_input_params: Dict[str, Any] = {} if stop_words: optional_input_params.update({"stopWords": stop_words}) @@ -38,7 +39,7 @@ def __init__( if max_tokens: optional_input_params.update({"maxTokens": max_tokens}) - input_params = { + input_params: Dict[str, Any] = { "llmProvider": llm_provider, "model": model, "promptVariables": template_variables, diff --git a/src/conductor/client/workflow/task/llm_tasks/llm_generate_embeddings.py b/src/conductor/client/workflow/task/llm_tasks/llm_generate_embeddings.py index 789bdec9..12dda0a0 100644 --- a/src/conductor/client/workflow/task/llm_tasks/llm_generate_embeddings.py +++ b/src/conductor/client/workflow/task/llm_tasks/llm_generate_embeddings.py @@ -1,6 +1,6 @@ from __future__ import annotations + from typing import Optional -from typing_extensions import Self from conductor.client.workflow.task.task import TaskInterface from conductor.client.workflow.task.task_type import TaskType @@ -14,7 +14,7 @@ def __init__( model: str, text: str, task_name: Optional[str] = None, - ) -> Self: + ) -> None: if task_name is None: task_name = "llm_generate_embeddings" super().__init__( diff --git a/src/conductor/client/workflow/task/llm_tasks/llm_index_documents.py b/src/conductor/client/workflow/task/llm_tasks/llm_index_documents.py index cfcea306..0d9248cd 100644 --- a/src/conductor/client/workflow/task/llm_tasks/llm_index_documents.py +++ b/src/conductor/client/workflow/task/llm_tasks/llm_index_documents.py @@ -1,8 +1,6 @@ from __future__ import annotations -from typing import Optional - -from typing_extensions import Self +from typing import Any, Dict, Optional from conductor.client.workflow.task.llm_tasks.utils.embedding_model import EmbeddingModel from conductor.client.workflow.task.task import TaskInterface @@ -41,7 +39,7 @@ def __init__( doc_id: Optional[str] = None, task_name: Optional[str] = None, metadata: Optional[dict] = None, - ) -> Self: + ) -> None: metadata = metadata or {} input_params = { "vectorDB": vector_db, @@ -54,7 +52,7 @@ def __init__( "metadata": metadata, } - optional_input_params = {} + optional_input_params: Dict[str, Any] = {} if chunk_size is not None: optional_input_params.update({"chunkSize": chunk_size}) diff --git a/src/conductor/client/workflow/task/llm_tasks/llm_index_text.py b/src/conductor/client/workflow/task/llm_tasks/llm_index_text.py index b1784869..05139e4e 100644 --- a/src/conductor/client/workflow/task/llm_tasks/llm_index_text.py +++ b/src/conductor/client/workflow/task/llm_tasks/llm_index_text.py @@ -1,6 +1,6 @@ from __future__ import annotations + from typing import Optional -from typing_extensions import Self from conductor.client.workflow.task.llm_tasks.utils.embedding_model import EmbeddingModel from conductor.client.workflow.task.task import TaskInterface @@ -32,7 +32,7 @@ def __init__( namespace: Optional[str] = None, task_name: Optional[str] = None, metadata: Optional[dict] = None, - ) -> Self: + ) -> None: metadata = metadata or {} if task_name is None: task_name = "llm_index_doc" diff --git a/src/conductor/client/workflow/task/llm_tasks/llm_query_embeddings.py b/src/conductor/client/workflow/task/llm_tasks/llm_query_embeddings.py index 14e685ec..212fce13 100644 --- a/src/conductor/client/workflow/task/llm_tasks/llm_query_embeddings.py +++ b/src/conductor/client/workflow/task/llm_tasks/llm_query_embeddings.py @@ -1,7 +1,6 @@ from __future__ import annotations -from typing import List, Optional -from typing_extensions import Self +from typing import List, Optional from conductor.client.workflow.task.task import TaskInterface from conductor.client.workflow.task.task_type import TaskType @@ -16,7 +15,7 @@ def __init__( embeddings: List[int], task_name: Optional[str] = None, namespace: Optional[str] = None, - ) -> Self: + ) -> None: if task_name is None: task_name = "llm_get_embeddings" diff --git a/src/conductor/client/workflow/task/llm_tasks/llm_search_index.py b/src/conductor/client/workflow/task/llm_tasks/llm_search_index.py index 4511d6e3..0ceee5ee 100644 --- a/src/conductor/client/workflow/task/llm_tasks/llm_search_index.py +++ b/src/conductor/client/workflow/task/llm_tasks/llm_search_index.py @@ -1,6 +1,6 @@ from __future__ import annotations + from typing import Optional -from typing_extensions import Self from conductor.client.workflow.task.task import TaskInterface from conductor.client.workflow.task.task_type import TaskType @@ -18,7 +18,7 @@ def __init__( query: str, task_name: Optional[str] = None, max_results: int = 1, - ) -> Self: + ) -> None: if task_name is None: task_name = "llm_search_index" diff --git a/src/conductor/client/workflow/task/llm_tasks/llm_text_complete.py b/src/conductor/client/workflow/task/llm_tasks/llm_text_complete.py index f944403f..fac4f154 100644 --- a/src/conductor/client/workflow/task/llm_tasks/llm_text_complete.py +++ b/src/conductor/client/workflow/task/llm_tasks/llm_text_complete.py @@ -1,6 +1,6 @@ from __future__ import annotations -from typing import Optional, List, Dict +from typing import Any, Dict, List, Optional from typing_extensions import Self @@ -20,9 +20,9 @@ def __init__( temperature: int = 0, top_p: int = 1, task_name: Optional[str] = None, - ) -> Self: + ) -> None: stop_words = stop_words or [] - optional_input_params = {} + optional_input_params: Dict[str, Any] = {} if stop_words: optional_input_params.update({"stopWords": stop_words}) @@ -33,7 +33,7 @@ def __init__( if not task_name: task_name = "llm_text_complete" - input_params = { + input_params: Dict[str, Any] = { "llmProvider": llm_provider, "model": model, "promptName": prompt_name, diff --git a/src/conductor/client/workflow/task/llm_tasks/utils/embedding_model.py b/src/conductor/client/workflow/task/llm_tasks/utils/embedding_model.py index 07eda9b9..b0aaa44a 100644 --- a/src/conductor/client/workflow/task/llm_tasks/utils/embedding_model.py +++ b/src/conductor/client/workflow/task/llm_tasks/utils/embedding_model.py @@ -17,14 +17,14 @@ def __init__(self, provider: str, model: str): def provider(self) -> str: return self._provider + @provider.setter + def provider(self, provider: str) -> None: + self._provider = provider + @property def model(self) -> str: return self._model - @provider.setter - def provider(self, provider: str): - self._provider = provider - @model.setter - def model(self, model: str): + def model(self, model: str) -> None: self._model = model diff --git a/src/conductor/client/workflow/task/llm_tasks/utils/prompt.py b/src/conductor/client/workflow/task/llm_tasks/utils/prompt.py index 1964a22c..780a0c5d 100644 --- a/src/conductor/client/workflow/task/llm_tasks/utils/prompt.py +++ b/src/conductor/client/workflow/task/llm_tasks/utils/prompt.py @@ -7,21 +7,21 @@ class Prompt(object): attribute_map: ClassVar[Dict[str, str]] = {"name": "promptName", "variables": "promptVariables"} def __init__(self, name: str, variables: Dict[str, object]): - self._name = name - self._variables = variables + self._name: str = name + self._variables: Dict[str, object] = variables @property def name(self) -> str: return self._name - @property - def variables(self) -> str: - return self._variables - @name.setter - def name(self, name: str): + def name(self, name: str) -> None: self._name = name + @property + def variables(self) -> Dict[str, object]: + return self._variables + @variables.setter - def variables(self, variables: str): + def variables(self, variables: Dict[str, object]) -> None: self._variables = variables diff --git a/src/conductor/client/workflow/task/set_variable_task.py b/src/conductor/client/workflow/task/set_variable_task.py index 89e9046d..48db36f6 100644 --- a/src/conductor/client/workflow/task/set_variable_task.py +++ b/src/conductor/client/workflow/task/set_variable_task.py @@ -1,9 +1,7 @@ -from typing_extensions import Self - from conductor.client.workflow.task.task import TaskInterface from conductor.client.workflow.task.task_type import TaskType class SetVariableTask(TaskInterface): - def __init__(self, task_ref_name: str) -> Self: + def __init__(self, task_ref_name: str) -> None: super().__init__(task_reference_name=task_ref_name, task_type=TaskType.SET_VARIABLE) diff --git a/src/conductor/client/workflow/task/simple_task.py b/src/conductor/client/workflow/task/simple_task.py index f745de15..68df51fa 100644 --- a/src/conductor/client/workflow/task/simple_task.py +++ b/src/conductor/client/workflow/task/simple_task.py @@ -1,13 +1,11 @@ from typing import Dict -from typing_extensions import Self - from conductor.client.workflow.task.task import TaskInterface from conductor.client.workflow.task.task_type import TaskType class SimpleTask(TaskInterface): - def __init__(self, task_def_name: str, task_reference_name: str) -> Self: + def __init__(self, task_def_name: str, task_reference_name: str) -> None: super().__init__( task_reference_name=task_reference_name, task_type=TaskType.SIMPLE, diff --git a/src/conductor/client/workflow/task/start_workflow_task.py b/src/conductor/client/workflow/task/start_workflow_task.py index 96d7115b..d59f615e 100644 --- a/src/conductor/client/workflow/task/start_workflow_task.py +++ b/src/conductor/client/workflow/task/start_workflow_task.py @@ -1,6 +1,6 @@ from __future__ import annotations + from typing import Optional -from typing_extensions import Self from conductor.client.http.models.start_workflow_request import StartWorkflowRequest from conductor.client.workflow.task.task import TaskInterface @@ -14,7 +14,7 @@ def __init__( workflow_name: str, start_workflow_request: StartWorkflowRequest, version: Optional[int] = None, - ) -> Self: + ) -> None: super().__init__( task_reference_name=task_ref_name, task_type=TaskType.START_WORKFLOW, diff --git a/src/conductor/client/workflow/task/sub_workflow_task.py b/src/conductor/client/workflow/task/sub_workflow_task.py index 38af91d3..8919ec88 100644 --- a/src/conductor/client/workflow/task/sub_workflow_task.py +++ b/src/conductor/client/workflow/task/sub_workflow_task.py @@ -1,9 +1,8 @@ from __future__ import annotations + from copy import deepcopy from typing import Dict, Optional -from typing_extensions import Self - from conductor.client.http.models.sub_workflow_params import SubWorkflowParams from conductor.client.http.models.workflow_task import WorkflowTask from conductor.client.workflow.conductor_workflow import ConductorWorkflow @@ -18,7 +17,7 @@ def __init__( workflow_name: str, version: Optional[int] = None, task_to_domain_map: Optional[Dict[str, str]] = None, - ) -> Self: + ) -> None: super().__init__(task_reference_name=task_ref_name, task_type=TaskType.SUB_WORKFLOW) self._workflow_name = deepcopy(workflow_name) self._version = deepcopy(version) @@ -35,7 +34,7 @@ def to_workflow_task(self) -> WorkflowTask: class InlineSubWorkflowTask(TaskInterface): - def __init__(self, task_ref_name: str, workflow: ConductorWorkflow) -> Self: + def __init__(self, task_ref_name: str, workflow: ConductorWorkflow) -> None: super().__init__( task_reference_name=task_ref_name, task_type=TaskType.SUB_WORKFLOW, diff --git a/src/conductor/client/workflow/task/switch_task.py b/src/conductor/client/workflow/task/switch_task.py index 0b3816e6..12a54098 100644 --- a/src/conductor/client/workflow/task/switch_task.py +++ b/src/conductor/client/workflow/task/switch_task.py @@ -1,6 +1,8 @@ +from __future__ import annotations + from copy import deepcopy from enum import Enum -from typing import List +from typing import Dict, List, Optional from typing_extensions import Self @@ -21,13 +23,13 @@ class EvaluatorType(str, Enum): class SwitchTask(TaskInterface): def __init__( self, task_ref_name: str, case_expression: str, use_javascript: bool = False - ) -> Self: + ) -> None: super().__init__( task_reference_name=task_ref_name, task_type=TaskType.SWITCH, ) - self._default_case = None - self._decision_cases = {} + self._default_case: Optional[TaskInterface] = None + self._decision_cases: Dict[str, List[TaskInterface]] = {} self._expression = deepcopy(case_expression) self._use_javascript = deepcopy(use_javascript) diff --git a/src/conductor/client/workflow/task/task.py b/src/conductor/client/workflow/task/task.py index 1bd88038..d04ce27e 100644 --- a/src/conductor/client/workflow/task/task.py +++ b/src/conductor/client/workflow/task/task.py @@ -1,7 +1,7 @@ from __future__ import annotations from copy import deepcopy -from typing import Any, Dict, List, Union, Optional +from typing import Any, Dict, List, Optional, Union from typing_extensions import Self @@ -10,8 +10,8 @@ from conductor.client.workflow.task.task_type import TaskType -def get_task_interface_list_as_workflow_task_list(*tasks: Self) -> List[WorkflowTask]: - converted_tasks = [] +def get_task_interface_list_as_workflow_task_list(*tasks: TaskInterface) -> List[WorkflowTask]: + converted_tasks: List[WorkflowTask] = [] for task in tasks: wf_task = task.to_workflow_task() if isinstance(wf_task, list): @@ -33,17 +33,17 @@ def __init__( input_parameters: Optional[Dict[str, Any]] = None, cache_key: Optional[str] = None, cache_ttl_second: int = 0, - ) -> Self: - self.task_reference_name = task_reference_name - self.task_type = task_type - self.name = task_name or task_reference_name - self.description = description - self.optional = optional - self.input_parameters = input_parameters - self._cache_key = cache_key - self._cache_ttl_second = cache_ttl_second - self._expression = None - self._evaluator_type = None + ) -> None: + self.task_reference_name: str = task_reference_name + self.task_type: TaskType = task_type + self.name: str = task_name or task_reference_name + self.description: Optional[str] = description + self.optional: Optional[bool] = optional + self._input_parameters: Dict[str, Any] = input_parameters or {} + self._cache_key: Optional[str] = cache_key + self._cache_ttl_second: int = cache_ttl_second + self._expression: Optional[str] = None + self._evaluator_type: Optional[str] = None @property def task_reference_name(self) -> str: @@ -76,7 +76,7 @@ def name(self, name: str) -> None: self._name = name @property - def expression(self) -> str: + def expression(self) -> Optional[str]: return self._expression @expression.setter @@ -84,7 +84,7 @@ def expression(self, expression: str) -> None: self._expression = expression @property - def evaluator_type(self) -> str: + def evaluator_type(self) -> Optional[str]: return self._evaluator_type @evaluator_type.setter @@ -96,7 +96,7 @@ def cache(self, cache_key: str, cache_ttl_second: int): self._cache_ttl_second = cache_ttl_second @property - def description(self) -> str: + def description(self) -> Optional[str]: return self._description @description.setter @@ -106,7 +106,7 @@ def description(self, description: str) -> None: self._description = deepcopy(description) @property - def optional(self) -> bool: + def optional(self) -> Optional[bool]: return self._optional @optional.setter diff --git a/src/conductor/client/workflow/task/terminate_task.py b/src/conductor/client/workflow/task/terminate_task.py index 745ef7f5..c1682ac6 100644 --- a/src/conductor/client/workflow/task/terminate_task.py +++ b/src/conductor/client/workflow/task/terminate_task.py @@ -1,7 +1,5 @@ from enum import Enum -from typing_extensions import Self - from conductor.client.workflow.task.task import TaskInterface from conductor.client.workflow.task.task_type import TaskType @@ -16,7 +14,7 @@ class WorkflowStatus(str, Enum): class TerminateTask(TaskInterface): - def __init__(self, task_ref_name: str, status: WorkflowStatus, termination_reason: str) -> Self: + def __init__(self, task_ref_name: str, status: WorkflowStatus, termination_reason: str) -> None: super().__init__( task_reference_name=task_ref_name, task_type=TaskType.TERMINATE, diff --git a/src/conductor/client/workflow/task/wait_for_webhook_task.py b/src/conductor/client/workflow/task/wait_for_webhook_task.py index 7ca5b39e..9ea475d2 100644 --- a/src/conductor/client/workflow/task/wait_for_webhook_task.py +++ b/src/conductor/client/workflow/task/wait_for_webhook_task.py @@ -1,14 +1,14 @@ from __future__ import annotations + from abc import ABC from typing import Dict, Optional -from typing_extensions import Self from conductor.client.workflow.task.task import TaskInterface from conductor.client.workflow.task.task_type import TaskType class WaitForWebHookTask(TaskInterface, ABC): - def __init__(self, task_ref_name: str, matches: Dict[str, object]) -> Self: + def __init__(self, task_ref_name: str, matches: Dict[str, object]) -> None: """ matches: dictionary of matching payload that acts as correction between the incoming webhook payload and a running workflow task - amongst all the running workflows. diff --git a/src/conductor/client/workflow/task/wait_task.py b/src/conductor/client/workflow/task/wait_task.py index 63abe58d..f78f1d48 100644 --- a/src/conductor/client/workflow/task/wait_task.py +++ b/src/conductor/client/workflow/task/wait_task.py @@ -1,7 +1,7 @@ from __future__ import annotations + from abc import ABC from typing import Optional -from typing_extensions import Self from conductor.client.workflow.task.task import TaskInterface from conductor.client.workflow.task.task_type import TaskType @@ -13,7 +13,7 @@ def __init__( task_ref_name: str, wait_until: Optional[str] = None, wait_for_seconds: Optional[int] = None, - ) -> Self: + ) -> None: """ wait_until: Specific date/time to wait for e.g. 2023-12-25 05:25 PST wait_for_seconds: time to block for - e.g. specifying 60 will wait for 60 seconds @@ -30,12 +30,12 @@ def __init__( class WaitForDurationTask(WaitTask): - def __init__(self, task_ref_name: str, duration_time_seconds: int) -> Self: + def __init__(self, task_ref_name: str, duration_time_seconds: int) -> None: super().__init__(task_ref_name) self.input_parameters = {"duration": str(duration_time_seconds) + "s"} class WaitUntilTask(WaitTask): - def __init__(self, task_ref_name: str, date_time: str) -> Self: + def __init__(self, task_ref_name: str, date_time: str) -> None: super().__init__(task_ref_name) self.input_parameters = {"until": date_time} diff --git a/src/conductor/client/workflow_client.py b/src/conductor/client/workflow_client.py index db35014e..447a40db 100644 --- a/src/conductor/client/workflow_client.py +++ b/src/conductor/client/workflow_client.py @@ -1,19 +1,20 @@ from __future__ import annotations + from abc import ABC, abstractmethod -from typing import Optional, List, Dict +from typing import Dict, List, Optional -from conductor.client.http.models.workflow_run import WorkflowRun -from conductor.client.http.models.skip_task_request import SkipTaskRequest -from conductor.client.http.models.workflow_status import WorkflowStatus +from conductor.client.http.models.correlation_ids_search_request import CorrelationIdsSearchRequest +from conductor.client.http.models.rerun_workflow_request import RerunWorkflowRequest from conductor.client.http.models.scrollable_search_result_workflow_summary import ( ScrollableSearchResultWorkflowSummary, ) from conductor.client.http.models.signal_response import SignalResponse -from conductor.client.http.models.correlation_ids_search_request import CorrelationIdsSearchRequest -from conductor.client.http.models.rerun_workflow_request import RerunWorkflowRequest +from conductor.client.http.models.skip_task_request import SkipTaskRequest from conductor.client.http.models.start_workflow_request import StartWorkflowRequest from conductor.client.http.models.workflow import Workflow +from conductor.client.http.models.workflow_run import WorkflowRun from conductor.client.http.models.workflow_state_update import WorkflowStateUpdate +from conductor.client.http.models.workflow_status import WorkflowStatus from conductor.client.http.models.workflow_test_request import WorkflowTestRequest diff --git a/src/conductor/shared/automator/utils.py b/src/conductor/shared/automator/utils.py index 7c52e83e..cc6284c5 100644 --- a/src/conductor/shared/automator/utils.py +++ b/src/conductor/shared/automator/utils.py @@ -5,7 +5,7 @@ import inspect import logging import typing -from typing import List +from typing import Any, List, cast from dacite import from_dict from requests.structures import CaseInsensitiveDict @@ -28,7 +28,7 @@ def convert_from_dict_or_list(cls: type, data: typing.Union[dict, list]) -> obje converted = convert_from_dict(generic_types, val) val_list.append(converted) return val_list - return convert_from_dict(cls, data) + return convert_from_dict(cls, cast(dict, data)) def convert_from_dict(cls: type, data: dict) -> object: @@ -107,7 +107,9 @@ def convert_from_dict(cls: type, data: dict) -> object: return cls(**kwargs) -def get_value(typ: type, val: object) -> object: +def get_value(typ: type, val: Any) -> Any: + values: Any = None + if typ in simple_types: return val elif ( diff --git a/src/conductor/shared/event/configuration/queue.py b/src/conductor/shared/event/configuration/queue.py index cd87e47e..0ef9b794 100644 --- a/src/conductor/shared/event/configuration/queue.py +++ b/src/conductor/shared/event/configuration/queue.py @@ -9,9 +9,9 @@ class QueueConfiguration(ABC): WORKER_PRODUCER_KEY: ClassVar[str] = "producer" def __init__(self, queue_name: str, queue_type: str): - self.queue_name = queue_name - self.queue_type = queue_type - self.worker_configuration = {} + self.queue_name: str = queue_name + self.queue_type: str = queue_type + self.worker_configuration: Dict[str, QueueWorkerConfiguration] = {} def add_consumer(self, worker_configuration: QueueWorkerConfiguration) -> None: self.worker_configuration[self.WORKER_CONSUMER_KEY] = worker_configuration diff --git a/src/conductor/shared/worker/__init__.py b/src/conductor/shared/worker/__init__.py index 5dd1bdba..87e15bc8 100644 --- a/src/conductor/shared/worker/__init__.py +++ b/src/conductor/shared/worker/__init__.py @@ -1,12 +1,12 @@ from conductor.shared.worker.exception import NonRetryableException +from conductor.shared.worker.task_definition_helper import ( + apply_task_options_to_task_def, +) from conductor.shared.worker.task_options import ( TaskOptions, get_task_options, task_options, ) -from conductor.shared.worker.task_definition_helper import ( - apply_task_options_to_task_def, -) __all__ = [ "NonRetryableException", diff --git a/src/conductor/shared/worker/task_options.py b/src/conductor/shared/worker/task_options.py index c3e45e55..5f010253 100644 --- a/src/conductor/shared/worker/task_options.py +++ b/src/conductor/shared/worker/task_options.py @@ -3,7 +3,6 @@ import functools from typing import Callable, Optional - _TASK_OPTIONS_ATTR = "_conductor_task_options" diff --git a/tests/unit/orkes/test_async_authorization_client.py b/tests/unit/orkes/test_async_authorization_client.py index 1995f41c..2700da3c 100644 --- a/tests/unit/orkes/test_async_authorization_client.py +++ b/tests/unit/orkes/test_async_authorization_client.py @@ -264,7 +264,7 @@ async def test_get_user_with_empty_string(mocker, authorization_client, conducto mock = mocker.patch.object(UserResourceApi, "get_user") mock.return_value = conductor_user_adapter await authorization_client.get_user("") - mock.assert_called_with(None) + mock.assert_called_with(None, _request_timeout=None, _request_auth=None, _content_type=None, _headers=None, _host_index=0) @pytest.mark.asyncio @@ -279,7 +279,7 @@ async def test_delete_user_with_empty_string(mocker, authorization_client): from conductor.asyncio_client.http.api import UserResourceApi mock = mocker.patch.object(UserResourceApi, "delete_user") await authorization_client.delete_user("") - mock.assert_called_with(None) + mock.assert_called_with(None, _request_timeout=None, _request_auth=None, _content_type=None, _headers=None, _host_index=0) @pytest.mark.asyncio @@ -319,7 +319,7 @@ async def test_upsert_user_with_empty_string(mocker, authorization_client, condu upsert_req = UpsertUserRequestAdapter(name=USER_NAME, roles=["ADMIN"]) mock.return_value = conductor_user_adapter await authorization_client.upsert_user("", upsert_req) - mock.assert_called_with(None, upsert_req) + mock.assert_called_with(None, upsert_req, _request_timeout=None, _request_auth=None, _content_type=None, _headers=None, _host_index=0) @pytest.mark.asyncio @@ -517,7 +517,7 @@ async def test_get_granted_permissions_for_user_with_empty_string(mocker, author mock = mocker.patch.object(UserResourceApi, "get_granted_permissions") mock.return_value = {"grantedAccess": []} await authorization_client.get_granted_permissions_for_user("") - mock.assert_called_with(None) + mock.assert_called_with(None, _request_timeout=None, _request_auth=None, _content_type=None, _headers=None, _host_index=0) @pytest.mark.asyncio @@ -532,7 +532,7 @@ async def test_create_access_key_empty_string_converts_to_none(mocker, authoriza "secret": "test-secret", } await authorization_client.create_access_key("") - mock.assert_called_with(None) + mock.assert_called_with(None, _request_timeout=None, _request_auth=None, _content_type=None, _headers=None, _host_index=0) @pytest.mark.asyncio @@ -545,7 +545,7 @@ async def test_add_role_to_application_user_empty_strings_convert_to_none( mock = mocker.patch.object(ApplicationResourceApi, "add_role_to_application_user") await authorization_client.add_role_to_application_user("", "") - mock.assert_called_with(None, None) + mock.assert_called_with(None, None, _request_timeout=None, _request_auth=None, _content_type=None, _headers=None, _host_index=0) @pytest.mark.asyncio @@ -556,7 +556,7 @@ async def test_delete_access_key_empty_strings_convert_to_none(mocker, authoriza mock = mocker.patch.object(ApplicationResourceApi, "delete_access_key") await authorization_client.delete_access_key("", "") - mock.assert_called_with(None, None) + mock.assert_called_with(None, None, _request_timeout=None, _request_auth=None, _content_type=None, _headers=None, _host_index=0) @pytest.mark.asyncio @@ -569,7 +569,7 @@ async def test_remove_role_from_application_user_empty_strings_convert_to_none( mock = mocker.patch.object(ApplicationResourceApi, "remove_role_from_application_user") await authorization_client.remove_role_from_application_user("", "") - mock.assert_called_with(None, None) + mock.assert_called_with(None, None, _request_timeout=None, _request_auth=None, _content_type=None, _headers=None, _host_index=0) @pytest.mark.asyncio @@ -583,7 +583,7 @@ async def test_get_app_by_access_key_id_empty_string_converts_to_none( mock = mocker.patch.object(ApplicationResourceApi, "get_app_by_access_key_id") mock.return_value = extended_conductor_application_adapter await authorization_client.get_app_by_access_key_id("") - mock.assert_called_with(None) + mock.assert_called_with(None, _request_timeout=None, _request_auth=None, _content_type=None, _headers=None, _host_index=0) @pytest.mark.asyncio @@ -595,7 +595,7 @@ async def test_get_access_keys_empty_string_converts_to_none(mocker, authorizati mock = mocker.patch.object(ApplicationResourceApi, "get_access_keys") mock.return_value = [] await authorization_client.get_access_keys("") - mock.assert_called_with(None) + mock.assert_called_with(None, _request_timeout=None, _request_auth=None, _content_type=None, _headers=None, _host_index=0) @pytest.mark.asyncio @@ -611,7 +611,7 @@ async def test_toggle_access_key_status_empty_strings_convert_to_none(mocker, au "status": "INACTIVE", } await authorization_client.toggle_access_key_status("", "") - mock.assert_called_with(None, None) + mock.assert_called_with(None, None, _request_timeout=None, _request_auth=None, _content_type=None, _headers=None, _host_index=0) @pytest.mark.asyncio @@ -623,7 +623,7 @@ async def test_get_tags_for_application_empty_string_converts_to_none(mocker, au mock = mocker.patch.object(ApplicationResourceApi, "get_tags_for_application") mock.return_value = [] await authorization_client.get_application_tags("") - mock.assert_called_with(None) + mock.assert_called_with(None, _request_timeout=None, _request_auth=None, _content_type=None, _headers=None, _host_index=0) @pytest.mark.asyncio @@ -636,4 +636,4 @@ async def test_delete_tag_for_application_empty_strings_convert_to_none( mock = mocker.patch.object(ApplicationResourceApi, "delete_tag_for_application") await authorization_client.delete_application_tags([], "") - mock.assert_called_with(None, None) + mock.assert_called_with(None, None, _request_timeout=None, _request_auth=None, _content_type=None, _headers=None, _host_index=0) diff --git a/tests/unit/workflow/test_async_workflow_executor.py b/tests/unit/workflow/test_async_workflow_executor.py index 12f0d0af..70f1384c 100644 --- a/tests/unit/workflow/test_async_workflow_executor.py +++ b/tests/unit/workflow/test_async_workflow_executor.py @@ -341,11 +341,7 @@ async def test_search_with_defaults(workflow_executor, mock_workflow_client): result = await workflow_executor.search() mock_workflow_client.search.assert_called_once_with( - start=None, - size=None, - free_text=None, - query=None, - skip_cache=None + start=0, size=100, free_text='*', query=None, skip_cache=None ) assert result == mock_search_result