conductor-python 1.2.1__tar.gz → 1.2.2__tar.gz

{conductor_python-1.2.1 → conductor_python-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: conductor-python
-Version: 1.2.1
+Version: 1.2.2
 Summary: Python SDK for working with https://github.com/conductor-oss/conductor
 License: Apache-2.0
 Author: Orkes

{conductor_python-1.2.1 → conductor_python-1.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "conductor-python"
-version = "1.2.1"
+version = "1.2.2"
 description = "Python SDK for working with https://github.com/conductor-oss/conductor"
 authors = ["Orkes <developers@orkes.io>"]
 license = "Apache-2.0"

conductor_python-1.2.2/src/conductor/asyncio_client/adapters/api/application_resource_api.py

@@ -0,0 +1,103 @@
+from typing import List
+
+from pydantic import StrictStr
+
+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,
+    ):
+        # 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=id, *args, **kwargs)
+
+    async def add_role_to_application_user(
+        self, application_id: StrictStr, role: StrictStr, *args, **kwargs
+    ):
+        # 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=application_id, role=role, *args, **kwargs
+        )
+
+    async def delete_access_key(
+        self,
+        application_id: StrictStr,
+        key_id: StrictStr,
+        *args,
+        **kwargs,
+    ):
+        # 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=application_id, key_id=key_id, *args, **kwargs
+        )
+
+    async def remove_role_from_application_user(
+        self,
+        application_id: StrictStr,
+        role: StrictStr,
+        *args,
+        **kwargs,
+    ):
+        # 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=application_id, role=role, *args, **kwargs
+        )
+
+    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
+        if not access_key_id:
+            access_key_id = None
+        return await super().get_app_by_access_key_id(access_key_id=access_key_id, *args, **kwargs)
+
+    async def get_access_keys(self, id: StrictStr, *args, **kwargs):
+        # Convert empty application id to None to prevent sending invalid data to server
+        if not id:
+            id = None
+        return await super().get_access_keys(id=id, *args, **kwargs)
+
+    async def toggle_access_key_status(
+        self, application_id: StrictStr, key_id: StrictStr, *args, **kwargs
+    ):
+        # 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=application_id, key_id=key_id, *args, **kwargs
+        )
+
+    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(id=application_id, *args, **kwargs)
+
+    async def delete_tag_for_application(
+        self, id: StrictStr, tag: List[Tag], *args, **kwargs
+    ) -> 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=id, tag=tag, *args, **kwargs)

conductor_python-1.2.2/src/conductor/asyncio_client/adapters/api/user_resource_api.py

@@ -0,0 +1,51 @@
+from pydantic import StrictStr
+
+from conductor.asyncio_client.http.api import UserResourceApi
+from conductor.asyncio_client.adapters.models import UpsertUserRequestAdapter as UpsertUserRequest
+
+
+class UserResourceApiAdapter(UserResourceApi):
+    async def get_granted_permissions(
+        self,
+        user_id: StrictStr,
+        *args,
+        **kwargs,
+    ) -> 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=user_id, *args, **kwargs)
+
+    async def get_user(
+        self,
+        id: StrictStr,
+        *args,
+        **kwargs,
+    ) -> object:
+        # Convert empty user id to None to prevent sending invalid data to server
+        if not id:
+            id = None
+        return await super().get_user(id=id, *args, **kwargs)
+
+    async def upsert_user(
+        self,
+        id: StrictStr,
+        upsert_user_request: UpsertUserRequest,
+        *args,
+        **kwargs,
+    ) -> object:
+        # Convert empty user id to None to prevent sending invalid data to server
+        if not id:
+            id = None
+        return await super().upsert_user(id=id, upsert_user_request=upsert_user_request, *args, **kwargs)
+
+    async def delete_user(
+        self,
+        id: StrictStr,
+        *args,
+        **kwargs,
+    ) -> 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=id, *args, **kwargs)

conductor_python-1.2.2/src/conductor/asyncio_client/adapters/api_client_adapter.py

