datachain 0.32.1__tar.gz → 0.32.2__tar.gz

{datachain-0.32.1 → datachain-0.32.2}/.pre-commit-config.yaml

@@ -24,7 +24,7 @@ repos:
       - id: trailing-whitespace
         exclude: '^LICENSES/'
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: 'v0.12.12'
+    rev: 'v0.13.0'
     hooks:
       - id: ruff
         args: [--fix, --exit-non-zero-on-fix]

{datachain-0.32.1 → datachain-0.32.2}/PKG-INFO

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

{datachain-0.32.1 → datachain-0.32.2}/docs/studio/webhooks.md

@@ -28,12 +28,14 @@ Payload:
             "id": "da59df47-d121-4eb6-aa76-dc452755544e",
             "status": "COMPLETE",
             "error_message": "",
+            "name": "job_query.py",
             "created_at": "2021-07-27T16:02:08.070557",
             "updated_at": "2021-07-27T16:22:08.070557",
             "finished_at": "2021-07-27T16:22:08.070557",
             "url": "https://studio.datachain.ai/team/TeamName/datasets/jobs/da59df47-d121-4eb6-aa76-dc452755544e"
         },
         "timestamp": "2021-07-27T16:22:08.070557",
+        "text": "Job job_query.py (da59df47-d121-4eb6-aa76-dc452755544e) changed its status to COMPLETE"
     }
 ```
 
@@ -45,7 +47,8 @@ Header: `http-x-datachain-event`: `PING`.
 Payload:
 ```json
 {
-    "action": "PING"
+    "action": "PING",
+    "message": "Webhook connection test successful"
 }
 ```
 
@@ -253,6 +256,14 @@ else:
     print("Warning: No signature header found")
 ```
 
+## Slack Integration
+
+You can use this webhook feature to send a message to slack as well. To integrate slack with Studio,
+
+1. Using the guide as described in [Slack documentation](https://docs.slack.dev/messaging/sending-messages-using-incoming-webhooks/) , create an incoming webhook and copy the webhook address in the following format `https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX` .
+2. Use the address to create a webhook in Studio as described [above](#creating-webhooks)
+3. You should now be able to view the message in Slack channel connected.
+
 ## Best practices for using Webhooks
 
 1. You should only subscribe to the webhook events that you need. This will reduce the amount of work your server needs to do.

{datachain-0.32.1 → datachain-0.32.2}/pyproject.toml

@@ -119,7 +119,7 @@ tests = [
 ]
 dev = [
   "datachain[docs,tests]",
-  "mypy==1.17.0",
+  "mypy==1.18.1",
   "types-python-dateutil",
   "types-dateparser",
   "types-pytz",

{datachain-0.32.1 → datachain-0.32.2}/src/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-0.32.1 → datachain-0.32.2}/src/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-0.32.1 → datachain-0.32.2}/src/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-0.32.1 → datachain-0.32.2}/src/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-0.32.1 → datachain-0.32.2}/src/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 → datachain-0.32.2}/src/datachain.egg-info/PKG-INFO

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

{datachain-0.32.1 → datachain-0.32.2}/src/datachain.egg-info/requires.txt

@@ -42,7 +42,7 @@ soundfile
 
 [dev]
 datachain[docs,tests]
-mypy==1.17.0
+mypy==1.18.1
 types-python-dateutil
 types-dateparser
 types-pytz

{datachain-0.32.1 → datachain-0.32.2}/tests/func/test_metastore.py

@@ -282,7 +282,7 @@ def test_remove_dataset(metastore):
     }
 
     metastore.remove_dataset(ds)
-    with pytest.raises(Exception, match="Dataset .+ not found"):
+    with pytest.raises(Exception, match=r"Dataset .+ not found"):
         metastore.get_dataset(ds.name)
 
     # dependencies should also be deleted and cleaned up

{datachain-0.32.1 → datachain-0.32.2}/tests/func/test_storage_pattern.py

@@ -77,7 +77,6 @@ def tmp_dir(tmp_path):
 
 
 def test_simple_wildcard(tmp_dir):
-    # Single level wildcard
     result = dc.read_storage(f"{tmp_dir}/deep/level1/temp/*.tmp")
     names = {f.name for f in result.to_values("file")}
     assert names == {"temp1.tmp", "temp2.tmp"}
@@ -224,18 +223,23 @@ def test_mixed_pattern_types(tmp_dir):
 
 def test_glob_pattern_in_bucket_name_raises_error():
     with pytest.raises(
-        ValueError, match="Glob patterns in bucket names are not supported.*bucket-\\*"
+        ValueError, match=r"Glob patterns in bucket names are not supported.*bucket-\*"
     ):
         dc.read_storage("s3://bucket-*/data/file.txt")
 
     with pytest.raises(
-        ValueError, match="Glob patterns in bucket names are not supported.*bucket-\\?"
+        ValueError, match=r"Glob patterns in bucket names are not supported.*bucket-\?"
     ):
         dc.read_storage("s3://bucket-?/files/*.txt")
 
     with pytest.raises(
         ValueError,
-        match="Glob patterns in bucket names are not supported.*bucket-\\{dev,prod\\}",
+        # Brace expansion appears literally in the message, we only need to
+        # escape braces for the regex engine, not double escape like before.
+        match=(
+            r"Glob patterns in bucket names are not supported.*"
+            r"bucket-\{dev,prod\}/logs/.*"
+        ),
     ):
         dc.read_storage("s3://bucket-{dev,prod}/logs/*.log")
 
