datachain 0.32.0__py3-none-any.whl → 0.32.2__py3-none-any.whl

datachain/__init__.py

@@ -37,7 +37,7 @@ from datachain.lib.file import (
     VideoFrame,
 )
 from datachain.lib.model_store import ModelStore
-from datachain.lib.namespaces import delete as delete_namespace
+from datachain.lib.namespaces import delete_namespace
 from datachain.lib.projects import create as create_project
 from datachain.lib.udf import Aggregator, Generator, Mapper
 from datachain.lib.utils import AbstractUDF, DataChainError

datachain/dataset.py

@@ -619,7 +619,7 @@ class DatasetRecord:
         if not self.versions:
             return "1.0.0"
 
-        major, minor, patch = semver.parse(self.latest_version)
+        major, _, _ = semver.parse(self.latest_version)
         return semver.create(major + 1, 0, 0)
 
     @property
@@ -630,7 +630,7 @@ class DatasetRecord:
         if not self.versions:
             return "1.0.0"
 
-        major, minor, patch = semver.parse(self.latest_version)
+        major, minor, _ = semver.parse(self.latest_version)
         return semver.create(major, minor + 1, 0)
 
     @property

datachain/lib/convert/python_to_sql.py

@@ -1,8 +1,14 @@
 import inspect
+import sys
 from datetime import datetime
 from enum import Enum
 from typing import Annotated, Literal, Union, get_args, get_origin
 
+if sys.version_info >= (3, 10):
+    from types import UnionType
+else:
+    UnionType = None
+
 from pydantic import BaseModel
 from typing_extensions import Literal as LiteralEx
 
@@ -34,6 +40,13 @@ PYTHON_TO_SQL = {
 }
 
 
+def _is_union(orig) -> bool:
+    if orig == Union:
+        return True
+    # some code is unreachab in python<3.10
+    return UnionType is not None and orig is UnionType  # type: ignore[unreachable]
+
+
 def python_to_sql(typ):  # noqa: PLR0911
     if inspect.isclass(typ):
         if issubclass(typ, SQLType):
@@ -69,9 +82,10 @@ def python_to_sql(typ):  # noqa: PLR0911
     if inspect.isclass(orig) and issubclass(dict, orig):
         return JSON
 
-    if orig == Union:
+    if _is_union(orig):
         if len(args) == 2 and (type(None) in args):
-            return python_to_sql(args[0])
+            non_none_arg = args[0] if args[0] is not type(None) else args[1]
+            return python_to_sql(non_none_arg)
 
         if _is_union_str_literal(orig, args):
             return String
@@ -95,7 +109,7 @@ def list_of_args_to_type(args) -> SQLType:
 
 
 def _is_json_inside_union(orig, args) -> bool:
-    if orig == Union and len(args) >= 2:
+    if _is_union(orig) and len(args) >= 2:
         # List in JSON: Union[dict, list[dict]]
         args_no_nones = [arg for arg in args if arg != type(None)]  # noqa: E721
         if len(args_no_nones) == 2:
@@ -112,6 +126,6 @@ def _is_json_inside_union(orig, args) -> bool:
 
 
 def _is_union_str_literal(orig, args) -> bool:
-    if orig != Union:
+    if not _is_union(orig):
         return False
     return all(arg is str or get_origin(arg) in (Literal, LiteralEx) for arg in args)

datachain/lib/dc/parquet.py

