datachain 0.32.1__py3-none-any.whl → 0.32.3__py3-none-any.whl

datachain/data_storage/metastore.py

@@ -689,9 +689,6 @@ class AbstractDBMetastore(AbstractMetastore):
             return self._projects.select()
         return select(*columns)
 
-    def _projects_update(self) -> "Update":
-        return self._projects.update()
-
     def _projects_delete(self) -> "Delete":
         return self._projects.delete()
 
@@ -839,6 +836,16 @@ class AbstractDBMetastore(AbstractMetastore):
 
         return self.get_project(name, namespace.name)
 
+    def _projects_base_query(self) -> "Select":
+        n = self._namespaces
+        p = self._projects
+
+        query = self._projects_select(
+            *(getattr(n.c, f) for f in self._namespaces_fields),
+            *(getattr(p.c, f) for f in self._projects_fields),
+        )
+        return query.select_from(n.join(p, n.c.id == p.c.namespace_id))
+
     def get_project(
         self, name: str, namespace_name: str, create: bool = False, conn=None
     ) -> Project:
@@ -854,11 +861,7 @@ class AbstractDBMetastore(AbstractMetastore):
             create = True
             validate = False
 
-        query = self._projects_select(
-            *(getattr(n.c, f) for f in self._namespaces_fields),
-            *(getattr(p.c, f) for f in self._projects_fields),
-        )
-        query = query.select_from(n.join(p, n.c.id == p.c.namespace_id)).where(
+        query = self._projects_base_query().where(
             p.c.name == name, n.c.name == namespace_name
         )
 
@@ -873,16 +876,9 @@ class AbstractDBMetastore(AbstractMetastore):
 
     def get_project_by_id(self, project_id: int, conn=None) -> Project:
         """Gets a single project by id"""
-        n = self._namespaces
         p = self._projects
 
-        query = self._projects_select(
-            *(getattr(n.c, f) for f in self._namespaces_fields),
-            *(getattr(p.c, f) for f in self._projects_fields),
-        )
-        query = query.select_from(n.join(p, n.c.id == p.c.namespace_id)).where(
-            p.c.id == project_id
-        )
+        query = self._projects_base_query().where(p.c.id == project_id)
 
         rows = list(self.db.execute(query, conn=conn))
         if not rows:
@@ -891,7 +887,8 @@ class AbstractDBMetastore(AbstractMetastore):
 
     def count_projects(self, namespace_id: Optional[int] = None) -> int:
         p = self._projects
-        query = self._projects_select()
+
+        query = self._projects_base_query()
         if namespace_id:
             query = query.where(p.c.namespace_id == namespace_id)
 
@@ -917,17 +914,12 @@ class AbstractDBMetastore(AbstractMetastore):
         """
         Gets a list of projects inside some namespace, or in all namespaces
         """
-        n = self._namespaces
         p = self._projects
 
-        query = self._projects_select(
-            *(getattr(n.c, f) for f in self._namespaces_fields),
-            *(getattr(p.c, f) for f in self._projects_fields),
-        )
-        query = query.select_from(n.join(p, n.c.id == p.c.namespace_id))
+        query = self._projects_base_query()
 
         if namespace_id:
-            query = query.where(n.c.id == namespace_id)
+            query = query.where(p.c.namespace_id == namespace_id)
 
         rows = list(self.db.execute(query, conn=conn))
 

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/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/file.py

@@ -332,7 +332,10 @@ class File(DataModel):
 
     @classmethod
     def upload(
-        cls, data: bytes, path: str, catalog: Optional["Catalog"] = None
+        cls,
+        data: bytes,
+        path: Union[str, os.PathLike[str]],
+        catalog: Optional["Catalog"] = None,
     ) -> "Self":
         if catalog is None:
             from datachain.catalog.loader import get_catalog
@@ -340,8 +343,10 @@ class File(DataModel):
             catalog = get_catalog()
         from datachain.client.fsspec import Client
 
-        client_cls = Client.get_implementation(path)
-        source, rel_path = client_cls.split_url(path)
+        path_str = stringify_path(path)
+
+        client_cls = Client.get_implementation(path_str)
+        source, rel_path = client_cls.split_url(path_str)
 
         client = catalog.get_client(client_cls.get_uri(source))
         file = client.upload(data, rel_path)
@@ -351,7 +356,9 @@ class File(DataModel):
         return file
 
     @classmethod
-    def at(cls, uri: str, session: Optional["Session"] = None) -> "Self":
+    def at(
+        cls, uri: Union[str, os.PathLike[str]], session: Optional["Session"] = None
+    ) -> "Self":
         """Construct a File from a full URI in one call.
 
         Example:
@@ -364,9 +371,10 @@ class File(DataModel):
         if session is None:
             session = Session.get()
         catalog = session.catalog
+        uri_str = stringify_path(uri)
 
-        client_cls = Client.get_implementation(uri)
-        source, rel_path = client_cls.split_url(uri)
+        client_cls = Client.get_implementation(uri_str)
+        source, rel_path = client_cls.split_url(uri_str)
         file = cls(source=client_cls.get_uri(source), path=rel_path)
         file._set_stream(catalog)
         return file

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_namespace(name: str, session: Optional[Session]) -> None:
+def delete_namespace(name: str, session: Optional[Session] = None) -> None:
     """
     Removes a namespace by name.
 

{datachain-0.32.1.dist-info → datachain-0.32.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datachain
-Version: 0.32.1
+Version: 0.32.3
 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"

{datachain-0.32.1.dist-info → datachain-0.32.3.dist-info}/RECORD

@@ -3,7 +3,7 @@ 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
@@ -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=2-FNdrhV-UoE6ztzdVea2MLpjr80Mvf3M3kbDfd3jSs,56222
+datachain/data_storage/metastore.py,sha256=SrcMeHAjzwTbX8A3WEZ3zzQzVW1n7uamrGDtQXqucyE,55810
 datachain/data_storage/schema.py,sha256=o3JbURKXRg3IJyIVA4QjHHkn6byRuz7avbydU2FlvNY,9897
 datachain/data_storage/serializer.py,sha256=6G2YtOFqqDzJf1KbvZraKGXl2XHZyVml2krunWUum5o,927
 datachain/data_storage/sqlite.py,sha256=1fIeIhmB3O8oQVzP8dDKap0KUIgI0n2TdBQSyv0R8J4,30345
@@ -75,14 +75,14 @@ datachain/lib/audio.py,sha256=fQmIBq-9hrUZtkgeJdPHYA_D8Wfe9D4cQZk4_ijxpNc,7580
 datachain/lib/clip.py,sha256=ae6uoiymOl53rBXwIfqJkbHrk_IA21R1uJwXo5454C4,6145
 datachain/lib/data_model.py,sha256=Rjah76GHwIV6AZQk4rsdg6JLre5D8Kb9T4PS5SXzsPA,3740
 datachain/lib/dataset_info.py,sha256=7w-DoKOyIVoOtWGCgciMLcP5CiAWJB3rVI-vUDF80k0,3311
-datachain/lib/file.py,sha256=gCtF1J1wYXpIZem5sd-ENVtuWip_znE7EQOkV51uFkQ,47321
+datachain/lib/file.py,sha256=FNM9XBn5uxOwaRedlL-aCYQ1CXboFaeQh5WzJXU3WhA,47505
 datachain/lib/hf.py,sha256=3xdvPQPilnJiGv3H4S4bTGqvrGGlZgZmqjE1n_SMJZg,7293
 datachain/lib/image.py,sha256=erWvZW5M3emnbl6_fGAOPyKm-1EKbt3vOdWPfe3Oo7U,3265
 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=IMfEgs680C3XpaLAiWIPhy8Wry4jT8iyRslcKV2cFOM,3768
+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
@@ -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.1.dist-info/licenses/LICENSE,sha256=8DnqK5yoPI_E50bEg_zsHKZHY2HqPy4rYN338BHQaRA,11344
-datachain-0.32.1.dist-info/METADATA,sha256=4T7E05Y-6wELDtaFv4De-D3dVQPk3Fm_-B3WqKkLvQQ,13607
-datachain-0.32.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-datachain-0.32.1.dist-info/entry_points.txt,sha256=0GMJS6B_KWq0m3VT98vQI2YZodAMkn4uReZ_okga9R4,49
-datachain-0.32.1.dist-info/top_level.txt,sha256=lZPpdU_2jJABLNIg2kvEOBi8PtsYikbN1OdMLHk8bTg,10
-datachain-0.32.1.dist-info/RECORD,,
+datachain-0.32.3.dist-info/licenses/LICENSE,sha256=8DnqK5yoPI_E50bEg_zsHKZHY2HqPy4rYN338BHQaRA,11344
+datachain-0.32.3.dist-info/METADATA,sha256=MJCn0xaCu7eOuQl8AXKTFX4HTvPqtBPY93rCvcUcoBg,13607
+datachain-0.32.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+datachain-0.32.3.dist-info/entry_points.txt,sha256=0GMJS6B_KWq0m3VT98vQI2YZodAMkn4uReZ_okga9R4,49
+datachain-0.32.3.dist-info/top_level.txt,sha256=lZPpdU_2jJABLNIg2kvEOBi8PtsYikbN1OdMLHk8bTg,10
+datachain-0.32.3.dist-info/RECORD,,