datachain 0.34.2__tar.gz → 0.34.4__tar.gz

{datachain-0.34.2 → datachain-0.34.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datachain
-Version: 0.34.2
+Version: 0.34.4
 Summary: Wrangle unstructured AI data at scale
 Author-email: Dmitry Petrov <support@dvc.org>
 License-Expression: Apache-2.0

{datachain-0.34.2 → datachain-0.34.4}/src/datachain/data_storage/sqlite.py

@@ -875,8 +875,17 @@ class SQLiteWarehouse(AbstractWarehouse):
                 if isinstance(c, BinaryExpression):
                     right_left_join = add_left_rows_filter(c)
 
-        union = sqlalchemy.union(left_right_join, right_left_join).subquery()
-        return sqlalchemy.select(*union.c).select_from(union)
+        # Use CTE instead of subquery to force SQLite to materialize the result
+        # This breaks deep nesting and prevents parser stack overflow.
+        union_cte = sqlalchemy.union(left_right_join, right_left_join).cte()
+
+        return self._regenerate_system_columns(union_cte)
+
+    def _system_row_number_expr(self):
+        return func.row_number().over()
+
+    def _system_random_expr(self):
+        return self._system_row_number_expr() * 1103515245 + 12345
 
     def create_pre_udf_table(self, query: "Select") -> "Table":
         """

{datachain-0.34.2 → datachain-0.34.4}/src/datachain/data_storage/warehouse.py

@@ -246,6 +246,44 @@ class AbstractWarehouse(ABC, Serializable):
                     break  # no more results
                 offset += page_size
 
+    def _regenerate_system_columns(self, selectable):
+        """Return a SELECT that regenerates sys__id and sys__rand deterministically."""
+
+        base = selectable.subquery() if hasattr(selectable, "subquery") else selectable
+
+        system_types: dict[str, sa.types.TypeEngine] = {
+            sys_col.name: sys_col.type
+            for sys_col in self.schema.dataset_row_cls.sys_columns()
+        }
+
+        result_columns = []
+        for col in base.c:
+            if col.name == "sys__id":
+                expr = self._system_row_number_expr()
+                expr = sa.cast(expr, system_types["sys__id"])
+                result_columns.append(expr.label("sys__id"))
+            elif col.name == "sys__rand":
+                expr = self._system_random_expr()
+                expr = sa.cast(expr, system_types["sys__rand"])
+                result_columns.append(expr.label("sys__rand"))
+            else:
+                result_columns.append(col)
+
+        # Wrap in subquery to materialize window functions, then wrap again in SELECT
+        # This ensures window functions are computed before INSERT...FROM SELECT
+        inner = sa.select(*result_columns).select_from(base).subquery()
+        return sa.select(*inner.c).select_from(inner)
+
+    def _system_row_number_expr(self):
+        """Return an expression that produces deterministic row numbers."""
+
+        raise NotImplementedError
+
+    def _system_random_expr(self):
+        """Return an expression that produces deterministic random values."""
+
+        raise NotImplementedError
+
     #
     # Table Name Internal Functions
     #
@@ -923,6 +961,8 @@ class AbstractWarehouse(ABC, Serializable):
         right: "_FromClauseArgument",
         onclause: "_OnClauseArgument",
         inner: bool = True,
+        full: bool = False,
+        columns=None,
     ) -> sa.Select:
         """
         Join two tables together.

{datachain-0.34.2 → datachain-0.34.4}/src/datachain/lib/dc/datachain.py

@@ -1701,7 +1701,11 @@ class DataChain:
             )
 
         query = self._query.join(
-            right_ds._query, sqlalchemy.and_(*ops), inner, full, rname + "{name}"
+            right_ds._query,
+            sqlalchemy.and_(*ops),
+            inner,
+            full,
+            rname + "{name}",
         )
         query.feature_schema = None
         ds = self._evolve(query=query)
@@ -1989,7 +1993,8 @@ class DataChain:
         results = self.results(include_hidden=include_hidden)
         if as_object:
             df = pd.DataFrame(results, columns=columns, dtype=object)
