data-designer-engine 0.5.9__tar.gz → 0.6.0__tar.gz

{data_designer_engine-0.5.9 → data_designer_engine-0.6.0}/.gitignore

@@ -106,3 +106,14 @@ packages/data-designer/README.md
 
 # Claude worktrees
 .claude/worktrees/
+
+# Fern libraries output — generated by `fern docs md generate` from `libraries:` in fern/docs.yml.
+# Regenerate locally (no token needed) or in CI before publishing.
+fern/code-reference/
+
+# Fern notebook output - generated by `make generate-fern-notebooks`.
+fern/components/notebooks/*.json
+fern/components/notebooks/*.ts
+
+# Graphify structural analysis cache (CI-only, cached via actions/cache)
+graphify-out/

{data_designer_engine-0.5.9 → data_designer_engine-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: data-designer-engine
-Version: 0.5.9
+Version: 0.6.0
 Summary: Generation engine for DataDesigner synthetic data generation
 License-Expression: Apache-2.0
 Classifier: Development Status :: 4 - Beta
@@ -15,7 +15,8 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.10
 Requires-Dist: anyascii<1,>=0.3.3
 Requires-Dist: chardet<6,>=3.0.2
-Requires-Dist: data-designer-config==0.5.9
+Requires-Dist: cryptography<47,>=46.0.7
+Requires-Dist: data-designer-config==0.6.0
 Requires-Dist: duckdb<2,>=1.5.0
 Requires-Dist: faker<21,>=20.1.0
 Requires-Dist: fsspec<2026,>=2025.3.0
@@ -29,6 +30,7 @@ Requires-Dist: lxml<7,>=6.1.0
 Requires-Dist: marko<3,>=2.1.2
 Requires-Dist: mcp<2,>=1.26.0
 Requires-Dist: networkx<4,>=3.0
+Requires-Dist: python-multipart<1,>=0.0.27
 Requires-Dist: ruff<1,>=0.14.10
 Requires-Dist: scipy<2,>=1.11.0
 Requires-Dist: sqlfluff<4,>=3.2.0

{data_designer_engine-0.5.9 → data_designer_engine-0.6.0}/pyproject.toml

@@ -34,6 +34,7 @@ bump = true
 dependencies = [
     "anyascii>=0.3.3,<1",
     "chardet>=3.0.2,<6",  # Pulled in by sqlfluff
+    "cryptography>=46.0.7,<47", # 46.0.7 fixes CVE-2026-39892 pulled in by mcp
     "data-designer-config=={{ version }}",
     "duckdb>=1.5.0,<2",
     "faker>=20.1.0,<21",
@@ -48,6 +49,7 @@ dependencies = [
     "marko>=2.1.2,<3",
     "mcp>=1.26.0,<2",
     "networkx>=3.0,<4",
+    "python-multipart>=0.0.27,<1", # 0.0.27 fixes security advisory pulled in by mcp
     "ruff>=0.14.10,<1",
     "scipy>=1.11.0,<2",
     "sqlfluff>=3.2.0,<4",

{data_designer_engine-0.5.9 → data_designer_engine-0.6.0}/src/data_designer/engine/column_generators/generators/base.py

@@ -16,6 +16,14 @@ from data_designer.logging import LOG_DOUBLE_INDENT, LOG_INDENT
 
 _T = TypeVar("_T")
 
+# Preserved deliberately. Two other 300s deadlines were retired in the
+# async-default flip (PR #592): the throttle queue-wait and the
+# ``_AsyncBridgedModelFacade`` bridge in ``custom.py`` — both have
+# ``ModelFacade`` context and could derive a per-call deadline from
+# ``inference_parameters.timeout``. This generic ``ColumnGenerator.generate()``
+# fallback has no facade reachable, so a defensive backstop stays here for
+# now. Wiring a per-call timeout through to ``_run_coroutine_sync`` is
+# tracked as a structural follow-up.
 SYNC_BRIDGE_TIMEOUT = 300
 
 if TYPE_CHECKING:
@@ -59,7 +67,7 @@ class ColumnGenerator(ConfigurableTask[TaskConfigT], ABC):
 
     @property
     def is_llm_bound(self) -> bool:
-        """Whether this generator makes LLM/HTTP calls during generation."""
+        """Whether this generator makes model/API calls during generation."""
         return False
 
     @property
@@ -209,18 +217,52 @@ class ColumnGeneratorWithModel(ColumnGeneratorWithModelRegistry[TaskConfigT], AB
 
 
 class ColumnGeneratorCellByCell(ColumnGenerator[TaskConfigT], ABC):
+    """Base class for column generators invoked once per row.
+
+    Override ``generate`` to return the complete row mapping after adding the
+    generated value. The engine calls the generator once per row and may run
+    calls concurrently. Use this base when generation is independent per row
+    (e.g. an LLM call per row, a per-row transform).
+    """
+
     @staticmethod
     def get_generation_strategy() -> GenerationStrategy:
         return GenerationStrategy.CELL_BY_CELL
 
     @abstractmethod
-    def generate(self, data: dict) -> dict: ...
+    def generate(self, data: dict) -> dict:
+        """Generate one row's output from a single row's upstream values.
+
+        Args:
+            data: Current row mapping containing the upstream values available to this column.
+
+        Returns:
+            Complete row mapping with existing keys preserved and the new column value added.
+            Include declared side-effect columns when the config creates them.
+        """
 
 
 class ColumnGeneratorFullColumn(ColumnGenerator[TaskConfigT], ABC):
+    """Base class for column generators that transform a full batch at once.
+
+    Override ``generate`` to return the complete batch DataFrame after adding
+    generated values. Use this base when generation is vectorizable or when an
+    external API accepts batched input more efficiently than per-row calls.
+    """
+
     @staticmethod
     def get_generation_strategy() -> GenerationStrategy:
         return GenerationStrategy.FULL_COLUMN
 
     @abstractmethod
-    def generate(self, data: pd.DataFrame) -> pd.DataFrame: ...
+    def generate(self, data: pd.DataFrame) -> pd.DataFrame:
+        """Generate an entire batch of row outputs.
+
+        Args:
+            data: DataFrame containing the upstream columns this generator depends on.
+
+        Returns:
+            DataFrame containing the input columns plus the new column and any side-effect
+            columns. When ``config.allow_resize`` is ``False``, the row count must match
+            the input; when it is ``True``, the row count may change.
+        """

{data_designer_engine-0.5.9 → data_designer_engine-0.6.0}/src/data_designer/engine/column_generators/generators/custom.py

@@ -13,8 +13,9 @@ from typing import TYPE_CHECKING, Any
 
 import data_designer.lazy_heavy_imports as lazy
 from data_designer.config.column_configs import CustomColumnConfig, GenerationStrategy
-from data_designer.engine.column_generators.generators.base import SYNC_BRIDGE_TIMEOUT, ColumnGenerator
+from data_designer.engine.column_generators.generators.base import ColumnGenerator
 from data_designer.engine.column_generators.utils.errors import CustomColumnGenerationError
+from data_designer.engine.models.errors import RETRYABLE_MODEL_ERRORS, ModelTimeoutError
 from data_designer.logging import LOG_INDENT
 
 if TYPE_CHECKING:
@@ -22,6 +23,30 @@ if TYPE_CHECKING:
 
 logger = logging.getLogger(__name__)
 
+# Floor for the derived sync→async bridge timeout. Defends against pathologically
+# small `inference_parameters.timeout` values; under normal operation the per-call
+# derivation in ``_compute_bridge_timeout`` exceeds this floor.
+# Module-level so tests can patch it for fast feedback.
+_BRIDGE_TIMEOUT_FLOOR_S: float = 60.0
+
+
+def _compute_bridge_timeout(
+    request_timeout: float,
+    max_correction_steps: int,
+    max_conversation_restarts: int = 0,
+) -> float:
+    """Derive the sync→async bridge deadline for one logical generation.
+
+    One bridged call can fire up to ``(1 + max_conversation_restarts)`` full
+    attempts, and each attempt can fire up to ``(1 + max_correction_steps)``
+    requests against the model. The 1.5x buffer absorbs HTTP connect/teardown
+    and serialization overhead. The floor (``_BRIDGE_TIMEOUT_FLOOR_S``) keeps
+    the deadline sane when ``inference_parameters.timeout`` is small or the
+    factory default.
+    """
+    attempts = (1 + max_conversation_restarts) * (1 + max_correction_steps)
+    return max(_BRIDGE_TIMEOUT_FLOOR_S, attempts * request_timeout * 1.5)
+
 
 class _AsyncBridgedModelFacade:
     """Proxy that bridges ``model.generate()`` to ``model.agenerate()`` in async engine mode.
@@ -62,14 +87,30 @@ class _AsyncBridgedModelFacade:
 
         from data_designer.engine.dataset_builders.utils.async_concurrency import ensure_async_engine_loop
 
+        # Honor a per-call ``timeout=`` override (passed straight through to the
+        # HTTP layer); fall back to the model's configured ``inference_parameters.timeout``
+        # via ``facade.request_timeout`` when no override is set.
+        per_request_timeout_override = kwargs.get("timeout")
+        per_request_timeout = (
+            float(per_request_timeout_override) if per_request_timeout_override is not None else facade.request_timeout
+        )
+        correction_steps = int(kwargs.get("max_correction_steps", 0) or 0)
+        conversation_restarts = int(kwargs.get("max_conversation_restarts", 0) or 0)
+        bridge_timeout = _compute_bridge_timeout(per_request_timeout, correction_steps, conversation_restarts)
+
         loop = ensure_async_engine_loop()
         future = asyncio.run_coroutine_threadsafe(facade.agenerate(*args, **kwargs), loop)
         try:
-            return future.result(timeout=SYNC_BRIDGE_TIMEOUT)
+            return future.result(timeout=bridge_timeout)
         except concurrent.futures.TimeoutError as exc:
             future.cancel()
-            logger.warning("Async model bridge timed out after %ss; coroutine cancelled", SYNC_BRIDGE_TIMEOUT)
-            raise TimeoutError(f"model.generate() bridge timed out after {SYNC_BRIDGE_TIMEOUT}s") from exc
+            # Demoted to debug: the raised ModelTimeoutError already surfaces
+            # the timeout at the scheduler with full context, and the throttled
+            # degraded-provider WARN is the user-facing signal under sustained
+            # bridge timeouts. Per-event WARN was noise on top of those.
+            logger.debug("Async model bridge timed out after %.0fs; coroutine cancelled", bridge_timeout)
+            # Raise as ModelTimeoutError so the scheduler classifies it retryable.
+            raise ModelTimeoutError(f"model.generate() bridge timed out after {bridge_timeout:.0f}s") from exc
 
     def __getattr__(self, name: str) -> Any:
         return getattr(object.__getattribute__(self, "_facade"), name)
@@ -81,7 +122,7 @@ class _AsyncBridgedModelFacade:
 class CustomColumnGenerator(ColumnGenerator[CustomColumnConfig]):
     """Column generator that uses a user-provided callable function.
 
-    Supports two strategies based on config.strategy:
+    Supports two strategies based on config.generation_strategy:
         - cell_by_cell: Processes rows one at a time (dict -> dict), parallelized by framework.
         - full_column: Processes entire batch (DataFrame -> DataFrame) for vectorized ops.
 
@@ -147,6 +188,10 @@ class CustomColumnGenerator(ColumnGenerator[CustomColumnConfig]):
                 result = await self._ainvoke_generator_function(data)
             except CustomColumnGenerationError:
                 raise
+            except RETRYABLE_MODEL_ERRORS:
+                # Preserve retryability so the scheduler can salvage these
+                # instead of counting them toward the early-shutdown gate.
+                raise
             except Exception as e:
                 logger.warning(
                     f"⚠️ Custom generator function {self.config.generator_function.__name__!r} "
@@ -193,6 +238,10 @@ class CustomColumnGenerator(ColumnGenerator[CustomColumnConfig]):
             result = self._invoke_generator_function(data)
         except CustomColumnGenerationError:
             raise
+        except RETRYABLE_MODEL_ERRORS:
+            # Preserve retryability so the scheduler can salvage these
+            # instead of counting them toward the early-shutdown gate.
+            raise
         except Exception as e:
             if not is_dataframe:
                 logger.warning(