@@ -0,0 +1,308 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import re
+import time
+from typing import Dict, Optional
+
+from conductor.asyncio_client.adapters.models import GenerateTokenRequest
+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.exceptions import ApiException
+from conductor.client.exceptions.auth_401_policy import Auth401Policy, Auth401Handler
+
+logger = logging.getLogger(Configuration.get_logging_formatted_name(__name__))
+
+
+class ApiClientAdapter(ApiClient):
+    def __init__(
+        self, configuration=None, header_name=None, header_value=None, cookie=None
+    ):
+        self._token_lock = asyncio.Lock()
+        self.configuration = configuration or Configuration()
+
+        self.rest_client = rest.RESTClientObject(self.configuration)
+        self.default_headers = {}
+        if header_name is not None:
+            self.default_headers[header_name] = header_value
+        self.cookie = cookie
+
+        # Initialize 401 policy handler
+        auth_401_policy = Auth401Policy(
+            max_attempts=self.configuration.auth_401_max_attempts,
+            base_delay_ms=self.configuration.auth_401_base_delay_ms,
+            max_delay_ms=self.configuration.auth_401_max_delay_ms,
+            jitter_percent=self.configuration.auth_401_jitter_percent,
+            stop_behavior=self.configuration.auth_401_stop_behavior,
+        )
+        self.auth_401_handler = Auth401Handler(auth_401_policy)
+
+    async def call_api(
+        self,
+        method,
+        url,
+        header_params=None,
+        body=None,
+        post_params=None,
+        _request_timeout=None,
+    ) -> rest.RESTResponse:
+        """Makes the HTTP request (synchronous)
+        :param method: Method to call.
+        :param url: Path to method endpoint.
+        :param header_params: Header parameters to be
+            placed in the request header.
+        :param body: Request body.
+        :param post_params dict: Request post form parameters,
+            for `application/x-www-form-urlencoded`, `multipart/form-data`.
+        :param _request_timeout: timeout setting for this request.
+        :return: RESTResponse
+        """
+
+        try:
+            logger.debug(
+                "HTTP request method: %s; url: %s; header_params: %s",
+                method,
+                url,
+                header_params,
+            )
+            response_data = await self.rest_client.request(
+                method,
+                url,
+                headers=header_params,
+                body=body,
+                post_params=post_params,
+                _request_timeout=_request_timeout,
+            )
+
+            # Handle 401 retries with policy-based logic
+            resource_path = url.replace(self.configuration.host, "")
+
+            # Loop to handle multiple 401 retries
+            while (
+                response_data.status == 401  # noqa: PLR2004 (Unauthorized status code)
+                and url != self.configuration.host + "/token"
+            ):
+                # Check if this is an auth-dependent call that should trigger 401 policy
+                if self.auth_401_handler.policy.is_auth_dependent_call(
+                    resource_path, method
+                ):
+                    # Handle 401 with policy (exponential backoff, max attempts, etc.)
+                    result = self.auth_401_handler.handle_401_error(
+                        resource_path=resource_path,
+                        method=method,
+                        status_code=401,
+                        error_code=None,
+                    )
+
+                    if result["should_retry"]:
+                        # Apply exponential backoff delay
+                        if result["delay_seconds"] > 0:
+                            logger.info(
+                                "401 error on %s %s - waiting %.2fs before retry (attempt %d/%d)",
+                                method,
+                                url,
+                                result["delay_seconds"],
+                                result["attempt_count"],
+                                result["max_attempts"],
+                            )
+                            await asyncio.sleep(result["delay_seconds"])
+
+                        # Try to refresh token and retry
+                        async with self._token_lock:
+                            # Check if token was already refreshed by another coroutine
+                            # to avoid race condition where multiple concurrent 401s
+                            # trigger redundant token refreshes
+                            token_expired = (
+                                self.configuration.token_update_time > 0
+                                and time.time()
+                                >= self.configuration.token_update_time
+                                + self.configuration.auth_token_ttl_sec
+                            )
+                            invalid_token = (
+                                not self.configuration._http_config.api_key.get(
+                                    "api_key"
+                                )
+                            )
+
+                            if invalid_token or token_expired:
+                                token = await self.refresh_authorization_token()
+                            else:
+                                token = self.configuration._http_config.api_key[
+                                    "api_key"
+                                ]
+                            if header_params is None:
+                                header_params = {}
+                            header_params["X-Authorization"] = token
+
+                        # Make the retry request outside the lock to avoid blocking other coroutines
+                        response_data = await self.rest_client.request(
+                            method,
+                            url,
+                            headers=header_params,
+                            body=body,
+                            post_params=post_params,
+                            _request_timeout=_request_timeout,
+                        )
+                    else:
+                        # Max attempts reached - log error and break
+                        logger.error(
+                            "401 error on %s %s - max attempts (%d) reached, stopping worker",
+                            method,
+                            url,
+                            result["max_attempts"],
+                        )
+                        break
+                else:
+                    # Non-auth-dependent call with 401 - use original behavior (single retry)
+                    logger.warning(
+                        "HTTP response from: %s; status code: 401 - obtaining new token",
+                        url,
+                    )
+                    async with self._token_lock:
+                        # The lock is intentionally broad (covers the whole block including the token state)
+                        # to avoid race conditions: without it, other coroutines could mis-evaluate
+                        # token state during a context switch and trigger redundant refreshes
+                        token_expired = (
+                            self.configuration.token_update_time > 0
+                            and time.time()
+                            >= self.configuration.token_update_time
+                            + self.configuration.auth_token_ttl_sec
+                        )
+                        invalid_token = not self.configuration._http_config.api_key.get(
+                            "api_key"
+                        )
+
+                        if invalid_token or token_expired:
+                            token = await self.refresh_authorization_token()
+                        else:
+                            token = self.configuration._http_config.api_key["api_key"]
+                        if header_params is None:
+                            header_params = {}
+                        header_params["X-Authorization"] = token
+                        response_data = await self.rest_client.request(
+                            method,
+                            url,
+                            headers=header_params,
+                            body=body,
+                            post_params=post_params,
+                            _request_timeout=_request_timeout,
+                        )
+                    # Break after single retry for non-auth-dependent calls
+                    break
+
+            # Record successful call to reset 401 attempt counters
+            if response_data.status != 401:
+                self.auth_401_handler.record_successful_call(resource_path)
+
+        except ApiException as e:
+            logger.error(
+                "HTTP request failed url: %s status: %s; reason: %s",
+                url,
+                e.status,
+                e.reason,
+            )
+            raise e
+
+        return response_data
+
+    def response_deserialize(
+        self,
+        response_data: rest.RESTResponse,
+        response_types_map: Optional[Dict[str, ApiResponseT]] = None,
+    ) -> ApiResponse[ApiResponseT]:
+        """Deserializes response into an object.
+        :param response_data: RESTResponse object to be deserialized.
+        :param response_types_map: dict of response types.
+        :return: ApiResponse
+        """
+
+        msg = "RESTResponse.read() must be called before passing it to response_deserialize()"
+        assert response_data.data is not None, msg
+
+        response_type = response_types_map.get(str(response_data.status), None)
+        if (
+            not response_type
+            and isinstance(response_data.status, int)
+            and 100 <= response_data.status <= 599  # noqa: PLR2004
+        ):
+            # if not found, look for '1XX', '2XX', etc.
+            response_type = response_types_map.get(
+                str(response_data.status)[0] + "XX", None
+            )
+
+        # deserialize response data
+        response_text = None
+        return_data = None
+        try:
+            if response_type == "bytearray":
+                return_data = response_data.data
+            elif response_type == "file":
+                return_data = self.__deserialize_file(response_data)
+            elif response_type is not None:
+                match = None
+                content_type = response_data.getheader("content-type")
+                if content_type is not None:
+                    match = re.search(r"charset=([a-zA-Z\-\d]+)[\s;]?", content_type)
+                encoding = match.group(1) if match else "utf-8"
+                response_text = response_data.data.decode(encoding)
+                return_data = self.deserialize(
+                    response_text, response_type, content_type
+                )
+        finally:
+            if not 200 <= response_data.status <= 299:  #  noqa: PLR2004
+                logger.error(
+                    "Unexpected response status code: %s", response_data.status
+                )
+                raise ApiException.from_response(
+                    http_resp=response_data,
+                    body=response_text,
+                    data=return_data,
+                )
+
+        return ApiResponse(
+            status_code=response_data.status,
+            data=return_data,
+            headers=response_data.getheaders(),
+            raw_data=response_data.data,
+        )
+
+    async def refresh_authorization_token(self):
+        obtain_new_token_response = await self.obtain_new_token()
+        token = obtain_new_token_response.get("token")
+        self.configuration._http_config.api_key["api_key"] = token
+        self.configuration.token_update_time = time.time()
+        logger.debug("New auth token been set")
+        return token
+
+    async def obtain_new_token(self):
+        body = GenerateTokenRequest(
+            key_id=self.configuration.auth_key,
+            key_secret=self.configuration.auth_secret,
+        )
+        _param = self.param_serialize(
+            method="POST",
+            resource_path="/token",
+            body=body.to_dict(),
+        )
+        response = await self.call_api(
+            *_param,
+        )
+        await response.read()
+        return json.loads(response.data)
+
+    @classmethod
+    def get_default(cls):
+        """Return new instance of ApiClient.
+        This method returns newly created, based on default constructor,
+        object of ApiClient class or returns a copy of default
+        ApiClient.
+        :return: The ApiClient object.
+        """
+        if cls._default is None:
+            cls._default = ApiClientAdapter()
+        return cls._default

