conductor-python 1.4.0__tar.gz → 1.5.0__tar.gz

{conductor_python-1.4.0 → conductor_python-1.5.0}/PKG-INFO

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

{conductor_python-1.4.0 → conductor_python-1.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "conductor-python"
-version = "1.4.0" # Do not change! Placeholder. Real version injected during build (edited) 
+version = "1.5.0" # Do not change! Placeholder. Real version injected during build (edited) 
 description = "Python SDK for working with https://github.com/conductor-oss/conductor"
 authors = ["Orkes <developers@orkes.io>"]
 license = "Apache-2.0"

{conductor_python-1.4.0 → conductor_python-1.5.0}/src/conductor/client/automator/task_handler.py

@@ -4,10 +4,11 @@ import importlib
 import inspect
 import logging
 import os
+import pickle
 import signal
 import threading
 import time
-from multiprocessing import Process, freeze_support, Queue, set_start_method
+from multiprocessing import Process, freeze_support, Queue, set_start_method, get_start_method
 from sys import platform
 from typing import List, Optional, Any, Dict
 
@@ -37,12 +38,25 @@ _VALID_MP_START_METHODS = {"spawn", "fork", "forkserver"}
 _mp_fork_set = False
 if not _mp_fork_set:
     try:
-        # The prometheus_client library holds a module-level threading lock;
-        # forking while that lock is held causes a deadlock in child processes.
-        # Set CONDUCTOR_MP_START_METHOD=spawn to avoid this if you hit the
-        # deadlock.  Default is fork for backward compatibility (spawn requires
-        # all Process arguments to be picklable).
-        _default_method = "spawn" if platform == "win32" else "fork"
+        # Default start method: "spawn" on every platform.
+        #
+        # fork() is fundamentally unsafe in a process that holds native
+        # framework state or non-main threads:
+        #   - macOS: Apple frameworks (CFNetwork, Security, libdispatch) may
+        #     SIGSEGV in forked children, producing silently-restarting worker
+        #     processes with exitcode=-11. CPython switched its own macOS
+        #     default to spawn in 3.8 for the same reason (bpo-33725).
+        #   - all POSIX: forking while another thread holds a lock (e.g. the
+        #     prometheus_client module-level lock, or the TaskHandler monitor
+        #     thread restarting a worker) leaves that lock permanently held in
+        #     the child -> silent deadlock.
+        # Workers (including the @worker_task decorator path) are pickle-safe,
+        # so spawn works everywhere. Deployments that rely on fork's
+        # copy-on-write inheritance can opt back in with
+        # CONDUCTOR_MP_START_METHOD=fork (re-exposing the hazards above).
+        # NOTE: spawn requires the standard `if __name__ == "__main__":` guard
+        # in the entrypoint script.
+        _default_method = "spawn"
         _method = os.environ.get("CONDUCTOR_MP_START_METHOD", "").strip().lower() or _default_method
         if _method not in _VALID_MP_START_METHODS:
             logger.warning(
@@ -341,8 +355,26 @@ class TaskHandler:
         logger.info("Starting worker processes...")
         freeze_support()
         self._monitor_stop_event.clear()
-        self.__start_task_runner_processes()
-        self.__start_metrics_provider_process()
+        try:
+            self.__start_task_runner_processes()
+            self.__start_metrics_provider_process()
+        except (TypeError, pickle.PicklingError, AttributeError) as e:
+            # Under the 'spawn'/'forkserver' start methods, Process arguments
+            # are pickled at start(); unpicklable state fails here. Clean up
+            # everything already started - otherwise the non-daemon logger
+            # subprocess keeps the interpreter alive forever after the
+            # exception (observed as a hang after "cannot pickle
+            # '_thread.lock' object").
+            logger.error(
+                "Failed to start worker processes with start method %r: %s. "
+                "Workers must be defined at module level (not nested inside "
+                "functions), and configuration, metrics_settings and "
+                "event_listeners must be picklable. "
+                "See https://github.com/conductor-oss/conductor-python/issues/264",
+                get_start_method(allow_none=True), e,
+            )
+            self.stop_processes()
+            raise
         self.__start_monitor_thread()
         logger.info("Started all processes")
 
@@ -445,6 +477,21 @@ class TaskHandler:
                 worker = self.workers[i] if i < len(self.workers) else None
                 worker_name = worker.get_task_definition_name() if worker is not None else f"worker[{i}]"
                 logger.warning("Worker process exited (worker=%s, pid=%s, exitcode=%s)", worker_name, process.pid, exitcode)
+                if exitcode < 0:
+                    # Negative exitcode == killed by signal (e.g. -11 is
+                    # SIGSEGV). Under the 'fork' start method this is the
+                    # classic symptom of fork-unsafe native libraries in the
+                    # parent (Apple frameworks on macOS, numpy/Accelerate,
+                    # grpc, ...).
+                    logger.warning(
+                        "Worker process %s was killed by signal %s. If this "
+                        "repeats on every restart, the process is likely "
+                        "crashing at startup: use the 'spawn' start method "
+                        "(CONDUCTOR_MP_START_METHOD=spawn, the default) and "
+                        "set PYTHONFAULTHANDLER=1 to capture the crashing "
+                        "stack trace.",
+                        worker_name, -exitcode,
+                    )
                 if not self.restart_on_failure:
                     continue
                 self.__restart_worker_process(i)

{conductor_python-1.4.0 → conductor_python-1.5.0}/src/conductor/client/worker/worker.py

@@ -2,8 +2,10 @@ from __future__ import annotations
 import asyncio
 import atexit
 import dataclasses
+import importlib
 import inspect
 import logging
+import sys
 import threading
 import time
 import traceback
@@ -275,6 +277,79 @@ class BackgroundEventLoop:
         logger.debug("Background event loop stopped")
 
 
+class _ExecuteFunctionReference:
+    """Pickle surrogate for functions whose module-level name was rebound.
+
+    The ``@worker_task`` decorator registers the *original* function but rebinds
+    the module-level name to its wrapper. Standard pickle-by-reference then
+    fails with ``PicklingError: it's not the same object as module.name`` when
+    the ``spawn``/``forkserver`` start methods pickle Process arguments
+    (GitHub issues #264/#271).
+
+    Instead of the raw function we pickle ``(module, qualname, unwrap_depth)``
+    and re-resolve in the child process: import the module, walk the qualname,
+    then follow ``__wrapped__`` (set by ``functools.wraps``) ``unwrap_depth``
+    times to get back to the registered function.
+    """
+
+    __slots__ = ("module_name", "qualname", "unwrap_depth")
+
+    def __init__(self, module_name: str, qualname: str, unwrap_depth: int):
+        self.module_name = module_name
+        self.qualname = qualname
+        self.unwrap_depth = unwrap_depth
+
+    def resolve(self) -> Callable:
+        module = importlib.import_module(self.module_name)
+        obj: Any = module
+        for part in self.qualname.split("."):
+            obj = getattr(obj, part)
+        for _ in range(self.unwrap_depth):
+            obj = obj.__wrapped__
+        return obj
+
+
+_MAX_UNWRAP_DEPTH = 32
+
+
+def _importable_function_reference(func: Any) -> Optional[_ExecuteFunctionReference]:
+    """Return a pickle surrogate for *func* if it needs one, else None.
+
+    None is returned when normal pickle-by-reference works (module-level
+    function whose name still points at itself) or when the function is not
+    resolvable by import at all (lambdas, closures, bound methods); in the
+    latter case pickling fails with the standard, descriptive pickle error.
+    """
+    if not inspect.isfunction(func):
+        return None
+    module_name = getattr(func, "__module__", None)
+    qualname = getattr(func, "__qualname__", None)
+    if not module_name or not qualname or "<locals>" in qualname or "<lambda>" in qualname:
+        return None
+    module = sys.modules.get(module_name)
+    if module is None:
+        return None
+    obj: Any = module
+    try:
+        for part in qualname.split("."):
+            obj = getattr(obj, part)
+    except AttributeError:
+        return None
+    if obj is func:
+        # Plain module-level function: default pickling works, no surrogate.
+        return None
+    # The name was rebound (typically by @worker_task). Walk the wrapper chain
+    # to find the registered function and record how many hops it takes.
+    depth = 0
+    current = obj
+    while hasattr(current, "__wrapped__") and depth < _MAX_UNWRAP_DEPTH:
+        current = current.__wrapped__
+        depth += 1
+        if current is func:
+            return _ExecuteFunctionReference(module_name, qualname, depth)
+    return None
+
+
 def is_callable_input_parameter_a_task(callable: ExecuteTaskFunction, object_type: Any) -> bool:
     parameters = inspect.signature(callable).parameters
     if len(parameters) != 1:
@@ -306,7 +381,11 @@ class Worker(WorkerInterface):
                  register_schema: bool = False
                  ) -> Self:
         super().__init__(task_definition_name)
-        self.api_client = ApiClient()
+        # Lazily constructed (see the api_client property): an eager ApiClient
+        # holds an httpx.Client and threading locks, which made Worker
+        # unpicklable under the 'spawn' start method and initialized TLS state
+        # in the parent process before fork() (unsafe on macOS).
+        self._api_client = None
         if poll_interval is None:
             self.poll_interval = DEFAULT_POLLING_INTERVAL
         else:
@@ -335,6 +414,46 @@ class Worker(WorkerInterface):
         # Add thread lock for safe concurrent access to _pending_async_tasks
         self._pending_tasks_lock = threading.Lock()
 
+    @property
+    def api_client(self) -> ApiClient:
+        """ApiClient used for output serialization, created on first use.
+
+        Lazy so that Worker instances remain picklable (required by the
+        'spawn'/'forkserver' multiprocessing start methods) and so the parent
+        process never initializes HTTP/TLS state on behalf of workers.
+        """
+        if self._api_client is None:
+            self._api_client = ApiClient()
+        return self._api_client
+
+    @api_client.setter
+    def api_client(self, value: ApiClient) -> None:
+        self._api_client = value
+
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        # Process-local runtime state must not cross process boundaries: the
+        # 'spawn'/'forkserver' start methods pickle Process args (issues
+        # #264/#271: "cannot pickle '_thread.lock' object"). Everything below
+        # is rebuilt lazily in the child process.
+        state["_api_client"] = None
+        state["_background_loop"] = None
+        state["_pending_async_tasks"] = {}
+        state["_pending_tasks_lock"] = None
+        ref = _importable_function_reference(state.get("_execute_function"))
+        if ref is not None:
+            state["_execute_function"] = ref
+        return state
+
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+        if self._pending_tasks_lock is None:
+            self._pending_tasks_lock = threading.Lock()
+        if isinstance(self._execute_function, _ExecuteFunctionReference):
+            # Assign through the property setter so the signature-derived
+            # flags are recomputed against the resolved function.
+            self.execute_function = self._execute_function.resolve()
+
     def execute(self, task: Task) -> TaskResult:
         task_input = {}
         task_output = None