@@ -26,8 +26,14 @@ def read_parquet(
     """Generate chain from parquet files.
 
     Parameters:
-        path: Storage URI with directory. URI must start with storage prefix such
-            as `s3://`, `gs://`, `az://` or "file:///".
+        path: Storage path(s) or URI(s). Can be a local path or start with a
+            storage prefix like `s3://`, `gs://`, `az://`, `hf://` or "file:///".
+            Supports glob patterns:
+              - `*` : wildcard
+              - `**` : recursive wildcard
+              - `?` : single character
+              - `{a,b}` : brace expansion list
+              - `{1..9}` : brace numeric or alphabetic range
         partitioning: Any pyarrow partitioning schema.
         output: Dictionary defining column names and their corresponding types.
         column: Created column name.
@@ -43,10 +49,19 @@ def read_parquet(
         dc.read_parquet("s3://mybucket/file.parquet")
         ```
 
-        Reading a partitioned dataset from a directory:
+        All files from a directory:
         ```py
-        import datachain as dc
-        dc.read_parquet("s3://mybucket/dir")
+        dc.read_parquet("s3://mybucket/dir/")
+        ```
+
+        Only parquet files from a directory, and all it's subdirectories:
+        ```py
+        dc.read_parquet("s3://mybucket/dir/**/*.parquet")
+        ```
+
+        Using filename patterns - numeric, list, starting with zeros:
+        ```py
+        dc.read_parquet("s3://mybucket/202{1..4}/{yellow,green}-{01..12}.parquet")
         ```
     """
     from .storage import read_storage

datachain/lib/dc/storage.py

@@ -51,7 +51,8 @@ def read_storage(
               - `*` : wildcard
               - `**` : recursive wildcard
               - `?` : single character
-              - `{a,b}` : brace expansion
+              - `{a,b}` : brace expansion list
+              - `{1..9}` : brace numeric or alphabetic range
         type: read file as "binary", "text", or "image" data. Default is "binary".
         recursive: search recursively for the given path.
         column: Column name that will contain File objects. Default is "file".
@@ -88,27 +89,32 @@ def read_storage(
         Simple call from s3:
         ```python
         import datachain as dc
-        chain = dc.read_storage("s3://my-bucket/my-dir")
+        dc.read_storage("s3://my-bucket/my-dir")
         ```
 
         Match all .json files recursively using glob pattern
         ```py
-        chain = dc.read_storage("gs://bucket/meta/**/*.json")
+        dc.read_storage("gs://bucket/meta/**/*.json")
         ```
 
         Match image file extensions for directories with pattern
         ```py
-        chain = dc.read_storage("s3://bucket/202?/**/*.{jpg,jpeg,png}")
+        dc.read_storage("s3://bucket/202?/**/*.{jpg,jpeg,png}")
+        ```
+
+        By ranges in filenames:
+        ```py
+        dc.read_storage("s3://bucket/202{1..4}/**/*.{jpg,jpeg,png}")
         ```
 
         Multiple URIs:
         ```python
-        chain = dc.read_storage(["s3://my-bkt/dir1", "s3://bucket2/dir2/dir3"])
+        dc.read_storage(["s3://my-bkt/dir1", "s3://bucket2/dir2/dir3"])
         ```
 
         With AWS S3-compatible storage:
         ```python
-        chain = dc.read_storage(
+        dc.read_storage(
             "s3://my-bucket/my-dir",
             client_config = {"aws_endpoint_url": "<minio-endpoint-url>"}
         )

datachain/lib/dc/storage_pattern.py

@@ -12,61 +12,37 @@ def validate_cloud_bucket_name(uri: str) -> None:
     """
     Validate that cloud storage bucket names don't contain glob patterns.
 
-    Args:
-        uri: URI to validate
-
     Raises:
         ValueError: If a cloud storage bucket name contains glob patterns
     """
     if not is_cloud_uri(uri):
         return
 
-    # Extract bucket name (everything between :// and first /)
     if "://" in uri:
         scheme_end = uri.index("://") + 3
         path_part = uri[scheme_end:]
 
-        # Get the bucket name (first segment)
         if "/" in path_part:
             bucket_name = path_part.split("/")[0]
         else:
             bucket_name = path_part
 
-        # Check if bucket name contains glob patterns
         glob_chars = ["*", "?", "[", "]", "{", "}"]
         if any(char in bucket_name for char in glob_chars):
             raise ValueError(f"Glob patterns in bucket names are not supported: {uri}")
 
 
 def split_uri_pattern(uri: str) -> tuple[str, Union[str, None]]:
-    """
-    Split a URI into base path and glob pattern.
-
-    Args:
-        uri: URI that may contain glob patterns (*, **, ?, {})
-
-    Returns:
-        Tuple of (base_uri, pattern) where pattern is None if no glob pattern found
-
-    Examples:
-        "s3://bucket/dir/*.mp3" -> ("s3://bucket/dir", "*.mp3")
-        "s3://bucket/**/*.mp3" -> ("s3://bucket", "**/*.mp3")
-        "s3://bucket/dir" -> ("s3://bucket/dir", None)
-    """
+    """Split a URI into base path and glob pattern."""
     if not any(char in uri for char in ["*", "?", "[", "{", "}"]):
         return uri, None
 
-    # Handle different URI schemes
     if "://" in uri:
-        # Split into scheme and path
         scheme_end = uri.index("://") + 3
         scheme_part = uri[:scheme_end]
         path_part = uri[scheme_end:]
-
-        # Find where the glob pattern starts
         path_segments = path_part.split("/")
 
-        # Find first segment with glob pattern
         pattern_start_idx = None
         for i, segment in enumerate(path_segments):
             # Check for glob patterns including brace expansion
@@ -77,9 +53,7 @@ def split_uri_pattern(uri: str) -> tuple[str, Union[str, None]]:
         if pattern_start_idx is None:
             return uri, None
 
-        # Split into base and pattern
         if pattern_start_idx == 0:
-            # Pattern at root of bucket
             base = scheme_part + path_segments[0]
             pattern = "/".join(path_segments[1:]) if len(path_segments) > 1 else "*"
         else:
@@ -87,13 +61,11 @@ def split_uri_pattern(uri: str) -> tuple[str, Union[str, None]]:
             pattern = "/".join(path_segments[pattern_start_idx:])
 
         return base, pattern
-    # Local path
+
     path_segments = uri.split("/")
 
-    # Find first segment with glob pattern
     pattern_start_idx = None
     for i, segment in enumerate(path_segments):
-        # Check for glob patterns including brace expansion
         if glob.has_magic(segment) or "{" in segment:
             pattern_start_idx = i
             break
@@ -101,7 +73,6 @@ def split_uri_pattern(uri: str) -> tuple[str, Union[str, None]]:
     if pattern_start_idx is None:
         return uri, None
 
-    # Split into base and pattern
     base = "/".join(path_segments[:pattern_start_idx]) if pattern_start_idx > 0 else "/"
     pattern = "/".join(path_segments[pattern_start_idx:])
 
@@ -109,51 +80,30 @@ def split_uri_pattern(uri: str) -> tuple[str, Union[str, None]]:
 
 
 def should_use_recursion(pattern: str, user_recursive: bool) -> bool:
-    """
-    Determine if we should use recursive listing based on the pattern.
-
-    Args:
-        pattern: The glob pattern extracted from URI
-        user_recursive: User's recursive preference
-
-    Returns:
-        True if recursive listing should be used
-
-    Examples:
-        "*" -> False (single level only)
-        "*.mp3" -> False (single level only)
-        "**/*.mp3" -> True (globstar requires recursion)
-        "dir/*/file.txt" -> True (multi-level pattern)
-    """
     if not user_recursive:
-        # If user explicitly wants non-recursive, respect that
         return False
 
-    # If pattern contains globstar, definitely need recursion
     if "**" in pattern:
         return True
 
-    # If pattern contains path separators, it needs recursion
-    # Single-level patterns like "*", "*.txt", "file?" should not be recursive
     return "/" in pattern
 
 
 def expand_brace_pattern(pattern: str) -> list[str]:
     """
-    Recursively expand brace patterns like *.{mp3,wav} into multiple glob patterns.
-    Handles nested and multiple brace patterns.
-
-    Args:
-        pattern: Pattern that may contain brace expansion
-
-    Returns:
-        List of expanded patterns
+    Recursively expand brace patterns into multiple glob patterns.
+    Supports:
+    - Comma-separated lists: *.{mp3,wav}
+    - Numeric ranges: file{1..10}
+    - Zero-padded numeric ranges: file{01..10}
+    - Character ranges: file{a..z}
 
     Examples:
         "*.{mp3,wav}" -> ["*.mp3", "*.wav"]
+        "file{1..3}" -> ["file1", "file2", "file3"]
+        "file{01..03}" -> ["file01", "file02", "file03"]
+        "file{a..c}" -> ["filea", "fileb", "filec"]
         "{a,b}/{c,d}" -> ["a/c", "a/d", "b/c", "b/d"]
-        "*.txt" -> ["*.txt"]
-        "{{a,b}}" -> ["{a}", "{b}"]  # Handle double braces
     """
     if "{" not in pattern or "}" not in pattern:
         return [pattern]
@@ -162,11 +112,9 @@ def expand_brace_pattern(pattern: str) -> list[str]:
 
 
 def _expand_single_braces(pattern: str) -> list[str]:
-    """Helper to expand single-level braces."""
     if "{" not in pattern or "}" not in pattern:
         return [pattern]
 
-    # Find the first complete brace pattern
     start = pattern.index("{")
     end = start
     depth = 0
@@ -184,46 +132,66 @@ def _expand_single_braces(pattern: str) -> list[str]:
 
     prefix = pattern[:start]
     suffix = pattern[end + 1 :]
-    options = pattern[start + 1 : end].split(",")
+    brace_content = pattern[start + 1 : end]
+
+    if ".." in brace_content:
+        options = _expand_range(brace_content)
+    else:
+        options = [opt.strip() for opt in brace_content.split(",")]
 
-    # Generate all combinations and recursively expand
     expanded = []
     for option in options:
-        combined = prefix + option.strip() + suffix
-        # Recursively expand any remaining braces
+        combined = prefix + option + suffix
         expanded.extend(_expand_single_braces(combined))
 
     return expanded
 
 
-def convert_globstar_to_glob(filter_pattern: str) -> str:
-    """Convert globstar patterns to GLOB patterns.
+def _expand_range(range_spec: str) -> list[str]:  # noqa: PLR0911
+    if ".." not in range_spec:
+        return [range_spec]
 
-    Standard GLOB doesn't understand ** as recursive wildcard,
-    so we need to convert patterns appropriately.
+    parts = range_spec.split("..")
+    if len(parts) != 2:
+        return [range_spec]
 
-    Args:
-        filter_pattern: Pattern that may contain globstars (**)
+    start, end = parts[0], parts[1]
 
-    Returns:
-        GLOB-compatible pattern
-    """
+    if start.isdigit() and end.isdigit():
+        pad_width = max(len(start), len(end)) if start[0] == "0" or end[0] == "0" else 0
+        start_num = int(start)
+        end_num = int(end)
+
+        if start_num <= end_num:
+            if pad_width > 0:
+                return [str(i).zfill(pad_width) for i in range(start_num, end_num + 1)]
+            return [str(i) for i in range(start_num, end_num + 1)]
+        if pad_width > 0:
+            return [str(i).zfill(pad_width) for i in range(start_num, end_num - 1, -1)]
+        return [str(i) for i in range(start_num, end_num - 1, -1)]
+
+    if len(start) == 1 and len(end) == 1 and start.isalpha() and end.isalpha():
+        start_ord = ord(start)
+        end_ord = ord(end)
+
+        if start_ord <= end_ord:
+            return [chr(i) for i in range(start_ord, end_ord + 1)]
+        return [chr(i) for i in range(start_ord, end_ord - 1, -1)]
+
+    return [range_spec]
+
+
+def convert_globstar_to_glob(filter_pattern: str) -> str:
     if "**" not in filter_pattern:
         return filter_pattern
 
     parts = filter_pattern.split("/")
     globstar_positions = [i for i, p in enumerate(parts) if p == "**"]
 
-    # Handle different cases based on number of globstars
     num_globstars = len(globstar_positions)
 
     if num_globstars <= 1:
-        # Special case: pattern like **/* means zero or more directories
-        # This is tricky because GLOB can't express "zero or more"
-        # We need different handling based on the pattern structure
-
         if filter_pattern == "**/*":
-            # Match everything
             return "*"
         if filter_pattern.startswith("**/"):
             remaining = filter_pattern[3:]
@@ -236,20 +204,11 @@ def convert_globstar_to_glob(filter_pattern: str) -> str:
                 # that works with recursive listing
                 # Special handling: if it's a simple extension pattern, match broadly
                 if remaining.startswith("*."):
-                    # Pattern like **/*.ext - match any file with this extension
-                    # This matches *.ext at current level and deeper with recursion:
                     return remaining
-                # Pattern like **/temp?.* - match as filename in subdirs
                 return f"*/{remaining}"
 
-        # Default: Zero or one globstar - simple replacement
         return filter_pattern.replace("**", "*")
 
-    # Multiple globstars - need more careful handling
-    # For patterns like **/level?/backup/**/*.ext
-    # We want to match any path containing /level?/backup/ and ending with .ext
-
-    # Find middle directories (between first and last **)
     middle_parts = []
     start_idx = globstar_positions[0] + 1
     end_idx = globstar_positions[-1]
@@ -258,17 +217,12 @@ def convert_globstar_to_glob(filter_pattern: str) -> str:
             middle_parts.append(parts[i])
 
     if not middle_parts:
-        # No fixed middle parts, just use wildcards
         result = filter_pattern.replace("**", "*")
     else:
-        # Create pattern that matches the middle parts
         middle_pattern = "/".join(middle_parts)
-        # Get the file pattern at the end if any
         last_part = parts[-1] if parts[-1] != "**" else "*"
 
-        # Match any path containing this pattern
         if last_part != "*":
-            # Has specific file pattern
             result = f"*{middle_pattern}*{last_part}"
         else:
             result = f"*{middle_pattern}*"
@@ -287,14 +241,11 @@ def apply_glob_filter(
 
     chain = ls(dc, list_path, recursive=use_recursive, column=column)
 
-    # If pattern doesn't contain path separator and list_path is not empty,
-    # prepend the list_path to make the pattern match correctly
     if list_path and "/" not in pattern:
         filter_pattern = f"{list_path.rstrip('/')}/{pattern}"
     else:
         filter_pattern = pattern
 
-    # Convert globstar patterns to GLOB-compatible patterns
     glob_pattern = convert_globstar_to_glob(filter_pattern)
 
     return chain.filter(Column(f"{column}.path").glob(glob_pattern))

datachain/lib/namespaces.py

@@ -77,7 +77,7 @@ def ls(session: Optional[Session] = None) -> list[Namespace]:
     return Session.get(session).catalog.metastore.list_namespaces()
 
 
-def delete(name: str, session: Optional[Session]) -> None:
+def delete_namespace(name: str, session: Optional[Session] = None) -> None:
     """
     Removes a namespace by name.
 
@@ -88,14 +88,13 @@ def delete(name: str, session: Optional[Session]) -> None:
             as these cannot be removed.
 
     Parameters:
-        name : The name of the namespace.
-        session : Session to use for getting project.
+        name: The name of the namespace.
+        session: Session to use for getting project.
 
     Example:
         ```py
         import datachain as dc
-        from datachain.lib.namespace import delete as delete_namespace
-        delete_namespace("dev")
+        dc.delete_namespace("dev")
         ```
     """
     session = Session.get(session)

{datachain-0.32.0.dist-info → datachain-0.32.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datachain
-Version: 0.32.0
+Version: 0.32.2
 Summary: Wrangle unstructured AI data at scale
 Author-email: Dmitry Petrov <support@dvc.org>
 License-Expression: Apache-2.0
@@ -102,7 +102,7 @@ Requires-Dist: scipy; extra == "tests"
 Requires-Dist: ultralytics; extra == "tests"
 Provides-Extra: dev
 Requires-Dist: datachain[docs,tests]; extra == "dev"
-Requires-Dist: mypy==1.17.0; extra == "dev"
+Requires-Dist: mypy==1.18.1; extra == "dev"
 Requires-Dist: types-python-dateutil; extra == "dev"
 Requires-Dist: types-dateparser; extra == "dev"
 Requires-Dist: types-pytz; extra == "dev"
@@ -210,45 +210,33 @@ datasets that evolve over time and may occasionally have processing errors.
 .. code:: py
 
     import datachain as dc
-    from datachain import C, File
 
-    def process_file(file: File):
-        """Process a file, which may occasionally fail."""
+    def process_file(file: dc.File) -> tuple[str, str, str]:
+        """Analyze a file, may occasionally fail."""
         try:
             # Your processing logic here
             content = file.read_text()
-            result = analyze_content(content)
-            return {
-                "content": content,
-                "result": result,
-                "error": None  # No error
-            }
+            result = content.upper()
+            return content, result, ""  # No error
         except Exception as e:
             # Return an error that will trigger reprocessing next time
-            return {
-                "content": None,
-                "result": None,
-                "error": str(e)  # Error field will trigger retry
-            }
+            return "", "", str(e)  # Error field will trigger retry
 
     # Process files efficiently with delta and retry
+    # Run it many times, keep adding files, to see delta and retry in action
     chain = (
         dc.read_storage(
             "data/",
             update=True,
             delta=True,              # Process only new/changed files
             delta_on="file.path",    # Identify files by path
-            retry_on="error"         # Field that indicates errors
+            delta_retry="error",     # Process files with error again
         )
-        .map(processed_result=process_file)
-        .mutate(
-            content=C("processed_result.content"),
-            result=C("processed_result.result"),
-            error=C("processed_result.error")
-        )
-        .save(name="processed_data")
+        .map(process_file, output=("content", "result", "error"))
+        .save("processed-data")
     )
 
+
 Example: LLM based text-file evaluation
 ---------------------------------------
 

{datachain-0.32.0.dist-info → datachain-0.32.2.dist-info}/RECORD

@@ -1,9 +1,9 @@
-datachain/__init__.py,sha256=5DFB1P58c35C_WBMrhmaynsP1WwCukC-9gTJIaPy0E8,1832
+datachain/__init__.py,sha256=BRqfLPoBRRycnndaxyba-i4ZrZCJl0As2pwV9RiNBr8,1822
 datachain/__main__.py,sha256=hG3Y4ARGEqe1AWwNMd259rBlqtphx1Wk39YbueQ0yV8,91
 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/dataset.py,sha256=eX7xGa3EUpAccBZWpkgDmYV6_FjGuhjkMLFHpjl6lVI,25256
 datachain/delta.py,sha256=X5Lw6GQ8MAYNl2YIExNvl0tPIkylQEWwnCw0We7NtHM,10693
 datachain/error.py,sha256=comKx1JCdjsBpxabrOWaiRP0aHBspBDZl1mkKFnBSq0,1739
 datachain/job.py,sha256=x5PB6d5sqx00hePNNkirESlOVAvnmkEM5ygUgQmAhsk,1262
@@ -82,7 +82,7 @@ datachain/lib/listing.py,sha256=U-2stsTEwEsq4Y80dqGfktGzkmB5-ZntnL1_rzXlH0k,7089
 datachain/lib/listing_info.py,sha256=9ua40Hw0aiQByUw3oAEeNzMavJYfW0Uhe8YdCTK-m_g,1110
 datachain/lib/meta_formats.py,sha256=zdyg6XLk3QIsSk3I7s0Ez5kaCJSlE3uq7JiGxf7UwtU,6348
 datachain/lib/model_store.py,sha256=A0pSVQ7uaZ9RvANapzirF8Cqq9N6ysosPpMSkzdRPkU,3226
-datachain/lib/namespaces.py,sha256=ij67QHnRJhC8uquR21aD8u1Um2jfxnBX8PecuOQZpYw,3828
+datachain/lib/namespaces.py,sha256=ZyIYUa3WMrv6R5HrSoLsmLiEbvUQDl8sBINLUmWOYG0,3775
 datachain/lib/projects.py,sha256=_YeU9PPcH_pC8-sbX-47XtWSdl1ltVKnALY8azWLJkM,4112
 datachain/lib/pytorch.py,sha256=S-st2SAczYut13KMf6eSqP_OQ8otWI5TRmzhK5fN3k0,7828
 datachain/lib/settings.py,sha256=xBQEPZfgaYKhHIFLd0u5CBTYDcJS8ZHCm47x7GJErFU,7666
@@ -97,7 +97,7 @@ datachain/lib/webdataset.py,sha256=CkW8FfGigNx6wo2EEK4KMjhEE8FamRHWGs2HZuH7jDY,7
 datachain/lib/webdataset_laion.py,sha256=xvT6m_r5y0KbOx14BUe7UC5mOgrktJq53Mh-H0EVlUE,2525
 datachain/lib/convert/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datachain/lib/convert/flatten.py,sha256=_5rjGFnN6t1KCX5ftL5rG7tiiNat7j0SdNqajO15KUY,1539
-datachain/lib/convert/python_to_sql.py,sha256=wg-O5FRKX3x3Wh8ZL1b9ntMlgf1zRO4djMP3t8CHJLo,3188
+datachain/lib/convert/python_to_sql.py,sha256=ACIHtiPujlG9DRChSlxifcMJCls1PvrB273w_cgR6OQ,3584
 datachain/lib/convert/sql_to_python.py,sha256=Gxc4FylWC_Pvvuawuc2MKZIiuAWI7wje8pyeN1MxRrU,670
 datachain/lib/convert/unflatten.py,sha256=ysMkstwJzPMWUlnxn-Z-tXJR3wmhjHeSN_P-sDcLS6s,2010
 datachain/lib/convert/values_to_tuples.py,sha256=j5yZMrVUH6W7b-7yUvdCTGI7JCUAYUOzHUGPoyZXAB0,4360
@@ -110,10 +110,10 @@ datachain/lib/dc/hf.py,sha256=B7pubDQTDmth9uILXyhpQNtOAT3UOLjR-peU__tpypk,2884
 datachain/lib/dc/json.py,sha256=-vJ-pUpp2JxK4_vOfznE09FIoEOrvCwoIZSLxM6pjmY,2742
 datachain/lib/dc/listings.py,sha256=V379Cb-7ZyquM0w7sWArQZkzInZy4GB7QQ1ZfowKzQY,4544
 datachain/lib/dc/pandas.py,sha256=ObueUXDUFKJGu380GmazdG02ARpKAHPhSaymfmOH13E,1489
-datachain/lib/dc/parquet.py,sha256=STgm19AM-etu7WmOUMJa5Z9GI6tPC-A0P3JO3ulfsKo,1839
+datachain/lib/dc/parquet.py,sha256=ASTrT1UhIbss8jcI5171mrlDQZ_sEFDcIA3qBxuPhZQ,2405
 datachain/lib/dc/records.py,sha256=l7TKSKjT6boXGd05KA5vvax-Y-mLMOo46VWrlxPhmdQ,3067
-datachain/lib/dc/storage.py,sha256=pydeiGLMsmDvruVY_bC5GsV6VLpYpRf7szrD0S2pTmE,9688
-datachain/lib/dc/storage_pattern.py,sha256=QDLLSuBd1mdfkdRi3srGXXigs7rHw3vAnQedjE01_H8,9779
+datachain/lib/dc/storage.py,sha256=5GybJi5zftorrNzSk6HZw-rAda-KU7KEU29putjVRVc,9842
+datachain/lib/dc/storage_pattern.py,sha256=FAEsXRl9QAWz-x1wgrJEC8Ehh049GgoeC_HW3Vlwx-c,7658
 datachain/lib/dc/utils.py,sha256=9OMiFu2kXIbtMqzJTEr1qbCoCBGpOmTnkWImVgFTKgo,4112
 datachain/lib/dc/values.py,sha256=7l1n352xWrEdql2NhBcZ3hj8xyPglWiY4qHjFPjn6iw,1428
 datachain/model/__init__.py,sha256=R9faX5OHV1xh2EW-g2MPedwbtEqt3LodJRyluB-QylI,189
@@ -161,9 +161,9 @@ datachain/sql/sqlite/vector.py,sha256=ncW4eu2FlJhrP_CIpsvtkUabZlQdl2D5Lgwy_cbfqR
 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.32.0.dist-info/licenses/LICENSE,sha256=8DnqK5yoPI_E50bEg_zsHKZHY2HqPy4rYN338BHQaRA,11344
-datachain-0.32.0.dist-info/METADATA,sha256=gLsH5khLc-z_s0MKTt3H6qk_UXDAaWuHy2lk1yytgBw,13898
-datachain-0.32.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-datachain-0.32.0.dist-info/entry_points.txt,sha256=0GMJS6B_KWq0m3VT98vQI2YZodAMkn4uReZ_okga9R4,49
-datachain-0.32.0.dist-info/top_level.txt,sha256=lZPpdU_2jJABLNIg2kvEOBi8PtsYikbN1OdMLHk8bTg,10
-datachain-0.32.0.dist-info/RECORD,,
+datachain-0.32.2.dist-info/licenses/LICENSE,sha256=8DnqK5yoPI_E50bEg_zsHKZHY2HqPy4rYN338BHQaRA,11344
+datachain-0.32.2.dist-info/METADATA,sha256=S_VstbtQSTQyz-Ac0c1X_giCWOOFU9zJ4CWbvkw7E_o,13607
+datachain-0.32.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+datachain-0.32.2.dist-info/entry_points.txt,sha256=0GMJS6B_KWq0m3VT98vQI2YZodAMkn4uReZ_okga9R4,49
+datachain-0.32.2.dist-info/top_level.txt,sha256=lZPpdU_2jJABLNIg2kvEOBi8PtsYikbN1OdMLHk8bTg,10
+datachain-0.32.2.dist-info/RECORD,,