{conductor_python-1.2.1 → conductor_python-1.2.2}/src/conductor/asyncio_client/adapters/models/conductor_user_adapter.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import Any, Dict, List, Optional
 
+from pydantic import Field, StrictBool
 from typing_extensions import Self
 
 from conductor.asyncio_client.http.models import ConductorUser
@@ -10,6 +11,9 @@ from conductor.asyncio_client.http.models import ConductorUser
 class ConductorUserAdapter(ConductorUser):
     groups: Optional[List["GroupAdapter"]] = None
     roles: Optional[List["RoleAdapter"]] = None
+    orkes_app: Optional[StrictBool] = Field(default=None, alias="orkesApp")
+    orkes_api_gateway: Optional[StrictBool] = Field(default=None, alias="orkesApiGateway")
+    contact_information: Optional[Dict[Any, str]] = Field(default=None, alias="contactInformation")
 
     @classmethod
     def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
@@ -39,12 +43,19 @@ class ConductorUserAdapter(ConductorUser):
                     else None
                 ),
                 "uuid": obj.get("uuid"),
+                "orkesApp": obj.get("orkesApp"),
+                "orkesApiGateway": obj.get("orkesApiGateway"),
+                "contactInformation": obj.get("contactInformation"),
             }
         )
         return _obj
 
 