-            return df.where(pd.notna(df), None)
+            df.where(pd.notna(df), None, inplace=True)
+            return df
         return pd.DataFrame.from_records(results, columns=columns)
 
     def show(

{datachain-0.34.2 → datachain-0.34.4}/src/datachain/lib/signal_schema.py

@@ -1,6 +1,8 @@
 import copy
 import hashlib
 import json
+import logging
+import math
 import warnings
 from collections.abc import Iterator, Sequence
 from dataclasses import dataclass
@@ -23,7 +25,7 @@ from typing import (  # noqa: UP035
     get_origin,
 )
 
-from pydantic import BaseModel, Field, create_model
+from pydantic import BaseModel, Field, ValidationError, create_model
 from sqlalchemy import ColumnElement
 from typing_extensions import Literal as LiteralEx
 
@@ -43,6 +45,8 @@ if TYPE_CHECKING:
     from datachain.catalog import Catalog
 
 
+logger = logging.getLogger(__name__)
+
 NAMES_TO_TYPES = {
     "int": int,
     "str": str,
@@ -463,12 +467,32 @@ class SignalSchema:
                 objs.append(self.setup_values.get(name))
             elif (fr := ModelStore.to_pydantic(fr_type)) is not None:
                 j, pos = unflatten_to_json_pos(fr, row, pos)
-                objs.append(fr(**j))
+                try:
+                    obj = fr(**j)
+                except ValidationError as e:
+                    if self._all_values_none(j):
+                        logger.debug("Failed to create input for %s: %s", name, e)
+                        obj = None
+                    else:
+                        raise
+                objs.append(obj)
             else:
                 objs.append(row[pos])
                 pos += 1
         return objs
 
+    @staticmethod
+    def _all_values_none(value: Any) -> bool:
+        if isinstance(value, dict):
+            return all(SignalSchema._all_values_none(v) for v in value.values())
+        if isinstance(value, (list, tuple, set)):
+            return all(SignalSchema._all_values_none(v) for v in value)
+        if isinstance(value, float):
+            # NaN is used to represent NULL and NaN float values in datachain
+            # Since SQLite does not have a separate NULL type, we need to check for NaN
+            return math.isnan(value) or value is None
+        return value is None
+
     def get_file_signal(self) -> Optional[str]:
         for signal_name, signal_type in self.values.items():
             if (fr := ModelStore.to_pydantic(signal_type)) is not None and issubclass(
@@ -546,8 +570,15 @@ class SignalSchema:
                 pos += 1
             else:
                 json, pos = unflatten_to_json_pos(fr, row, pos)  # type: ignore[union-attr]
-                obj = fr(**json)
-                SignalSchema._set_file_stream(obj, catalog, cache)
+                try:
+                    obj = fr(**json)
+                    SignalSchema._set_file_stream(obj, catalog, cache)
+                except ValidationError as e:
+                    if self._all_values_none(json):
+                        logger.debug("Failed to create feature for %s: %s", fr_cls, e)
+                        obj = None
+                    else:
+                        raise
                 res.append(obj)
         return res
 

{datachain-0.34.2 → datachain-0.34.4}/src/datachain/query/dataset.py

@@ -1009,7 +1009,9 @@ class SQLJoin(Step):
     rname: str
 
     def hash_inputs(self) -> str:
-        predicates = ensure_sequence(self.predicates or [])
+        predicates = (
+            ensure_sequence(self.predicates) if self.predicates is not None else []
+        )
 
         parts = [
             bytes.fromhex(self.query1.hash()),

{datachain-0.34.2 → datachain-0.34.4}/src/datachain.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datachain
-Version: 0.34.2
+Version: 0.34.4
 Summary: Wrangle unstructured AI data at scale
 Author-email: Dmitry Petrov <support@dvc.org>
 License-Expression: Apache-2.0

{datachain-0.34.2 → datachain-0.34.4}/src/datachain.egg-info/SOURCES.txt

@@ -334,6 +334,7 @@ tests/func/test_storage_pattern.py
 tests/func/test_studio_datetime_parsing.py
 tests/func/test_to_database.py
 tests/func/test_toolkit.py
+tests/func/test_udf.py
 tests/func/test_video.py
 tests/func/test_warehouse.py
 tests/func/data/Big_Buck_Bunny_360_10s_1MB.mp4