@@ -256,6 +260,58 @@ def test_hugging_face_glob_patterns():
 
     with pytest.raises(
         ValueError,
-        match="Glob patterns in bucket names are not supported.*hf://datasets",
+        match=r"Glob patterns in bucket names are not supported.*hf://datasets",
     ):
         validate_cloud_bucket_name("hf://datasets*/username/repo-name/data/file.txt")
+
+
+def test_brace_expansion_numeric_ranges(tmp_dir):
+    (tmp_dir / "deep").mkdir(exist_ok=True)
+
+    for i in range(1, 6):
+        (tmp_dir / "deep" / f"file{i}.txt").write_text(f"content {i}")
+
+    result = dc.read_storage(f"{tmp_dir}/deep/file{{1..3}}.txt")
+    files = sorted(f.name for f in result.to_values("file"))
+    assert files == ["file1.txt", "file2.txt", "file3.txt"]
+
+    for i in range(1, 10):
+        (tmp_dir / "deep" / f"data{str(i).zfill(2)}.log").write_text(f"log {i}")
+
+    result = dc.read_storage(f"{tmp_dir}/deep/data{{01..05}}.log")
+    files = sorted(f.name for f in result.to_values("file"))
+    assert files == [
+        "data01.log",
+        "data02.log",
+        "data03.log",
+        "data04.log",
+        "data05.log",
+    ]
+
+
+def test_brace_expansion_character_ranges(tmp_dir):
+    (tmp_dir / "deep").mkdir(exist_ok=True)
+    for char in "abcde":
+        dir_path = tmp_dir / "deep" / f"dir-{char}"
+        dir_path.mkdir()
+        (dir_path / "file.txt").write_text(f"content {char}")
+
+    result = dc.read_storage(f"{tmp_dir}/deep/dir-{{a..c}}/file.txt")
+    dirs = sorted(f.source.split("/")[-1] for f in result.to_values("file"))
+    assert dirs == ["dir-a", "dir-b", "dir-c"]
+
+
+def test_brace_expansion_combined_patterns(tmp_dir):
+    (tmp_dir / "deep").mkdir(exist_ok=True)
+    for year in ["2005"]:
+        for month in range(1, 13):
+            filename = f"data-{year}-{str(month).zfill(2)}.csv"
+            (tmp_dir / "deep" / filename).write_text(f"data {year}-{month}")
+
+    result = dc.read_storage(f"{tmp_dir}/deep/data-2005-{{01..03}}.csv")
+    files = sorted([f.name for f in result.to_values("file")])
+    assert files == ["data-2005-01.csv", "data-2005-02.csv", "data-2005-03.csv"]
+
+    result = dc.read_storage(f"{tmp_dir}/deep/data-*-{{10..12}}.csv")
+    files = sorted(f.name for f in result.to_values("file"))
+    assert files == ["data-2005-10.csv", "data-2005-11.csv", "data-2005-12.csv"]

{datachain-0.32.1 → datachain-0.32.2}/tests/unit/lib/test_audio.py

@@ -178,7 +178,7 @@ def test_save_audio_validation(audio_file, tmp_path):
     with pytest.raises(ValueError, match="start time must be non-negative"):
         save_audio(audio_file, output=str(tmp_path), start=-1.0, end=1.0)
 
-    with pytest.raises(ValueError, match="Can't save audio.*invalid time range"):
+    with pytest.raises(ValueError, match=r"Can't save audio.*invalid time range"):
         save_audio(audio_file, output=str(tmp_path), start=2.0, end=1.0)
 
 

{datachain-0.32.1 → datachain-0.32.2}/tests/unit/lib/test_datachain.py

@@ -2182,18 +2182,18 @@ def test_union_different_columns(test_session):
     chain2 = dc.read_values(value=[3, 4], session=test_session)
     chain3 = dc.read_values(other=["a", "different", "thing"], session=test_session)
     with pytest.raises(
-        ValueError, match="Cannot perform union. name only present in left"
+        ValueError, match=r"Cannot perform union. name only present in left"
     ):
         chain1.union(chain2).show()
     with pytest.raises(
-        ValueError, match="Cannot perform union. name only present in right"
+        ValueError, match=r"Cannot perform union. name only present in right"
     ):
         chain2.union(chain1).show()
     with pytest.raises(
         ValueError,
-        match="Cannot perform union. "
-        "other only present in left. "
-        "name, value only present in right",
+        match=r"Cannot perform union. "
+        r"other only present in left. "
+        r"name, value only present in right",
     ):
         chain3.union(chain1).show()