-from conductor.asyncio_client.adapters.models.group_adapter import GroupAdapter  # noqa: E402
-from conductor.asyncio_client.adapters.models.role_adapter import RoleAdapter  # noqa: E402
+from conductor.asyncio_client.adapters.models.group_adapter import (  # noqa: E402
+    GroupAdapter,
+)
+from conductor.asyncio_client.adapters.models.role_adapter import (  # noqa: E402
+    RoleAdapter,
+)
 
 ConductorUserAdapter.model_rebuild(raise_errors=False)

{conductor_python-1.2.1 → conductor_python-1.2.2}/src/conductor/asyncio_client/adapters/models/integration_def_form_field_adapter.py

@@ -97,6 +97,9 @@ class IntegrationDefFormFieldAdapter(IntegrationDefFormField):
                 "oAuth2AuthCode",
                 "oAuth2TokenExpiresAt",
                 "oAuth2RedirectUri",
+                "oAuth2Scope",
+                "oAuth2Provider",
+                "oAuth2AccessToken",
             ]
         ):
             raise ValueError(

{conductor_python-1.2.1 → conductor_python-1.2.2}/src/conductor/asyncio_client/automator/task_handler.py

@@ -30,14 +30,13 @@ if not _mp_fork_set:
         logger.error(
             "Error when setting multiprocessing.set_start_method - maybe the context is set %s",
             e.args,
-
         )
     if platform == "darwin":
         os.environ["no_proxy"] = "*"
 
 
 def register_decorated_fn(
-    name: str, poll_interval: int, domain: str, worker_id: str, func
+    name: str, poll_interval: int, domain: str, worker_id: str, func, task_options=None
 ):
     logger.info("Registering decorated function: %s", name)
     _decorated_functions[(name, domain)] = {
@@ -45,6 +44,7 @@ def register_decorated_fn(
         "poll_interval": poll_interval,
         "domain": domain,
         "worker_id": worker_id,
+        "task_options": task_options,
     }
 
 

{conductor_python-1.2.1 → conductor_python-1.2.2}/src/conductor/asyncio_client/automator/task_runner.py

@@ -64,6 +64,13 @@ class AsyncTaskRunner:
         )
 
         while True:
+            # Check if worker should stop due to 401 policy
+            if (hasattr(self.task_client, 'api_client') and 
+                hasattr(self.task_client.api_client, 'auth_401_handler') and 
+                hasattr(self.task_client.api_client.auth_401_handler, 'is_worker_stopped') and 
+                self.task_client.api_client.auth_401_handler.is_worker_stopped()):
+                logger.error("Worker stopped due to persistent 401 authentication failures")
+                break
             await self.run_once()
 
     async def run_once(self) -> None:

{conductor_python-1.2.1 → conductor_python-1.2.2}/src/conductor/asyncio_client/configuration/configuration.py

@@ -33,6 +33,15 @@ class Configuration:
     CONDUCTOR_WORKER_<TASK_TYPE>_POLLING_INTERVAL: Task-specific polling interval
     CONDUCTOR_WORKER_<TASK_TYPE>_DOMAIN: Task-specific domain
 
+    Authentication Retry Policy (401 Handling):
+    -------------------------------------------
+    CONDUCTOR_AUTH_401_MAX_ATTEMPTS: Maximum retry attempts per endpoint (default: 6)
+    CONDUCTOR_AUTH_401_BASE_DELAY_MS: Base delay in milliseconds (default: 1000.0)
+    CONDUCTOR_AUTH_401_MAX_DELAY_MS: Maximum delay cap in milliseconds (default: 60000.0)
+    CONDUCTOR_AUTH_401_JITTER_PERCENT: Random jitter percentage 0.0-1.0 (default: 0.2)
+    CONDUCTOR_AUTH_401_STOP_BEHAVIOR: Behavior after max attempts: 'stop_worker' or 'continue' (default: 'stop_worker')
+
+    
     Example:
     --------
     ```python
@@ -82,6 +91,12 @@ class Configuration:
         verify_ssl: Optional[bool] = None,
         proxy: Optional[str] = None,
         proxy_headers: Optional[Dict[str, str]] = None,
+        # 401-specific configuration
+        auth_401_max_attempts: Optional[int] = None,
+        auth_401_base_delay_ms: Optional[float] = None,
+        auth_401_max_delay_ms: Optional[float] = None,
+        auth_401_jitter_percent: Optional[float] = None,
+        auth_401_stop_behavior: Optional[str] = None,
         **kwargs: Any,
     ):
         """
@@ -139,7 +154,7 @@ class Configuration:
         self.polling_interval = polling_interval or self._get_env_int(
             "CONDUCTOR_WORKER_POLL_INTERVAL", 100
         )
-        self.domain = domain or os.getenv("CONDUCTOR_WORKER_DOMAIN", "default_domain")
+        self.domain = domain or os.getenv("CONDUCTOR_WORKER_DOMAIN", None)
         self.polling_interval_seconds = polling_interval_seconds or self._get_env_int(
             "CONDUCTOR_WORKER_POLL_INTERVAL_SECONDS", 0
         )
@@ -188,7 +203,7 @@ class Configuration:
             "ca_cert_data": ca_cert_data or os.getenv("CONDUCTOR_SSL_CA_CERT_DATA"),
             "debug": debug,
         }
-        
+
         # Add SSL parameters if they exist in HttpConfiguration
         if cert_file or os.getenv("CONDUCTOR_CERT_FILE"):
             http_config_kwargs["cert_file"] = cert_file or os.getenv("CONDUCTOR_CERT_FILE")
@@ -214,6 +229,12 @@ class Configuration:
         if self.proxy_headers:
             self._http_config.proxy_headers = self.proxy_headers
 
+        # Set proxy configuration on the HTTP config
+        if self.proxy:
+            self._http_config.proxy = self.proxy
+        if self.proxy_headers:
+            self._http_config.proxy_headers = self.proxy_headers
+
         # Debug switch and logging setup
         self.__debug = debug
         if self.__debug:
@@ -233,6 +254,23 @@ class Configuration:
         # Orkes Conductor auth token properties
         self.token_update_time = 0
         self.auth_token_ttl_sec = auth_token_ttl_min * 60
+        
+        # 401-specific configuration
+        self.auth_401_max_attempts = auth_401_max_attempts or self._get_env_int(
+            "CONDUCTOR_AUTH_401_MAX_ATTEMPTS", 6
+        )
+        self.auth_401_base_delay_ms = auth_401_base_delay_ms or self._get_env_float(
+            "CONDUCTOR_AUTH_401_BASE_DELAY_MS", 1000.0
+        )
+        self.auth_401_max_delay_ms = auth_401_max_delay_ms or self._get_env_float(
+            "CONDUCTOR_AUTH_401_MAX_DELAY_MS", 60000.0
+        )
+        self.auth_401_jitter_percent = auth_401_jitter_percent or self._get_env_float(
+            "CONDUCTOR_AUTH_401_JITTER_PERCENT", 0.2
+        )
+        self.auth_401_stop_behavior = auth_401_stop_behavior or os.getenv(
+            "CONDUCTOR_AUTH_401_STOP_BEHAVIOR", "stop_worker"
+        )
 
     def _get_env_float(self, env_var: str, default: float) -> float:
         """Get float value from environment variable with default fallback."""