datachain 0.30.1__py3-none-any.whl → 0.30.3__py3-none-any.whl

datachain/catalog/catalog.py

@@ -680,8 +680,9 @@ class Catalog:
                 ds_namespace, ds_project, ds_name = parse_dataset_name(ds_name)
                 assert ds_namespace
                 assert ds_project
-                project = self.metastore.get_project(ds_project, ds_namespace)
-                dataset = self.get_dataset(ds_name, project)
+                dataset = self.get_dataset(
+                    ds_name, namespace_name=ds_namespace, project_name=ds_project
+                )
                 if not ds_version:
                     ds_version = dataset.latest_version
                 dataset_sources = self.warehouse.get_dataset_sources(
@@ -807,7 +808,11 @@ class Catalog:
             )
         default_version = DEFAULT_DATASET_VERSION
         try:
-            dataset = self.get_dataset(name, project)
+            dataset = self.get_dataset(
+                name,
+                namespace_name=project.namespace.name if project else None,
+                project_name=project.name if project else None,
+            )
             default_version = dataset.next_version_patch
             if update_version == "major":
                 default_version = dataset.next_version_major
@@ -1016,7 +1021,11 @@ class Catalog:
             dc.save(name)
         except Exception as e:  # noqa: BLE001
             try:
-                ds = self.get_dataset(name, project)
+                ds = self.get_dataset(
+                    name,
+                    namespace_name=project.namespace.name,
+                    project_name=project.name,
+                )
                 self.metastore.update_dataset_status(
                     ds,
                     DatasetStatus.FAILED,
@@ -1033,7 +1042,11 @@ class Catalog:
             except DatasetNotFoundError:
                 raise e from None
 
-        ds = self.get_dataset(name, project)
+        ds = self.get_dataset(
+            name,
+            namespace_name=project.namespace.name,
+            project_name=project.name,
+        )
 
         self.update_dataset_version_with_warehouse_info(
             ds,
@@ -1041,7 +1054,11 @@ class Catalog:
             sources="\n".join(sources),
         )
 
-        return self.get_dataset(name, project)
+        return self.get_dataset(
+            name,
+            namespace_name=project.namespace.name,
+            project_name=project.name,
+        )
 
     def get_full_dataset_name(
         self,
@@ -1077,22 +1094,23 @@ class Catalog:
         return namespace_name, project_name, name
 
     def get_dataset(
-        self, name: str, project: Optional[Project] = None
+        self,
+        name: str,
+        namespace_name: Optional[str] = None,
+        project_name: Optional[str] = None,
     ) -> DatasetRecord:
         from datachain.lib.listing import is_listing_dataset
 
-        project = project or self.metastore.default_project
+        namespace_name = namespace_name or self.metastore.default_namespace_name
+        project_name = project_name or self.metastore.default_project_name
 
         if is_listing_dataset(name):
-            project = self.metastore.listing_project
+            namespace_name = self.metastore.system_namespace_name
+            project_name = self.metastore.listing_project_name
 
-        try:
-            return self.metastore.get_dataset(name, project.id if project else None)
-        except DatasetNotFoundError:
-            raise DatasetNotFoundError(
-                f"Dataset {name} not found in namespace {project.namespace.name}"
-                f" and project {project.name}"
-            ) from None
+        return self.metastore.get_dataset(
+            name, namespace_name=namespace_name, project_name=project_name
+        )
 
     def get_dataset_with_remote_fallback(
         self,
@@ -1113,8 +1131,11 @@ class Catalog:
 
         if self.metastore.is_local_dataset(namespace_name) or not update:
             try:
-                project = self.metastore.get_project(project_name, namespace_name)
-                ds = self.get_dataset(name, project)
+                ds = self.get_dataset(
+                    name,
+                    namespace_name=namespace_name,
+                    project_name=project_name,
+                )
                 if not version or ds.has_version(version):
                     return ds
             except (NamespaceNotFoundError, ProjectNotFoundError, DatasetNotFoundError):
@@ -1139,7 +1160,9 @@ class Catalog:
                 local_ds_version=version,
             )
             return self.get_dataset(
-                name, self.metastore.get_project(project_name, namespace_name)
+                name,
+                namespace_name=namespace_name,
+                project_name=project_name,
             )
 
         return self.get_remote_dataset(namespace_name, project_name, name)
@@ -1148,7 +1171,11 @@ class Catalog:
         """Returns dataset that contains version with specific uuid"""
         for dataset in self.ls_datasets():
             if dataset.has_version_with_uuid(uuid):
-                return self.get_dataset(dataset.name, dataset.project)
+                return self.get_dataset(
+                    dataset.name,
+                    namespace_name=dataset.project.namespace.name,
+                    project_name=dataset.project.name,
+                )
         raise DatasetNotFoundError(f"Dataset with version uuid {uuid} not found.")
 
     def get_remote_dataset(
@@ -1171,9 +1198,18 @@ class Catalog:
         return DatasetRecord.from_dict(dataset_info)
 
     def get_dataset_dependencies(
-        self, name: str, version: str, project: Optional[Project] = None, indirect=False
+        self,
+        name: str,
+        version: str,
+        namespace_name: Optional[str] = None,
+        project_name: Optional[str] = None,
+        indirect=False,
     ) -> list[Optional[DatasetDependency]]:
-        dataset = self.get_dataset(name, project)
+        dataset = self.get_dataset(
+            name,
+            namespace_name=namespace_name,
+            project_name=project_name,
+        )
 
         direct_dependencies = self.metastore.get_direct_dataset_dependencies(
             dataset, version
@@ -1187,10 +1223,13 @@ class Catalog:
                 # dependency has been removed
                 continue
             if d.is_dataset:
-                project = self.metastore.get_project(d.project, d.namespace)
                 # only datasets can have dependencies
                 d.dependencies = self.get_dataset_dependencies(
-                    d.name, d.version, project, indirect=indirect
+                    d.name,
+                    d.version,
+                    namespace_name=d.namespace,
+                    project_name=d.project,
+                    indirect=indirect,
                 )
 
         return direct_dependencies
@@ -1340,7 +1379,11 @@ class Catalog:
         project: Optional[Project] = None,
         client_config=None,
     ) -> list[str]:
-        dataset = self.get_dataset(name, project)
+        dataset = self.get_dataset(
+            name,
+            namespace_name=project.namespace.name if project else None,
+            project_name=project.name if project else None,
+        )
 
         return self.warehouse.export_dataset_table(
             bucket_uri, dataset, version, client_config
@@ -1349,7 +1392,11 @@ class Catalog:
     def dataset_table_export_file_names(
         self, name: str, version: str, project: Optional[Project] = None
     ) -> list[str]:
-        dataset = self.get_dataset(name, project)
+        dataset = self.get_dataset(
+            name,
+            namespace_name=project.namespace.name if project else None,
+            project_name=project.name if project else None,
+        )
         return self.warehouse.dataset_table_export_file_names(dataset, version)
 
     def remove_dataset(
@@ -1359,7 +1406,11 @@ class Catalog:
         version: Optional[str] = None,
         force: Optional[bool] = False,
     ):
-        dataset = self.get_dataset(name, project)
+        dataset = self.get_dataset(
+            name,
+            namespace_name=project.namespace.name if project else None,
+            project_name=project.name if project else None,
+        )
         if not version and not force:
             raise ValueError(f"Missing dataset version from input for dataset {name}")
         if version and not dataset.has_version(version):
@@ -1395,7 +1446,11 @@ class Catalog:
         if attrs is not None:
             update_data["attrs"] = attrs  # type: ignore[assignment]
 
-        dataset = self.get_dataset(name, project)
+        dataset = self.get_dataset(
+            name,
+            namespace_name=project.namespace.name if project else None,
+            project_name=project.name if project else None,
+        )
         return self.update_dataset(dataset, **update_data)
 
     def ls(
@@ -1549,7 +1604,9 @@ class Catalog:
         )
 
         try:
-            local_dataset = self.get_dataset(local_ds_name, project=project)
+            local_dataset = self.get_dataset(
+                local_ds_name, namespace_name=namespace.name, project_name=project.name
+            )
             if local_dataset and local_dataset.has_version(local_ds_version):
                 raise DataChainError(
                     f"Local dataset {local_ds_uri} already exists with different uuid,"

datachain/cli/commands/datasets.py

@@ -107,8 +107,9 @@ def list_datasets_local(catalog: "Catalog", name: Optional[str] = None):
 def list_datasets_local_versions(catalog: "Catalog", name: str):
     namespace_name, project_name, name = catalog.get_full_dataset_name(name)
 
-    project = catalog.metastore.get_project(project_name, namespace_name)
-    ds = catalog.get_dataset(name, project)
+    ds = catalog.get_dataset(
+        name, namespace_name=namespace_name, project_name=project_name
+    )
     for v in ds.versions:
         yield (name, v.version)
 

datachain/data_storage/metastore.py

@@ -301,7 +301,13 @@ class AbstractMetastore(ABC, Serializable):
         """
 
     @abstractmethod
-    def get_dataset(self, name: str, project_id: Optional[int] = None) -> DatasetRecord:
+    def get_dataset(
+        self,
+        name: str,  # normal, not full dataset name
+        namespace_name: Optional[str] = None,
+        project_name: Optional[str] = None,
+        conn=None,
+    ) -> DatasetRecord:
         """Gets a single dataset by name."""
 
     @abstractmethod
@@ -912,11 +918,14 @@ class AbstractDBMetastore(AbstractMetastore):
         **kwargs,  # TODO registered = True / False
     ) -> DatasetRecord:
         """Creates new dataset."""
-        project_id = project_id or self.default_project.id
+        if not project_id:
+            project = self.default_project
+        else:
+            project = self.get_project_by_id(project_id)
 
         query = self._datasets_insert().values(
             name=name,
-            project_id=project_id,
+            project_id=project.id,
             status=status,
             feature_schema=json.dumps(feature_schema or {}),
             created_at=datetime.now(timezone.utc),
@@ -935,7 +944,9 @@ class AbstractDBMetastore(AbstractMetastore):
             query = query.on_conflict_do_nothing(index_elements=["project_id", "name"])
         self.db.execute(query)
 
-        return self.get_dataset(name, project_id)
+        return self.get_dataset(
+            name, namespace_name=project.namespace.name, project_name=project.name
+        )
 
     def create_dataset_version(  # noqa: PLR0913
         self,
@@ -992,7 +1003,12 @@ class AbstractDBMetastore(AbstractMetastore):
             )
         self.db.execute(query, conn=conn)
 
-        return self.get_dataset(dataset.name, dataset.project.id, conn=conn)
+        return self.get_dataset(
+            dataset.name,
+            namespace_name=dataset.project.namespace.name,
+            project_name=dataset.project.name,
+            conn=conn,
+        )
 
     def remove_dataset(self, dataset: DatasetRecord) -> None:
         """Removes dataset."""
@@ -1216,21 +1232,30 @@ class AbstractDBMetastore(AbstractMetastore):
     def get_dataset(
         self,
         name: str,  # normal, not full dataset name
-        project_id: Optional[int] = None,
+        namespace_name: Optional[str] = None,
+        project_name: Optional[str] = None,
         conn=None,
     ) -> DatasetRecord:
         """
         Gets a single dataset in project by dataset name.
         """
-        project_id = project_id or self.default_project.id
+        namespace_name = namespace_name or self.default_namespace_name
+        project_name = project_name or self.default_project_name
 
         d = self._datasets
+        n = self._namespaces
+        p = self._projects
         query = self._base_dataset_query()
-        query = query.where(d.c.name == name, d.c.project_id == project_id)  # type: ignore [attr-defined]
+        query = query.where(
+            d.c.name == name,
+            n.c.name == namespace_name,
+            p.c.name == project_name,
+        )  # type: ignore [attr-defined]
         ds = self._parse_dataset(self.db.execute(query, conn=conn))
         if not ds:
             raise DatasetNotFoundError(
-                f"Dataset {name} not found in project with id {project_id}"
+                f"Dataset {name} not found in namespace {namespace_name}"
+                f" and project {project_name}"
             )
 
         return ds

datachain/delta.py

@@ -77,7 +77,8 @@ def _get_delta_chain(
 
 def _get_retry_chain(
     name: str,
-    project: Project,
+    namespace_name: str,
+    project_name: str,
     latest_version: str,
     source_ds_name: str,
     source_ds_project: Project,
@@ -96,8 +97,8 @@ def _get_retry_chain(
     # Read the latest version of the result dataset for retry logic
     result_dataset = datachain.read_dataset(
         name,
-        namespace=project.namespace.name,
-        project=project.name,
+        namespace=namespace_name,
+        project=project_name,
         version=latest_version,
     )
     source_dc = datachain.read_dataset(
@@ -128,7 +129,8 @@ def _get_retry_chain(
 
 def _get_source_info(
     name: str,
-    project: Project,
+    namespace_name: str,
+    project_name: str,
     latest_version: str,
     catalog,
 ) -> tuple[
@@ -145,7 +147,11 @@ def _get_source_info(
         Returns (None, None, None, None) if source dataset was removed.
     """
     dependencies = catalog.get_dataset_dependencies(
-        name, latest_version, project=project, indirect=False
+        name,
+        latest_version,
+        namespace_name=namespace_name,
+        project_name=project_name,
+        indirect=False,
     )
 
     dep = dependencies[0]
@@ -157,7 +163,9 @@ def _get_source_info(
     source_ds_name = dep.name
     source_ds_version = dep.version
     source_ds_latest_version = catalog.get_dataset(
-        source_ds_name, project=source_ds_project
+        source_ds_name,
+        namespace_name=source_ds_project.namespace.name,
+        project_name=source_ds_project.name,
     ).latest_version
 
     return (
@@ -211,12 +219,14 @@ def delta_retry_update(
     """
 
     catalog = dc.session.catalog
-    project = catalog.metastore.get_project(project_name, namespace_name)
+    # project = catalog.metastore.get_project(project_name, namespace_name)
     dc._query.apply_listing_pre_step()
 
     # Check if dataset exists
     try:
-        dataset = catalog.get_dataset(name, project=project)
+        dataset = catalog.get_dataset(
+            name, namespace_name=namespace_name, project_name=project_name
+        )
         latest_version = dataset.latest_version
     except DatasetNotFoundError:
         # First creation of result dataset
@@ -234,7 +244,7 @@ def delta_retry_update(
         source_ds_version,
         source_ds_latest_version,
         dependencies,
-    ) = _get_source_info(name, project, latest_version, catalog)
+    ) = _get_source_info(name, namespace_name, project_name, latest_version, catalog)
 
     # If source_ds_name is None, starting dataset was removed
     if source_ds_name is None:
@@ -264,7 +274,8 @@ def delta_retry_update(
     if delta_retry:
         retry_chain = _get_retry_chain(
             name,
-            project,
+            namespace_name,
+            project_name,
             latest_version,
             source_ds_name,
             source_ds_project,
@@ -290,8 +301,8 @@ def delta_retry_update(
 
     latest_dataset = datachain.read_dataset(
         name,
-        namespace=project.namespace.name,
-        project=project.name,
+        namespace=namespace_name,
+        project=project_name,
         version=latest_version,
     )
     compared_chain = latest_dataset.diff(

datachain/func/string.py

@@ -6,6 +6,14 @@ from datachain.sql.functions import string
 
 from .func import ColT, Func
 
+__all__ = [
+    "byte_hamming_distance",
+    "length",
+    "regexp_replace",
+    "replace",
+    "split",
+]
+
 
 def length(col: ColT) -> Func:
     """

datachain/lib/dc/database.py

@@ -7,6 +7,7 @@ from typing import TYPE_CHECKING, Any, Optional, Union
 import sqlalchemy
 
 from datachain.query.schema import ColumnMeta
+from datachain.utils import batched
 
 DEFAULT_DATABASE_BATCH_SIZE = 10_000
 
@@ -74,16 +75,18 @@ def to_database(
     *,
     batch_rows: int = DEFAULT_DATABASE_BATCH_SIZE,
     on_conflict: Optional[str] = None,
+    conflict_columns: Optional[list[str]] = None,
     column_mapping: Optional[dict[str, Optional[str]]] = None,
-) -> None:
+) -> int:
     """
     Implementation function for exporting DataChain to database tables.
 
     This is the core implementation that handles the actual database operations.
     For user-facing documentation, see DataChain.to_database() method.
-    """
-    from datachain.utils import batched
 
+    Returns:
+        int: Number of rows affected (inserted/updated).
+    """
     if on_conflict and on_conflict not in ("ignore", "update"):
         raise ValueError(
             f"on_conflict must be 'ignore' or 'update', got: {on_conflict}"
@@ -101,23 +104,39 @@ def to_database(
         all_columns, normalized_column_mapping
     )
 
+    normalized_conflict_columns = _normalize_conflict_columns(
+        conflict_columns, normalized_column_mapping
+    )
+
     with _connect(connection) as conn:
         metadata = sqlalchemy.MetaData()
         table = sqlalchemy.Table(table_name, metadata, *columns)
 
-        # Check if table already exists to determine if we should clean up on error.
-        inspector = sqlalchemy.inspect(conn)
-        assert inspector  # to satisfy mypy
-        table_existed_before = table_name in inspector.get_table_names()
-
+        table_existed_before = False
+        total_rows_affected = 0
         try:
-            table.create(conn, checkfirst=True)
-            rows_iter = chain._leaf_values()
-            for batch in batched(rows_iter, batch_rows):
-                _process_batch(
-                    conn, table, batch, on_conflict, column_indices_and_names
-                )
-            conn.commit()
+            with conn.begin():
+                # Check if table exists to determine if we should clean up on error.
+                inspector = sqlalchemy.inspect(conn)
+                assert inspector  # to satisfy mypy
+                table_existed_before = table_name in inspector.get_table_names()
+
+                table.create(conn, checkfirst=True)
+
+                rows_iter = chain._leaf_values()
+                for batch in batched(rows_iter, batch_rows):
+                    rows_affected = _process_batch(
+                        conn,
+                        table,
+                        batch,
+                        on_conflict,
+                        normalized_conflict_columns,
+                        column_indices_and_names,
+                    )
+                    if rows_affected < 0 or total_rows_affected < 0:
+                        total_rows_affected = -1
+                    else:
+                        total_rows_affected += rows_affected
         except Exception:
             if not table_existed_before:
                 try:
@@ -127,6 +146,8 @@ def to_database(
                     pass
             raise
 
+    return total_rows_affected
+
 
 def _normalize_column_mapping(
     column_mapping: dict[str, Optional[str]],
@@ -167,6 +188,30 @@ def _normalize_column_mapping(
     return normalized_mapping
 
 
+def _normalize_conflict_columns(
+    conflict_columns: Optional[list[str]], column_mapping: dict[str, Optional[str]]
+) -> Optional[list[str]]:
+    """
+    Normalize conflict_columns by converting DataChain format to database format
+    and applying column mapping.
+    """
+    if not conflict_columns:
+        return None
+
+    normalized_columns = []
+    for col in conflict_columns:
+        db_col = ColumnMeta.to_db_name(col)
+
+        if db_col in column_mapping or hasattr(column_mapping, "default_factory"):
+            mapped_name = column_mapping[db_col]
+            if mapped_name:
+                normalized_columns.append(mapped_name)
+        else:
+            normalized_columns.append(db_col)
+
+    return normalized_columns
+
+
 def _prepare_columns(all_columns, column_mapping):
     """Prepare column mapping and column definitions."""
     column_indices_and_names = []  # List of (index, target_name) tuples
@@ -183,8 +228,14 @@ def _prepare_columns(all_columns, column_mapping):
     return column_indices_and_names, columns
 
 
-def _process_batch(conn, table, batch, on_conflict, column_indices_and_names):
-    """Process a batch of rows with conflict resolution."""
+def _process_batch(
+    conn, table, batch, on_conflict, conflict_columns, column_indices_and_names
+) -> int:
+    """Process a batch of rows with conflict resolution.
+
+    Returns:
+        int: Number of rows affected by the insert operation.
+    """
 
     def prepare_row(row_values):
         """Convert a row tuple to a dictionary with proper DB column names."""
@@ -197,6 +248,7 @@ def _process_batch(conn, table, batch, on_conflict, column_indices_and_names):
 
     supports_conflict = on_conflict and conn.engine.name in ("postgresql", "sqlite")
 
+    insert_stmt: Any  # Can be PostgreSQL, SQLite, or regular insert statement
     if supports_conflict:
         # Use dialect-specific insert for conflict resolution
         if conn.engine.name == "postgresql":
@@ -217,7 +269,19 @@ def _process_batch(conn, table, batch, on_conflict, column_indices_and_names):
             update_values = {
                 col.name: insert_stmt.excluded[col.name] for col in table.columns
             }
-            insert_stmt = insert_stmt.on_conflict_do_update(set_=update_values)
+            if conn.engine.name == "postgresql":
+                if not conflict_columns:
+                    raise ValueError(
+                        "conflict_columns parameter is required when "
+                        "on_conflict='update' with PostgreSQL. Specify the column "
+                        "names that form a unique constraint."
+                    )
+
+                insert_stmt = insert_stmt.on_conflict_do_update(
+                    index_elements=conflict_columns, set_=update_values
+                )
+            else:
+                insert_stmt = insert_stmt.on_conflict_do_update(set_=update_values)
     elif on_conflict:
         import warnings
 
@@ -228,7 +292,8 @@ def _process_batch(conn, table, batch, on_conflict, column_indices_and_names):
             stacklevel=2,
         )
 
-    conn.execute(insert_stmt, rows_to_insert)
+    result = conn.execute(insert_stmt, rows_to_insert)
+    return result.rowcount
 
 
 def read_database(

datachain/lib/dc/datachain.py

@@ -284,7 +284,11 @@ class DataChain:
         """Underlying dataset, if there is one."""
         if not self.name:
             return None
-        return self.session.catalog.get_dataset(self.name, self._query.project)
+        return self.session.catalog.get_dataset(
+            self.name,
+            namespace_name=self._query.project.namespace.name,
+            project_name=self._query.project.name,
+        )
 
     def __or__(self, other: "Self") -> "Self":
         """Return `self.union(other)`."""
@@ -2296,14 +2300,19 @@ class DataChain:
         *,
         batch_rows: int = DEFAULT_DATABASE_BATCH_SIZE,
         on_conflict: Optional[str] = None,
+        conflict_columns: Optional[list[str]] = None,
         column_mapping: Optional[dict[str, Optional[str]]] = None,
-    ) -> None:
+    ) -> int:
         """Save chain to a database table using a given database connection.
 
         This method exports all DataChain records to a database table, creating the
         table if it doesn't exist and appending data if it does. The table schema
         is automatically inferred from the DataChain's signal schema.
 
+        For PostgreSQL, tables are created in the schema specified by the connection's
+        search_path (defaults to 'public'). Use URL parameters to target specific
+        schemas.
+
         Parameters:
             table_name: Name of the database table to create/write to.
             connection: SQLAlchemy connectable, str, or a sqlite3 connection
@@ -2319,25 +2328,34 @@ class DataChain:
                   (default)
                 - "ignore": Skip duplicate rows silently
                 - "update": Update existing rows with new values
+            conflict_columns: List of column names that form a unique constraint
+                for conflict resolution. Required when on_conflict='update' and
+                using PostgreSQL.
             column_mapping: Optional mapping to rename or skip columns:
                 - Dict mapping DataChain column names to database column names
                 - Set values to None to skip columns entirely, or use `defaultdict` to
                   skip all columns except those specified.
 
+        Returns:
+            int: Number of rows affected (inserted/updated). -1 if DB driver doesn't
+                 support telemetry.
+
         Examples:
             Basic usage with PostgreSQL:
             ```py
-            import sqlalchemy as sa
             import datachain as dc
 
-            chain = dc.read_storage("s3://my-bucket/")
-            engine = sa.create_engine("postgresql://user:pass@localhost/mydb")
-            chain.to_database("files_table", engine)
+            rows_affected = (dc
+              .read_storage("s3://my-bucket/")
+              .to_database("files_table", "postgresql://user:pass@localhost/mydb")
+            )
+            print(f"Inserted/updated {rows_affected} rows")
             ```
 
             Using SQLite with connection string:
             ```py
-            chain.to_database("my_table", "sqlite:///data.db")
+            rows_affected = chain.to_database("my_table", "sqlite:///data.db")
+            print(f"Affected {rows_affected} rows")
             ```
 
             Column mapping and renaming:
@@ -2356,7 +2374,9 @@ class DataChain:
             chain.to_database("my_table", engine, on_conflict="ignore")
 
             # Update existing records
-            chain.to_database("my_table", engine, on_conflict="update")
+            chain.to_database(
+               "my_table", engine, on_conflict="update", conflict_columns=["id"]
+            )
             ```
 
             Working with different databases:
@@ -2368,15 +2388,22 @@ class DataChain:
             # SQLite in-memory
             chain.to_database("temp_table", "sqlite:///:memory:")
             ```
+
+            PostgreSQL with schema support:
+            ```py
+            pg_url = "postgresql://user:pass@host/db?options=-c search_path=analytics"
+            chain.to_database("processed_data", pg_url)
+            ```
         """
         from .database import to_database
 
-        to_database(
+        return to_database(
             self,
             table_name,
             connection,
             batch_rows=batch_rows,
             on_conflict=on_conflict,
+            conflict_columns=conflict_columns,
             column_mapping=column_mapping,
         )
 

datachain/lib/dc/datasets.py

@@ -357,7 +357,14 @@ def delete_dataset(
         ) from None
 
     if not force:
-        version = version or catalog.get_dataset(name, ds_project).latest_version
+        version = (
+            version
+            or catalog.get_dataset(
+                name,
+                namespace_name=ds_project.namespace.name,
+                project_name=ds_project.name,
+            ).latest_version
+        )
     else:
         version = None
     catalog.remove_dataset(name, ds_project, version=version, force=force)
@@ -403,9 +410,7 @@ def move_dataset(
     namespace, project, name = catalog.get_full_dataset_name(src)
     dest_namespace, dest_project, dest_name = catalog.get_full_dataset_name(dest)
 
-    dataset = catalog.get_dataset(
-        name, catalog.metastore.get_project(project, namespace)
-    )
+    dataset = catalog.get_dataset(name, namespace_name=namespace, project_name=project)
 
     catalog.update_dataset(
         dataset,

datachain/listing.py

@@ -65,17 +65,13 @@ class Listing:
 
     @cached_property
     def dataset(self) -> "DatasetRecord":
-        from datachain.error import DatasetNotFoundError
-
         assert self.dataset_name
         project = self.metastore.listing_project
-        try:
-            return self.metastore.get_dataset(self.dataset_name, project.id)
-        except DatasetNotFoundError:
-            raise DatasetNotFoundError(
-                f"Dataset {self.dataset_name} not found in namespace"
-                f" {project.namespace.name} and project {project.name}"
-            ) from None
+        return self.metastore.get_dataset(
+            self.dataset_name,
+            namespace_name=project.namespace.name,
+            project_name=project.name,
+        )
 
     @cached_property
     def dataset_rows(self):

datachain/model/ultralytics/bbox.py

@@ -31,11 +31,11 @@ class YoloBBox(DataModel):
         if not summary:
             return YoloBBox(box=BBox())
         name = summary[0].get("name", "")
-        box = (
-            BBox.from_dict(summary[0]["box"], title=name)
-            if summary[0].get("box")
-            else BBox()
-        )
+        if summary[0].get("box"):
+            assert isinstance(summary[0]["box"], dict)
+            box = BBox.from_dict(summary[0]["box"], title=name)
+        else:
+            box = BBox()
         return YoloBBox(
             cls=summary[0]["class"],
             name=name,
@@ -70,7 +70,8 @@ class YoloBBoxes(DataModel):
                 names.append(name)
                 confidence.append(s["confidence"])
                 if s.get("box"):
-                    box.append(BBox.from_dict(s.get("box"), title=name))
+                    assert isinstance(s["box"], dict)
+                    box.append(BBox.from_dict(s["box"], title=name))
         return YoloBBoxes(
             cls=cls,
             name=names,
@@ -101,11 +102,11 @@ class YoloOBBox(DataModel):
         if not summary:
             return YoloOBBox(box=OBBox())
         name = summary[0].get("name", "")
-        box = (
-            OBBox.from_dict(summary[0]["box"], title=name)
-            if summary[0].get("box")
-            else OBBox()
-        )
+        if summary[0].get("box"):
+            assert isinstance(summary[0]["box"], dict)
+            box = OBBox.from_dict(summary[0]["box"], title=name)
+        else:
+            box = OBBox()
         return YoloOBBox(
             cls=summary[0]["class"],
             name=name,
@@ -140,7 +141,8 @@ class YoloOBBoxes(DataModel):
                 names.append(name)
                 confidence.append(s["confidence"])
                 if s.get("box"):
-                    box.append(OBBox.from_dict(s.get("box"), title=name))
+                    assert isinstance(s["box"], dict)
+                    box.append(OBBox.from_dict(s["box"], title=name))
         return YoloOBBoxes(
             cls=cls,
             name=names,

datachain/model/ultralytics/pose.py

@@ -56,16 +56,16 @@ class YoloPose(DataModel):
         if not summary:
             return YoloPose(box=BBox(), pose=Pose3D())
         name = summary[0].get("name", "")
-        box = (
-            BBox.from_dict(summary[0]["box"], title=name)
-            if summary[0].get("box")
-            else BBox()
-        )
-        pose = (
-            Pose3D.from_dict(summary[0]["keypoints"])
-            if summary[0].get("keypoints")
-            else Pose3D()
-        )
+        if summary[0].get("box"):
+            assert isinstance(summary[0]["box"], dict)
+            box = BBox.from_dict(summary[0]["box"], title=name)
+        else:
+            box = BBox()
+        if summary[0].get("keypoints"):
+            assert isinstance(summary[0]["keypoints"], dict)
+            pose = Pose3D.from_dict(summary[0]["keypoints"])
+        else:
+            pose = Pose3D()
         return YoloPose(
             cls=summary[0]["class"],
             name=name,
@@ -103,9 +103,11 @@ class YoloPoses(DataModel):
                 names.append(name)
                 confidence.append(s["confidence"])
                 if s.get("box"):
-                    box.append(BBox.from_dict(s.get("box"), title=name))
+                    assert isinstance(s["box"], dict)
+                    box.append(BBox.from_dict(s["box"], title=name))
                 if s.get("keypoints"):
-                    pose.append(Pose3D.from_dict(s.get("keypoints")))
+                    assert isinstance(s["keypoints"], dict)
+                    pose.append(Pose3D.from_dict(s["keypoints"]))
         return YoloPoses(
             cls=cls,
             name=names,

datachain/model/ultralytics/segment.py

@@ -34,16 +34,16 @@ class YoloSegment(DataModel):
         if not summary:
             return YoloSegment(box=BBox(), segment=Segment())
         name = summary[0].get("name", "")
-        box = (
-            BBox.from_dict(summary[0]["box"], title=name)
-            if summary[0].get("box")
-            else BBox()
-        )
-        segment = (
-            Segment.from_dict(summary[0]["segments"], title=name)
-            if summary[0].get("segments")
-            else Segment()
-        )
+        if summary[0].get("box"):
+            assert isinstance(summary[0]["box"], dict)
+            box = BBox.from_dict(summary[0]["box"], title=name)
+        else:
+            box = BBox()
+        if summary[0].get("segments"):
+            assert isinstance(summary[0]["segments"], dict)
+            segment = Segment.from_dict(summary[0]["segments"], title=name)
+        else:
+            segment = Segment()
         return YoloSegment(
             cls=summary[0]["class"],
             name=summary[0]["name"],
@@ -81,9 +81,11 @@ class YoloSegments(DataModel):
                 names.append(name)
                 confidence.append(s["confidence"])
                 if s.get("box"):
-                    box.append(BBox.from_dict(s.get("box"), title=name))
+                    assert isinstance(s["box"], dict)
+                    box.append(BBox.from_dict(s["box"], title=name))
                 if s.get("segments"):
-                    segment.append(Segment.from_dict(s.get("segments"), title=name))
+                    assert isinstance(s["segments"], dict)
+                    segment.append(Segment.from_dict(s["segments"], title=name))
         return YoloSegments(
             cls=cls,
             name=names,

datachain/query/dataset.py

@@ -1703,16 +1703,18 @@ class DatasetQuery:
                 for dep in self.catalog.get_dataset_dependencies(
                     dep_dataset.name,
                     dep_dataset_version,
-                    dep_dataset.project,
+                    namespace_name=dep_dataset.project.namespace.name,
+                    project_name=dep_dataset.project.name,
                     indirect=False,
                 ):
                     if dep:
-                        dep_project = self.catalog.metastore.get_project(
-                            dep.project, dep.namespace
-                        )
                         dependencies.add(
                             (
-                                self.catalog.get_dataset(dep.name, dep_project),
+                                self.catalog.get_dataset(
+                                    dep.name,
+                                    namespace_name=dep.namespace,
+                                    project_name=dep.project,
+                                ),
                                 dep.version,
                             )
                         )
@@ -1754,7 +1756,11 @@ class DatasetQuery:
             if (
                 name
                 and version
-                and self.catalog.get_dataset(name, project).has_version(version)
+                and self.catalog.get_dataset(
+                    name,
+                    namespace_name=project.namespace.name,
+                    project_name=project.name,
+                ).has_version(version)
             ):
                 raise RuntimeError(f"Dataset {name} already has version {version}")
         except DatasetNotFoundError:
@@ -1808,11 +1814,15 @@ class DatasetQuery:
                 # overriding dependencies
                 self.dependencies = set()
                 for dep in dependencies:
-                    dep_project = self.catalog.metastore.get_project(
-                        dep.project, dep.namespace
-                    )
                     self.dependencies.add(
-                        (self.catalog.get_dataset(dep.name, dep_project), dep.version)
+                        (
+                            self.catalog.get_dataset(
+                                dep.name,
+                                namespace_name=dep.namespace,
+                                project_name=dep.project,
+                            ),
+                            dep.version,
+                        )
                     )
 
             self._add_dependencies(dataset, version)  # type: ignore [arg-type]

datachain/sql/__init__.py

@@ -1,6 +1,8 @@
 from sqlalchemy.sql.elements import literal
 from sqlalchemy.sql.expression import column
 
+# Import PostgreSQL dialect registration (registers PostgreSQL type converter)
+from . import postgresql_dialect  # noqa: F401
 from .default import setup as default_setup
 from .selectable import select, values
 

datachain/sql/postgresql_dialect.py

@@ -0,0 +1,9 @@
+"""
+PostgreSQL dialect registration for DataChain.
+"""
+
+from datachain.sql.postgresql_types import PostgreSQLTypeConverter
+from datachain.sql.types import register_backend_types
+
+# Register PostgreSQL type converter
+register_backend_types("postgresql", PostgreSQLTypeConverter())

datachain/sql/postgresql_types.py

@@ -0,0 +1,21 @@
+"""
+PostgreSQL-specific type converter for DataChain.
+
+Handles PostgreSQL-specific type mappings that differ from the default dialect.
+"""
+
+from sqlalchemy.dialects import postgresql
+
+from datachain.sql.types import TypeConverter
+
+
+class PostgreSQLTypeConverter(TypeConverter):
+    """PostgreSQL-specific type converter."""
+
+    def datetime(self):
+        """PostgreSQL uses TIMESTAMP WITH TIME ZONE to preserve timezone information."""
+        return postgresql.TIMESTAMP(timezone=True)
+
+    def json(self):
+        """PostgreSQL uses JSONB for better performance and query capabilities."""
+        return postgresql.JSONB()

datachain/sql/sqlite/__init__.py

@@ -1,4 +1,8 @@
-from .base import create_user_defined_sql_functions, setup, sqlite_dialect
+from .base import (
+    create_user_defined_sql_functions,
+    setup,
+    sqlite_dialect,
+)
 
 __all__ = [
     "create_user_defined_sql_functions",

datachain/sql/sqlite/base.py

@@ -304,7 +304,11 @@ def register_user_defined_sql_functions() -> None:
 
 
 def adapt_datetime(val: datetime) -> str:
-    if not (val.tzinfo is timezone.utc or val.tzname() == "UTC"):
+    is_utc_check = val.tzinfo is timezone.utc
+    tzname_check = val.tzname() == "UTC"
+    combined_check = is_utc_check or tzname_check
+
+    if not combined_check:
         try:
             val = val.astimezone(timezone.utc)
         except (OverflowError, ValueError, OSError):
@@ -314,6 +318,7 @@ def adapt_datetime(val: datetime) -> str:
                 val = datetime.min.replace(tzinfo=timezone.utc)
             else:
                 raise
+
     return val.replace(tzinfo=None).isoformat(" ")
 
 

datachain/sql/types.py

@@ -58,9 +58,14 @@ def converter(dialect) -> "TypeConverter":
     try:
         return registry[name]
     except KeyError:
-        raise ValueError(
-            f"No type converter registered for dialect: {dialect.name!r}"
-        ) from None
+        # Fall back to default converter if specific dialect not found
+        try:
+            return registry["default"]
+        except KeyError:
+            raise ValueError(
+                f"No type converter registered for dialect: {dialect.name!r} "
+                f"and no default converter available"
+            ) from None
 
 
 def read_converter(dialect) -> "TypeReadConverter":
@@ -68,9 +73,14 @@ def read_converter(dialect) -> "TypeReadConverter":
     try:
         return read_converter_registry[name]
     except KeyError:
-        raise ValueError(
-            f"No read type converter registered for dialect: {dialect.name!r}"
-        ) from None
+        # Fall back to default converter if specific dialect not found
+        try:
+            return read_converter_registry["default"]
+        except KeyError:
+            raise ValueError(
+                f"No read type converter registered for dialect: {dialect.name!r} "
+                f"and no default converter available"
+            ) from None
 
 
 def type_defaults(dialect) -> "TypeDefaults":
@@ -78,7 +88,14 @@ def type_defaults(dialect) -> "TypeDefaults":
     try:
         return type_defaults_registry[name]
     except KeyError:
-        raise ValueError(f"No type defaults registered for dialect: {name!r}") from None
+        # Fall back to default converter if specific dialect not found
+        try:
+            return type_defaults_registry["default"]
+        except KeyError:
+            raise ValueError(
+                f"No type defaults registered for dialect: {dialect.name!r} "
+                f"and no default converter available"
+            ) from None
 
 
 def db_defaults(dialect) -> "DBDefaults":
@@ -86,7 +103,14 @@ def db_defaults(dialect) -> "DBDefaults":
     try:
         return db_defaults_registry[name]
     except KeyError:
-        raise ValueError(f"No DB defaults registered for dialect: {name!r}") from None
+        # Fall back to default converter if specific dialect not found
+        try:
+            return db_defaults_registry["default"]
+        except KeyError:
+            raise ValueError(
+                f"No DB defaults registered for dialect: {dialect.name!r} "
+                f"and no default converter available"
+            ) from None
 
 
 class SQLType(TypeDecorator):

{datachain-0.30.1.dist-info → datachain-0.30.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datachain
-Version: 0.30.1
+Version: 0.30.3
 Summary: Wrangle unstructured AI data at scale
 Author-email: Dmitry Petrov <support@dvc.org>
 License-Expression: Apache-2.0
@@ -45,7 +45,7 @@ Requires-Dist: datamodel-code-generator>=0.25
 Requires-Dist: Pillow<12,>=10.0.0
 Requires-Dist: msgpack<2,>=1.0.4
 Requires-Dist: psutil
-Requires-Dist: huggingface_hub<0.34.0
+Requires-Dist: huggingface_hub
 Requires-Dist: iterative-telemetry>=0.0.10
 Requires-Dist: platformdirs
 Requires-Dist: dvc-studio-client<1,>=0.21
@@ -81,8 +81,10 @@ Provides-Extra: video
 Requires-Dist: ffmpeg-python; extra == "video"
 Requires-Dist: imageio[ffmpeg,pyav]>=2.37.0; extra == "video"
 Requires-Dist: opencv-python; extra == "video"
+Provides-Extra: postgres
+Requires-Dist: psycopg2-binary>=2.9.0; extra == "postgres"
 Provides-Extra: tests
-Requires-Dist: datachain[audio,hf,remote,torch,vector,video]; extra == "tests"
+Requires-Dist: datachain[audio,hf,postgres,remote,torch,vector,video]; extra == "tests"
 Requires-Dist: pytest<9,>=8; extra == "tests"
 Requires-Dist: pytest-sugar>=0.9.6; extra == "tests"
 Requires-Dist: pytest-cov>=4.1.0; extra == "tests"
@@ -90,6 +92,7 @@ Requires-Dist: pytest-mock>=3.12.0; extra == "tests"
 Requires-Dist: pytest-servers[all]>=0.5.9; extra == "tests"
 Requires-Dist: pytest-benchmark[histogram]; extra == "tests"
 Requires-Dist: pytest-xdist>=3.3.1; extra == "tests"
+Requires-Dist: pytest-env>=1.1.0; extra == "tests"
 Requires-Dist: virtualenv; extra == "tests"
 Requires-Dist: dulwich; extra == "tests"
 Requires-Dist: hypothesis; extra == "tests"

{datachain-0.30.1.dist-info → datachain-0.30.3.dist-info}/RECORD

@@ -4,10 +4,10 @@ datachain/asyn.py,sha256=RH_jFwJcTXxhEFomaI9yL6S3Onau6NZ6FSKfKFGtrJE,9689
 datachain/cache.py,sha256=ESVRaCJXEThMIfGEFVHx6wJPOZA7FYk9V6WxjyuqUBY,3626
 datachain/config.py,sha256=g8qbNV0vW2VEKpX-dGZ9pAn0DAz6G2ZFcr7SAV3PoSM,4272
 datachain/dataset.py,sha256=ATGa-CBTFoZeTN2V40-zHEzfMBcdYK0WuoJ6H2yEAvo,25268
-datachain/delta.py,sha256=fTEhCedseUsHuH_Ek52NXFhFPyFD_6MioEH5sCilNgo,9897
+datachain/delta.py,sha256=dghGvD44LcglvL5-kUOIKk75ywBO0U7eikA3twKZC28,10202
 datachain/error.py,sha256=OWwWMkzZYJrkcoEDGhJHMf7SfKvxcsOLRF94mjPf29I,1609
 datachain/job.py,sha256=x5PB6d5sqx00hePNNkirESlOVAvnmkEM5ygUgQmAhsk,1262
-datachain/listing.py,sha256=GuUlj3oYJQOIbLYr3IqNCSeuiU5pfOtRAQQl9uBEFQU,7458
+datachain/listing.py,sha256=aqayl5St3D9PwdwM6nR1STkpLSw-S3U8pudO9PWi3N8,7241
 datachain/namespace.py,sha256=MozcXYxedIbamzY56YKy9r9fgSpOm2VryhWfIf6stYk,1791
 datachain/node.py,sha256=KWDT0ClYXB7FYI-QOvzAa-UDkLJErUI2eWm5FBteYuU,5577
 datachain/nodes_fetcher.py,sha256=_wgaKyqEjkqdwJ_Hj6D8vUYz7hnU7g6xhm0H6ZnYxmE,1095
@@ -21,13 +21,13 @@ datachain/studio.py,sha256=27750qCSNxIChEzhV02damIFreLMfr7UdiWqMFyk8AA,15361
 datachain/telemetry.py,sha256=0A4IOPPp9VlP5pyW9eBfaTK3YhHGzHl7dQudQjUAx9A,994
 datachain/utils.py,sha256=Gp5JVr_m7nVWQGDOjrGnZjRXF9-Ai-MBxiPJIcpPvWQ,15451
 datachain/catalog/__init__.py,sha256=cMZzSz3VoUi-6qXSVaHYN-agxQuAcz2XSqnEPZ55crE,353
-datachain/catalog/catalog.py,sha256=QTWCXy75iWo-0MCXyfV_WbsKeZ1fpLpvL8d60rxn1ws,65528
+datachain/catalog/catalog.py,sha256=vy5k0ME9FxDnpV5D9Ry0YT8eRAKZglUDdyePslJSBpk,67174
 datachain/catalog/datasource.py,sha256=IkGMh0Ttg6Q-9DWfU_H05WUnZepbGa28HYleECi6K7I,1353
 datachain/catalog/loader.py,sha256=B2cps5coFE4MBttM-j8cs7JgNVPjnHKF4Gx1s2fJrxw,6119
 datachain/cli/__init__.py,sha256=migILaB4-dSSlxEoi6MYOGhOg2jpZo3a2AhS3mSuN8o,8237
 datachain/cli/utils.py,sha256=wrLnAh7Wx8O_ojZE8AE4Lxn5WoxHbOj7as8NWlLAA74,3036
 datachain/cli/commands/__init__.py,sha256=zp3bYIioO60x_X04A4-IpZqSYVnpwOa1AdERQaRlIhI,493
-datachain/cli/commands/datasets.py,sha256=LfOe22O9OCEDI8K2cy05Gp4_Q-GFHOHRv4bXQ-USM4s,6472
+datachain/cli/commands/datasets.py,sha256=m8aTlUMpYCZmfSwhp7Lb_UFaQRQm_kOWXh71bNBn7qQ,6461
 datachain/cli/commands/du.py,sha256=9edEzDEs98K2VYk8Wf-ZMpUzALcgm9uD6YtoqbvtUGU,391
 datachain/cli/commands/index.py,sha256=eglNaIe1yyIadUHHumjtNbgIjht6kme7SS7xE3YHR88,198
 datachain/cli/commands/ls.py,sha256=CBmk838Q-EQp04lE2Qdnpsc1GXAkC4-I-b-a_828n1E,5272
@@ -49,7 +49,7 @@ datachain/client/s3.py,sha256=6DNVGLg-woPS1DVlYVX2rIlunNblsuxyOnI1rSzhW3k,7515
 datachain/data_storage/__init__.py,sha256=9Wit-oe5P46V7CJQTD0BJ5MhOa2Y9h3ddJ4VWTe-Lec,273
 datachain/data_storage/db_engine.py,sha256=n8ojCbvVMPY2e3SG8fUaaD0b9GkVfpl_Naa_6EiHfWg,3788
 datachain/data_storage/job.py,sha256=ZkeXCNUj_VCkoKYx29hqB4AcfVUielnRjY-GYUcUxt4,426
-datachain/data_storage/metastore.py,sha256=Qw332arvhgXB4UY0yX-Hu8Vgl3smU12l6bvxrL9Q-vo,53810
+datachain/data_storage/metastore.py,sha256=0-myih2VtUm_gcwz8bNgnP2h0rBkBl6v1IEhduShb4w,54517
 datachain/data_storage/schema.py,sha256=o3JbURKXRg3IJyIVA4QjHHkn6byRuz7avbydU2FlvNY,9897
 datachain/data_storage/serializer.py,sha256=6G2YtOFqqDzJf1KbvZraKGXl2XHZyVml2krunWUum5o,927
 datachain/data_storage/sqlite.py,sha256=TTQjdDXUaZSr3MEaxZjDhsVIkIJqxFNA-sD25TO3m_4,30228
@@ -67,7 +67,7 @@ datachain/func/func.py,sha256=fpslnn4edr0dH3mD8BSTndRFJiiVZvbJoBJV6HkHMqw,17400
 datachain/func/numeric.py,sha256=J6FgzuIAcS6B02Cm1qPnJdB6ut21jyBDVXSBrkZNZaQ,6978
 datachain/func/path.py,sha256=9Jas35QhEtRai4l54hMqVvuJsqxHvOx88oo4vym1H_I,4077
 datachain/func/random.py,sha256=t7jwXsI8-hy0qAdvjAntgzy-AHtTAfozlZ1CpKR-QZE,458
-datachain/func/string.py,sha256=X9u4ip97U63RCaKRhMddoze7HgPiY3LbPRn9G06UWWo,7311
+datachain/func/string.py,sha256=6-fZM7wHv0JZ2ZzpLFPLLYW15K_CT5VfYsmx56zBrpA,7419
 datachain/func/window.py,sha256=ImyRpc1QI8QUSPO7KdD60e_DPVo7Ja0G5kcm6BlyMcw,1584
 datachain/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datachain/lib/arrow.py,sha256=geoLvyDd5uMqS3D9Ec1ODlShCUAdtwHUwl8FqbUX_hg,10776
@@ -103,9 +103,9 @@ datachain/lib/convert/unflatten.py,sha256=ysMkstwJzPMWUlnxn-Z-tXJR3wmhjHeSN_P-sD
 datachain/lib/convert/values_to_tuples.py,sha256=j5yZMrVUH6W7b-7yUvdCTGI7JCUAYUOzHUGPoyZXAB0,4360
 datachain/lib/dc/__init__.py,sha256=TFci5HTvYGjBesNUxDAnXaX36PnzPEUSn5a6JxB9o0U,872
 datachain/lib/dc/csv.py,sha256=q6a9BpapGwP6nwy6c5cklxQumep2fUp9l2LAjtTJr6s,4411
-datachain/lib/dc/database.py,sha256=MPE-KzwcR2DhWLCEbl1gWFp63dLqjWuiJ1iEfC2BrJI,12443
-datachain/lib/dc/datachain.py,sha256=_C9PZjUHVewpdp94AR2GS3QEI96Svsyx52dLJVM4tm4,98143
-datachain/lib/dc/datasets.py,sha256=P6CIJizD2IYFwOQG5D3VbQRjDmUiRH0ysdtb551Xdm8,15098
+datachain/lib/dc/database.py,sha256=F6EOjPKwSdp26kJsOKGq49D9OxqyKEalINHEwLQav2s,14716
+datachain/lib/dc/datachain.py,sha256=sfLT_iMGkNsPh5JAPzRATyC4hsotp34bDS0rSu2NQ10,99244
+datachain/lib/dc/datasets.py,sha256=jRwfHUUESlNdK1heUNxb-V10ZobRJYPbvCqYYkz2FYI,15240
 datachain/lib/dc/hf.py,sha256=AP_MUHg6HJWae10PN9hD_beQVjrl0cleZ6Cvhtl1yoI,2901
 datachain/lib/dc/json.py,sha256=dNijfJ-H92vU3soyR7X1IiDrWhm6yZIGG3bSnZkPdAE,2733
 datachain/lib/dc/listings.py,sha256=V379Cb-7ZyquM0w7sWArQZkzInZy4GB7QQ1ZfowKzQY,4544
@@ -121,12 +121,12 @@ datachain/model/pose.py,sha256=rjquA6M-I-Y30Xm6YSkGv1OY52hJZmR2AuxbIpE5uD0,3865
 datachain/model/segment.py,sha256=NhcEYB_KVa0aLQYiZ4jEwkylH9QBLd8fZhmg6PVnx1Y,1967
 datachain/model/utils.py,sha256=5elwCKleOO6CZM0IuWjFykPekrhc5m7V4jSIOcgGMms,6733
 datachain/model/ultralytics/__init__.py,sha256=EvcNX9qUyxKXXlKCPpsXeRrabyXk5E9EkN-tyiYkfS4,750
-datachain/model/ultralytics/bbox.py,sha256=vxrqu7poIgPD0V2iuy26F74YCKr3s-CFKibPOAbGS40,4570
-datachain/model/ultralytics/pose.py,sha256=pBlmt63Qe68FKmexHimUGlNbNOoOlMHXG4fzXZ9edh8,3185
-datachain/model/ultralytics/segment.py,sha256=63bDCj43E6iZ0hFI5J6uQfksdCmjEp6sEm1XzVaE8pw,2986
+datachain/model/ultralytics/bbox.py,sha256=C-aDiBhVa_ML2oERWvksRkyMU1XuYSpb6eItHB5q0qc,4764
+datachain/model/ultralytics/pose.py,sha256=pvoXrWWUSWT_UBaMwUb5MBHAY57Co2HFDPigFYNZWUA,3392
+datachain/model/ultralytics/segment.py,sha256=v9_xDxd5zw_I8rXsbl7yQXgEdTs2T38zyY_Y4XGN8ok,3194
 datachain/query/__init__.py,sha256=7DhEIjAA8uZJfejruAVMZVcGFmvUpffuZJwgRqNwe-c,263
 datachain/query/batch.py,sha256=-goxLpE0EUvaDHu66rstj53UnfHpYfBUGux8GSpJ93k,4306
-datachain/query/dataset.py,sha256=hUKKHuqkfNaojzOt6rMIksU-PG72i_lfbKSHZ5rt--M,62715
+datachain/query/dataset.py,sha256=qMVySOlyDm3b-zpF7z_DGeeCfltH7YSGwB7HYYmNhBU,63081
 datachain/query/dispatch.py,sha256=A0nPxn6mEN5d9dDo6S8m16Ji_9IvJLXrgF2kqXdi4fs,15546
 datachain/query/metrics.py,sha256=DOK5HdNVaRugYPjl8qnBONvTkwjMloLqAr7Mi3TjCO0,858
 datachain/query/params.py,sha256=O_j89mjYRLOwWNhYZl-z7mi-rkdP7WyFmaDufsdTryE,863
@@ -137,9 +137,11 @@ datachain/query/udf.py,sha256=e753bDJzTNjGFQn1WGTvOAWSwjDbrFI1-_DDWkWN2ls,1343
 datachain/query/utils.py,sha256=a2PTBZ3qsG6XlUcp9XsoGiQfKkca4Q3m-VzFgiGQPAc,1230
 datachain/remote/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datachain/remote/studio.py,sha256=pDThxvEEpIKVGfa9rmtz_zeqHwrgzh0Lv-Pd4wzDx5k,15448
-datachain/sql/__init__.py,sha256=6SQRdbljO3d2hx3EAVXEZrHQKv5jth0Jh98PogT59No,262
+datachain/sql/__init__.py,sha256=8D2omsBiATt8bjLjGo6jBEtaKEkOlnlNFWhVryHMDv0,388
+datachain/sql/postgresql_dialect.py,sha256=pDTfH8xaXz5xZsq8O1aQUvWLRIv_ogYeAqtmKlPp3Rw,280
+datachain/sql/postgresql_types.py,sha256=ryb_0lzuA9UOJ_B6nW9Yb8nJjzeSmEItAL_Ceue65lc,627
 datachain/sql/selectable.py,sha256=cTc60qVoAwqqss0Vop8Lt5Z-ROnM1XrQmL_GLjRxhXs,1765
-datachain/sql/types.py,sha256=ASSPkmM5EzdRindqj2O7WHLXq8VHAgFYedG8lYfGvVI,14045
+datachain/sql/types.py,sha256=RWOghtYFx14K-e71QOGg5yfKb-A4-4JgFjaJ0wCZ17Y,15006
 datachain/sql/utils.py,sha256=rzlJw08etivdrcuQPqNVvVWhuVSyUPUQEEc6DOhu258,818
 datachain/sql/default/__init__.py,sha256=XQ2cEZpzWiABqjV-6yYHUBGI9vN_UHxbxZENESmVAWw,45
 datachain/sql/default/base.py,sha256=QD-31C6JnyOXzogyDx90sUhm7QvgXIYpeHEASH84igU,628
@@ -151,16 +153,16 @@ datachain/sql/functions/numeric.py,sha256=BK2KCiPSgM2IveCq-9M_PG3CtPBlztaS9TTn1L
 datachain/sql/functions/path.py,sha256=zixpERotTFP6LZ7I4TiGtyRA8kXOoZmH1yzH9oRW0mg,1294
 datachain/sql/functions/random.py,sha256=vBwEEj98VH4LjWixUCygQ5Bz1mv1nohsCG0-ZTELlVg,271
 datachain/sql/functions/string.py,sha256=E-T9OIzUR-GKaLgjZsEtg5CJrY_sLf1lt1awTvY7w2w,1426
-datachain/sql/sqlite/__init__.py,sha256=TAdJX0Bg28XdqPO-QwUVKy8rg78cgMileHvMNot7d04,166
-datachain/sql/sqlite/base.py,sha256=ldyWoMBvrYH789GK8xE4wbBNYxz4B-g4BmQAK6_KjR0,21398
+datachain/sql/sqlite/__init__.py,sha256=PsLaDSij9a03VxGSpagpNl7NQsGtgm72ArUeALZONoc,183
+datachain/sql/sqlite/base.py,sha256=6aoQHeggY3hs31_YZ-wlYKA1Lto4MFOpgfgRspH6IMc,21498
 datachain/sql/sqlite/types.py,sha256=cH6oge2E_YWFy22wY-txPJH8gxoQFSpCthtZR8PZjpo,1849
 datachain/sql/sqlite/vector.py,sha256=ncW4eu2FlJhrP_CIpsvtkUabZlQdl2D5Lgwy_cbfqR0,469
 datachain/toolkit/__init__.py,sha256=eQ58Q5Yf_Fgv1ZG0IO5dpB4jmP90rk8YxUWmPc1M2Bo,68
 datachain/toolkit/split.py,sha256=ktGWzY4kyzjWyR86dhvzw-Zhl0lVk_LOX3NciTac6qo,2914
 datachain/torch/__init__.py,sha256=gIS74PoEPy4TB3X6vx9nLO0Y3sLJzsA8ckn8pRWihJM,579
-datachain-0.30.1.dist-info/licenses/LICENSE,sha256=8DnqK5yoPI_E50bEg_zsHKZHY2HqPy4rYN338BHQaRA,11344
-datachain-0.30.1.dist-info/METADATA,sha256=kSCxhbIsJRF2S21DGPAGzsZw89sp_Ice1ytw0y2yYN8,13766
-datachain-0.30.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-datachain-0.30.1.dist-info/entry_points.txt,sha256=0GMJS6B_KWq0m3VT98vQI2YZodAMkn4uReZ_okga9R4,49
-datachain-0.30.1.dist-info/top_level.txt,sha256=lZPpdU_2jJABLNIg2kvEOBi8PtsYikbN1OdMLHk8bTg,10
-datachain-0.30.1.dist-info/RECORD,,
+datachain-0.30.3.dist-info/licenses/LICENSE,sha256=8DnqK5yoPI_E50bEg_zsHKZHY2HqPy4rYN338BHQaRA,11344
+datachain-0.30.3.dist-info/METADATA,sha256=TataasDxkiKnymsMaLxda_Cp0DhYE_FhUMA8CKBXCgg,13903
+datachain-0.30.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+datachain-0.30.3.dist-info/entry_points.txt,sha256=0GMJS6B_KWq0m3VT98vQI2YZodAMkn4uReZ_okga9R4,49
+datachain-0.30.3.dist-info/top_level.txt,sha256=lZPpdU_2jJABLNIg2kvEOBi8PtsYikbN1OdMLHk8bTg,10
+datachain-0.30.3.dist-info/RECORD,,