lamindb_setup 0.81.3__py3-none-any.whl → 1.0a1__py3-none-any.whl

lamindb_setup/core/_hub_crud.py

@@ -12,25 +12,23 @@ def select_instance_by_owner_name(
     name: str,
     client: Client,
 ) -> dict | None:
-    try:
-        data = (
-            client.table("instance")
-            .select(
-                "*, account!inner!instance_account_id_28936e8f_fk_account_id(*),"
-                " storage!inner!storage_instance_id_359fca71_fk_instance_id(*)"
-            )
-            .eq("name", name)
-            .eq("account.handle", owner)
-            .eq("storage.is_default", True)
-            .execute()
-            .data
+    # this won't find an instance without the default storage
+    data = (
+        client.table("instance")
+        .select(
+            "*, account!inner!instance_account_id_28936e8f_fk_account_id(*),"
+            " storage!inner!storage_instance_id_359fca71_fk_instance_id(*)"
         )
-    except Exception:
-        return None
+        .eq("name", name)
+        .eq("account.handle", owner)
+        .eq("storage.is_default", True)
+        .execute()
+        .data
+    )
     if len(data) == 0:
         return None
     result = data[0]
-    # this is now a list
+    # this is a list
     # assume only one default storage
     result["storage"] = result["storage"][0]
     return result
@@ -89,15 +87,22 @@ def select_instance_by_id_with_storage(
     instance_id: str,
     client: Client,
 ):
-    response = (
+    # this won't find an instance without the default storage
+    data = (
         client.table("instance")
-        .select("*, storage!instance_storage_id_87963cc8_fk_storage_id(*)")
+        .select("*, storage!inner!storage_instance_id_359fca71_fk_instance_id(*)")
         .eq("id", instance_id)
+        .eq("storage.is_default", True)
         .execute()
+        .data
     )
-    if len(response.data) == 0:
+    if len(data) == 0:
         return None
-    return response.data[0]
+    result = data[0]
+    # this is a list
+    # assume only one default storage
+    result["storage"] = result["storage"][0]
+    return result
 
 
 def update_instance(instance_id: str, instance_fields: dict, client: Client):
@@ -139,17 +144,14 @@ def select_collaborator(
 def select_default_storage_by_instance_id(
     instance_id: str, client: Client
 ) -> dict | None:
-    try:
-        data = (
-            client.table("storage")
-            .select("*")
-            .eq("instance_id", instance_id)
-            .eq("is_default", True)
-            .execute()
-            .data
-        )
-    except Exception:
-        return None
+    data = (
+        client.table("storage")
+        .select("*")
+        .eq("instance_id", instance_id)
+        .eq("is_default", True)
+        .execute()
+        .data
+    )
     if len(data) == 0:
         return None
     return data[0]

lamindb_setup/core/_settings.py

@@ -164,7 +164,7 @@ class SetupSettings:
 
     @property
     def paths(self) -> type[SetupPaths]:
-        """Convert cloud paths to lamidb local paths.
+        """Convert cloud paths to lamindb local paths.
 
         Use `settings.paths.cloud_to_local_no_update`
         or `settings.paths.cloud_to_local`.
@@ -179,7 +179,7 @@ class SetupSettings:
         repr = self.user.__repr__()
         repr += f"\nAuto-connect in Python: {self.auto_connect}\n"
         repr += f"Private Django API: {self.private_django_api}\n"
-        repr += f"Cache directory: {self.cache_dir}\n"
+        repr += f"Cache directory: {self.cache_dir.as_posix()}\n"
         if self._instance_exists:
             repr += self.instance.__repr__()
         else:
@@ -200,9 +200,14 @@ class SetupPaths:
         # cache_key is ignored if filepath is a local path
         if not isinstance(filepath, LocalPathClasses):
             # settings is defined further in this file
-            local_filepath = settings.cache_dir / (
-                filepath.path if cache_key is None else cache_key  # type: ignore
-            )
+            if cache_key is None:
+                local_key = filepath.path  # type: ignore
+                protocol = filepath.protocol  # type: ignore
+                if protocol in {"http", "https"}:
+                    local_key = local_key.removeprefix(protocol + "://")
+            else:
+                local_key = cache_key
+            local_filepath = settings.cache_dir / local_key
         else:
             local_filepath = filepath
         return local_filepath

lamindb_setup/core/_settings_instance.py

@@ -121,7 +121,7 @@ class InstanceSettings:
     def _search_local_root(
         self, local_root: str | None = None, mute_warning: bool = False
     ) -> StorageSettings | None:
-        from lnschema_core.models import Storage
+        from lamindb.models import Storage
 
         if local_root is not None:
             local_records = Storage.objects.filter(root=local_root)
@@ -358,7 +358,7 @@ class InstanceSettings:
             sqlite_filepath = self.storage.cloud_to_local(
                 self._sqlite_file, error_no_origin=False
             )
-            return f"sqlite:///{sqlite_filepath}"
+            return f"sqlite:///{sqlite_filepath.as_posix()}"
         else:
             return self._db
 
@@ -457,11 +457,24 @@ class InstanceSettings:
         settings._instance_settings = self
 
     def _init_db(self):
+        from lamindb_setup import _check_setup
+
         from .django import setup_django
 
+        _check_setup.IS_LOADING = True
         setup_django(self, init=True)
+        _check_setup.IS_LOADING = False
+
+        from lamindb.models import Space
+
+        Space.objects.get_or_create(
+            name="All",
+            description="Every team & user with access to the instance has access.",
+        )
 
     def _load_db(self) -> tuple[bool, str]:
+        from lamindb_setup import _check_setup
+
         # Is the database available and initialized as LaminDB?
         # returns a tuple of status code and message
         if self.dialect == "sqlite" and not self._sqlite_file.exists():
@@ -472,7 +485,6 @@ class InstanceSettings:
                     f" {legacy_file} to {self._sqlite_file}"
                 )
             return False, f"SQLite file {self._sqlite_file} does not exist"
-        from lamindb_setup import settings  # to check user
 
         from .django import setup_django
 
@@ -481,5 +493,7 @@ class InstanceSettings:
         # setting up django also performs a check for migrations & prints them
         # as warnings
         # this should fail, e.g., if the db is not reachable
+        _check_setup.IS_LOADING = True
         setup_django(self)
+        _check_setup.IS_LOADING = False
         return True, ""

lamindb_setup/core/_settings_storage.py

@@ -7,6 +7,7 @@ import string
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Literal
 
+import fsspec
 from lamin_utils import logger
 
 from ._aws_credentials import HOSTED_REGIONS, get_aws_credentials_manager
@@ -24,6 +25,10 @@ if TYPE_CHECKING:
 
 IS_INITIALIZED_KEY = ".lamindb/_is_initialized"
 
+# a list of supported fsspec protocols
+# rename file to local before showing to a user
+VALID_PROTOCOLS = ("file", "gs", "s3", "hf", "http", "https")
+
 
 def base62(n_char: int) -> str:
     """Like nanoid without hyphen and underscore."""
@@ -114,16 +119,11 @@ def init_storage(
             root_str = f"s3://lamin-{region}/{uid}"
         else:
             root_str = f"s3://lamin-hosted-test/{uid}"
-    elif root_str.startswith(("gs://", "s3://", "hf://")):
-        pass
-    else:  # local path
-        try:
-            _ = Path(root_str)
-        except Exception as e:
-            logger.error(
-                "`storage` is not a valid local, GCP storage, AWS S3 path or Hugging Face path"
-            )
-            raise e
+    elif (input_protocol := fsspec.utils.get_protocol(root_str)) not in VALID_PROTOCOLS:
+        valid_protocols = ("local",) + VALID_PROTOCOLS[1:]  # show local instead of file
+        raise ValueError(
+            f"Protocol {input_protocol} is not supported, valid protocols are {', '.join(valid_protocols)}"
+        )
     ssettings = StorageSettings(
         uid=uid,
         root=root_str,
@@ -227,10 +227,10 @@ class StorageSettings:
 
     @property
     def record(self) -> Any:
-        """Storage record in current instance."""
+        """Storage record in the current instance."""
         if self._record is None:
             # dynamic import because of import order
-            from lnschema_core.models import Storage
+            from lamindb.models import Storage
 
             from ._settings import settings
 
@@ -299,14 +299,15 @@ class StorageSettings:
         return self._region
 
     @property
-    def type(self) -> Literal["local", "s3", "gs"]:
+    def type(self) -> Literal["local", "s3", "gs", "hf", "http", "https"]:
         """AWS S3 vs. Google Cloud vs. local.
 
-        Returns the protocol as a string: "local", "s3", "gs".
+        Returns the protocol as a string: "local", "s3", "gs", "http", "https".
         """
         import fsspec
 
         convert = {"file": "local"}
+        # init_storage checks that the root protocol belongs to VALID_PROTOCOLS
         protocol = fsspec.utils.get_protocol(self.root_as_str)
         return convert.get(protocol, protocol)  # type: ignore
 
@@ -345,5 +346,5 @@ class StorageSettings:
         return self.root / filekey
 
     def local_filepath(self, filekey: UPathStr) -> UPath:
-        """Local (cache) filepath from filekey: `local(filepath(...))`."""
+        """Local (cache) filepath from filekey."""
         return self.cloud_to_local(self.key_to_filepath(filekey))

lamindb_setup/core/_settings_user.py

@@ -48,7 +48,7 @@ class UserSettings:
     @property
     def id(self):
         """Integer id valid in current intance."""
-        from lnschema_core.users import current_user_id
+        from lamindb.base.users import current_user_id
 
         # there is no cache needed here because current_user_id()
         # has its own cache

lamindb_setup/core/django.py

@@ -5,10 +5,8 @@ import builtins
 import os
 from pathlib import Path
 import time
-from lamin_utils import logger
-from ._settings_store import current_instance_settings_file
 from ._settings_instance import InstanceSettings
-import sys
+
 
 IS_RUN_FROM_IPYTHON = getattr(builtins, "__IPYTHON__", False)
 IS_SETUP = False

lamindb_setup/core/hashing.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 
 import base64
 import hashlib
+import json
 from concurrent.futures import ThreadPoolExecutor
 from typing import TYPE_CHECKING
 
@@ -40,11 +41,21 @@ def b16_to_b64(s: str):
     return to_b64_str(base64.b16decode(s.strip('"'), casefold=True))
 
 
+def hash_string(string: str) -> str:
+    # as we're truncating (not here) at 22 b64, we choose md5 over sha512
+    return to_b64_str(hashlib.md5(string.encode("utf-8")).digest())
+
+
 # a lot to read about this: lamin-notes/2022/hashing
 def hash_set(s: set[str]) -> str:
-    bstr = ":".join(sorted(s)).encode("utf-8")
-    # as we're truncating at 22 b64, we choose md5 over sha512
-    return to_b64_str(hashlib.md5(bstr).digest())[:HASH_LENGTH]
+    join_s = ":".join(sorted(s))
+    return hash_string(join_s)[:HASH_LENGTH]
+
+
+def hash_dict(d: dict) -> str:
+    return to_b64_str(hashlib.md5(json.dumps(d, sort_keys=True).encode()).digest())[
+        :HASH_LENGTH
+    ]
 
 
 def hash_from_hashes_list(hashes: Iterable[str]) -> str:
@@ -111,6 +122,6 @@ def hash_dir(path: Path):
     hashes, sizes = zip(*hashes_sizes)
 
     hash, hash_type = hash_from_hashes_list(hashes), "md5-d"
-    n_objects = len(hashes)
+    n_files = len(hashes)
     size = sum(sizes)
-    return size, hash, hash_type, n_objects
+    return size, hash, hash_type, n_files

lamindb_setup/core/upath.py

@@ -12,14 +12,15 @@ from itertools import islice
 from pathlib import Path, PosixPath, PurePosixPath, WindowsPath
 from typing import TYPE_CHECKING, Any, Literal
 
+import click
 import fsspec
 from lamin_utils import logger
 from upath import UPath
-from upath.implementations.cloud import CloudPath, S3Path  # keep CloudPath!
+from upath.implementations.cloud import CloudPath  # keep CloudPath!
 from upath.implementations.local import LocalPath
 
 from ._aws_credentials import HOSTED_BUCKETS, get_aws_credentials_manager
-from .hashing import HASH_LENGTH, b16_to_b64, hash_from_hashes_list
+from .hashing import HASH_LENGTH, b16_to_b64, hash_from_hashes_list, hash_string
 
 if TYPE_CHECKING:
     from .types import UPathStr
@@ -190,8 +191,17 @@ class ProgressCallback(fsspec.callbacks.Callback):
         pass
 
     def update_relative_value(self, inc=1):
-        self.value += inc
-        self.call()
+        if inc != 0:
+            self.value += inc
+            self.call()
+        else:
+            # this is specific to http filesystem
+            # for some reason the last update is 0 always
+            # sometimes the reported result is less that 100%
+            # here 100% is forced manually in this case
+            if self.value < 1.0 and self.value >= 0.999:
+                self.value = self.size
+                self.call()
 
     def branch(self, path_1, path_2, kwargs):
         if self.adjust_size:
@@ -258,7 +268,17 @@ def download_to(self, local_path: UPathStr, print_progress: bool = True, **kwarg
         )
         kwargs["callback"] = callback
 
-    self.fs.download(str(self), str(local_path), **kwargs)
+    cloud_path_str = str(self)
+    local_path_str = str(local_path)
+    # needed due to https://github.com/fsspec/filesystem_spec/issues/1766
+    # otherwise fsspec calls fs._ls_real where it reads the body and parses links
+    # so the file is downloaded 2 times
+    # upath doesn't call fs.ls to infer type, so it is safe to call
+    if self.protocol in {"http", "https"} and self.stat().as_info()["type"] == "file":
+        self.fs.use_listings_cache = True
+        self.fs.dircache[cloud_path_str] = []
+
+    self.fs.download(cloud_path_str, local_path_str, **kwargs)
 
 
 def upload_from(
@@ -306,8 +326,7 @@ def upload_from(
         destination = self.as_posix()
 
     # the below lines are to avoid s3fs triggering create_bucket in upload if
-    # dirs are present it allows to avoid permission error
-    # would be easier to just
+    # dirs are present, it allows to avoid the permission error
     if self.protocol == "s3" and local_path_is_dir and create_folder:
         bucket = self.drive
         if bucket not in self.fs.dircache:
@@ -350,27 +369,19 @@ def synchronize(
         exists = True
         cloud_mts = timestamp
     else:
-        # hf requires special treatment
-        if protocol == "hf":
-            try:
-                stat_hf = self.stat().as_info()
-                is_dir = stat_hf["type"] == "directory"
-                exists = True
-                if not is_dir:
-                    cloud_mts = stat_hf["last_commit"].date.timestamp()
-            except FileNotFoundError:
-                exists = False
-        else:
-            # perform only one network request to check existence, type and timestamp
-            try:
-                cloud_mts = self.modified.timestamp()
-                is_dir = False
-                exists = True
-            except FileNotFoundError:
-                exists = False
-            except IsADirectoryError:
-                is_dir = True
-                exists = True
+        try:
+            cloud_stat = self.stat()
+            cloud_info = cloud_stat.as_info()
+            exists = True
+            is_dir = cloud_info["type"] == "directory"
+            if not is_dir:
+                # hf requires special treatment
+                if protocol == "hf":
+                    cloud_mts = cloud_info["last_commit"].date.timestamp()
+                else:
+                    cloud_mts = cloud_stat.st_mtime
+        except FileNotFoundError:
+            exists = False
 
     if not exists:
         warn_or_error = f"The original path {self} does not exist anymore."
@@ -386,6 +397,7 @@ def synchronize(
         return None
 
     # synchronization logic for directories
+    # to synchronize directories, it should be possible to get modification times
     if is_dir:
         files = self.fs.find(str(self), detail=True)
         if protocol == "s3":
@@ -451,8 +463,16 @@ def synchronize(
         callback, print_progress, objectpath.name, "synchronizing"
     )
     if objectpath.exists():
-        local_mts_obj = objectpath.stat().st_mtime  # type: ignore
-        need_synchronize = cloud_mts > local_mts_obj
+        if cloud_mts != 0:
+            local_mts_obj = objectpath.stat().st_mtime
+            need_synchronize = cloud_mts > local_mts_obj
+        else:
+            # this is true for http for example
+            # where size is present but st_mtime is not
+            # we assume that any change without the change in size is unlikely
+            cloud_size = cloud_stat.st_size
+            local_size_obj = objectpath.stat().st_size
+            need_synchronize = cloud_size != local_size_obj
     else:
         objectpath.parent.mkdir(parents=True, exist_ok=True)
         need_synchronize = True
@@ -464,7 +484,8 @@ def synchronize(
         self.download_to(
             objectpath, recursive=False, print_progress=False, callback=callback
         )
-        os.utime(objectpath, times=(cloud_mts, cloud_mts))
+        if cloud_mts != 0:
+            os.utime(objectpath, times=(cloud_mts, cloud_mts))
     else:
         # nothing happens if parent_update is not defined
         # because of Callback.no_op
@@ -497,7 +518,7 @@ def compute_file_tree(
         skip_suffixes_tuple = ()
     else:
         skip_suffixes_tuple = tuple(skip_suffixes)  # type: ignore
-    n_objects = 0
+    n_files = 0
     n_directories = 0
 
     # by default only including registered files
@@ -510,7 +531,7 @@ def compute_file_tree(
         include_paths = set()
 
     def inner(dir_path: Path, prefix: str = "", level: int = -1):
-        nonlocal n_objects, n_directories, suffixes
+        nonlocal n_files, n_directories, suffixes
         if level == 0:
             return
         stripped_dir_path = dir_path.as_posix().rstrip("/")
@@ -543,7 +564,7 @@ def compute_file_tree(
                 suffix = extract_suffix_from_path(child_path)
                 suffixes.add(suffix)
                 n_files_per_dir_and_type[suffix] += 1
-                n_objects += 1
+                n_files += 1
                 if n_files_per_dir_and_type[suffix] == n_max_files_per_dir_and_type:
                     yield prefix + "..."
                 elif n_files_per_dir_and_type[suffix] > n_max_files_per_dir_and_type:
@@ -556,15 +577,15 @@ def compute_file_tree(
     for line in islice(iterator, n_max_files):
         folder_tree += f"\n{line}"
     if next(iterator, None):
-        folder_tree += f"\n... only showing {n_max_files} out of {n_objects} files"
+        folder_tree += f"\n... only showing {n_max_files} out of {n_files} files"
     directory_info = "directory" if n_directories == 1 else "directories"
     display_suffixes = ", ".join([f"{suffix!r}" for suffix in suffixes])
-    suffix_message = f" with suffixes {display_suffixes}" if n_objects > 0 else ""
+    suffix_message = f" with suffixes {display_suffixes}" if n_files > 0 else ""
     message = (
         f"{n_directories} sub-{directory_info} &"
-        f" {n_objects} files{suffix_message}\n{path.resolve()}{folder_tree}"
+        f" {n_files} files{suffix_message}\n{path.resolve()}{folder_tree}"
     )
-    return message, n_objects
+    return message, n_files
 
 
 # adapted from: https://stackoverflow.com/questions/9727673
@@ -718,12 +739,26 @@ warnings.filterwarnings(
 )
 
 
-def create_path(path: UPath, access_token: str | None = None) -> UPath:
-    path = UPath(path)
-    # test whether we have an AWS S3 path
-    if not isinstance(path, S3Path):
-        return path
-    return get_aws_credentials_manager().enrich_path(path, access_token)
+def create_path(path: UPathStr, access_token: str | None = None) -> UPath:
+    upath = UPath(path)
+
+    if upath.protocol == "s3":
+        # add managed credentials and other options for AWS s3 paths
+        return get_aws_credentials_manager().enrich_path(upath, access_token)
+
+    if upath.protocol in {"http", "https"}:
+        # this is needed because by default aiohttp drops a connection after 5 min
+        # so it is impossible to download large files
+        client_kwargs = upath.storage_options.get("client_kwargs", {})
+        if "timeout" not in client_kwargs:
+            from aiohttp import ClientTimeout
+
+            client_kwargs = {
+                **client_kwargs,
+                "timeout": ClientTimeout(sock_connect=30, sock_read=30),
+            }
+            return UPath(upath, client_kwargs=client_kwargs)
+    return upath
 
 
 def get_stat_file_cloud(stat: dict) -> tuple[int, str | None, str | None]:
@@ -739,20 +774,28 @@ def get_stat_file_cloud(stat: dict) -> tuple[int, str | None, str | None]:
         hash = b16_to_b64(stat["blob_id"])
         hash_type = "sha1"
     # s3
+    # StorageClass is checked to be sure that it is indeed s3
+    # because http also has ETag
     elif "ETag" in stat:
         etag = stat["ETag"]
-        # small files
-        if "-" not in etag:
-            # only store hash for non-multipart uploads
-            # we can't rapidly validate multi-part uploaded files client-side
-            # we can add more logic later down-the-road
-            hash = b16_to_b64(etag)
-            hash_type = "md5"
+        if "mimetype" in stat:
+            # http
+            hash = hash_string(etag.strip('"'))
+            hash_type = "md5-etag"
         else:
-            stripped_etag, suffix = etag.split("-")
-            suffix = suffix.strip('"')
-            hash = b16_to_b64(stripped_etag)
-            hash_type = f"md5-{suffix}"  # this is the S3 chunk-hashing strategy
+            # s3
+            # small files
+            if "-" not in etag:
+                # only store hash for non-multipart uploads
+                # we can't rapidly validate multi-part uploaded files client-side
+                # we can add more logic later down-the-road
+                hash = b16_to_b64(etag)
+                hash_type = "md5"
+            else:
+                stripped_etag, suffix = etag.split("-")
+                suffix = suffix.strip('"')
+                hash = b16_to_b64(stripped_etag)
+                hash_type = f"md5-{suffix}"  # this is the S3 chunk-hashing strategy
     if hash is not None:
         hash = hash[:HASH_LENGTH]
     return size, hash, hash_type
@@ -777,17 +820,18 @@ def get_stat_dir_cloud(path: UPath) -> tuple[int, str | None, str | None, int]:
         if compute_list_hash:
             hashes.append(object[accessor].strip('"='))
     size = sum(sizes)
-    n_objects = len(sizes)
+    n_files = len(sizes)
     if compute_list_hash:
         hash, hash_type = hash_from_hashes_list(hashes), "md5-d"
-    return size, hash, hash_type, n_objects
+    return size, hash, hash_type, n_files
 
 
-class InstanceNotEmpty(Exception):
-    pass
+class InstanceNotEmpty(click.ClickException):
+    def show(self, file=None):
+        pass
 
 
-# is as fast as boto3: https://lamin.ai/laminlabs/lamindata/transform/krGp3hT1f78N5zKv
+# is as fast as boto3: https://lamin.ai/laminlabs/lamin-site-assets/transform/krGp3hT1f78N5zKv
 def check_storage_is_empty(
     root: UPathStr, *, raise_error: bool = True, account_for_sqlite_file: bool = False
 ) -> int:
@@ -810,20 +854,20 @@ def check_storage_is_empty(
             root_string += "/"
         directory_string = root_string + ".lamindb"
     objects = root_upath.fs.find(directory_string)
-    n_objects = len(objects)
-    n_diff = n_objects - n_offset_objects
+    n_files = len(objects)
+    n_diff = n_files - n_offset_objects
     ask_for_deletion = (
         "delete them prior to deleting the instance"
         if raise_error
         else "consider deleting them"
     )
     message = (
-        f"Storage '{directory_string}' contains {n_objects - n_offset_objects} objects"
+        f"Storage '{directory_string}' contains {n_files - n_offset_objects} objects"
         f" - {ask_for_deletion}"
     )
     if n_diff > 0:
         if raise_error:
-            raise InstanceNotEmpty(message)
+            raise InstanceNotEmpty(message) from None
         else:
             logger.warning(message)
     return n_diff

{lamindb_setup-0.81.3.dist-info → lamindb_setup-1.0a1.dist-info}/METADATA

@@ -1,20 +1,19 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: lamindb_setup
-Version: 0.81.3
+Version: 1.0a1
 Summary: Setup & configure LaminDB.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: lnschema_core>=0.51.0
 Requires-Dist: lamin_utils>=0.3.3
-Requires-Dist: django>4.2,<5.3.0
+Requires-Dist: django>=5,<5.2
 Requires-Dist: dj_database_url>=1.3.0,<3.0.0
 Requires-Dist: pydantic-settings
 Requires-Dist: appdirs<2.0.0
 Requires-Dist: requests
 Requires-Dist: universal_pathlib==0.2.5
 Requires-Dist: botocore<2.0.0
-Requires-Dist: supabase>=2.8.1,<=2.10.0
+Requires-Dist: supabase>=2.8.1,<=2.11.0
 Requires-Dist: psutil
 Requires-Dist: urllib3<2 ; extra == "aws"
 Requires-Dist: aiobotocore[boto3]>=2.5.4,<3.0.0 ; extra == "aws"