datachain 0.32.1__tar.gz → 0.32.3__tar.gz

{datachain-0.32.1 → datachain-0.32.3}/.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.3}/PKG-INFO

@@ -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 → datachain-0.32.3}/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.3}/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.3}/src/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-0.32.1 → datachain-0.32.3}/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.3}/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.3}/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.3}/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.3}/src/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-0.32.1 → datachain-0.32.3}/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.3}/src/datachain.egg-info/PKG-INFO

@@ -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 → datachain-0.32.3}/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.3}/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