lamindb_setup 0.70.0__py2.py3-none-any.whl → 0.71.1__py2.py3-none-any.whl

lamindb_setup/core/upath.py

@@ -4,21 +4,25 @@
 from __future__ import annotations
 
 import os
+from collections import defaultdict
 from datetime import datetime, timezone
-import botocore.session
+from functools import partial
+from itertools import islice
 from pathlib import Path, PurePosixPath
-from typing import Literal, Dict
+from typing import TYPE_CHECKING, Any, Literal
+
+import botocore.session
 import fsspec
-from itertools import islice
-from typing import Optional, Set, Any, Tuple, List
-from collections import defaultdict
 from lamin_utils import logger
 from upath import UPath
-from upath.implementations.cloud import CloudPath, S3Path  # noqa  # keep CloudPath!
+from upath.implementations.cloud import CloudPath, S3Path  # keep CloudPath!
 from upath.implementations.local import LocalPath, PosixUPath, WindowsUPath
-from .types import UPathStr
+
 from .hashing import b16_to_b64, hash_md5s_from_dir
 
+if TYPE_CHECKING:
+    from .types import UPathStr
+
 LocalPathClasses = (PosixUPath, WindowsUPath, LocalPath)
 
 # also see https://gist.github.com/securifera/e7eed730cbe1ce43d0c29d7cd2d582f4
@@ -52,12 +56,15 @@ VALID_SUFFIXES = {
     ".zarr",
     ".json",
 }
-
+VALID_COMPOSITE_SUFFIXES = {
+    ".anndata.zarr",
+    ".spatialdata.zarr",
+}
 
 TRAILING_SEP = (os.sep, os.altsep) if os.altsep is not None else os.sep
 
 
-def extract_suffix_from_path(path: Path, arg_name: Optional[str] = None) -> str:
+def extract_suffix_from_path(path: Path, arg_name: str | None = None) -> str:
     def process_digits(suffix: str):
         if suffix[1:].isdigit():  # :1 to skip the dot
             return ""  # digits are no valid suffixes
@@ -70,6 +77,12 @@ def extract_suffix_from_path(path: Path, arg_name: Optional[str] = None) -> str:
     total_suffix = "".join(path.suffixes)
     if total_suffix in VALID_SUFFIXES:
         return total_suffix
+    elif total_suffix.endswith(tuple(VALID_COMPOSITE_SUFFIXES)):
+        # below seems slow but OK for now
+        for suffix in VALID_COMPOSITE_SUFFIXES:
+            if total_suffix.endswith(suffix):
+                break
+        return suffix
     else:
         print_hint = True
         arg_name = "file" if arg_name is None else arg_name  # for the warning
@@ -141,44 +154,100 @@ def create_mapper(
         )
 
 
-def print_hook(size: int, value: int, **kwargs):
+def print_hook(size: int, value: int, objectname: str, action: str):
     progress_in_percent = (value / size) * 100
-    out = (
-        f"... {kwargs['action']} {Path(kwargs['filepath']).name}:"
-        f" {min(progress_in_percent, 100):4.1f}%"
-    )
-    if progress_in_percent >= 100:
-        out += "\n"
+    out = f"... {action} {objectname}:" f" {min(progress_in_percent, 100):4.1f}%"
     if "NBPRJ_TEST_NBPATH" not in os.environ:
         print(out, end="\r")
 
 
 class ProgressCallback(fsspec.callbacks.Callback):
-    def __init__(self, action: Literal["uploading", "downloading"]):
+    def __init__(
+        self,
+        objectname: str,
+        action: Literal["uploading", "downloading", "synchronizing"],
+        adjust_size: bool = False,
+    ):
+        assert action in {"uploading", "downloading", "synchronizing"}
+
         super().__init__()
+
         self.action = action
+        print_progress = partial(print_hook, objectname=objectname, action=action)
+        self.hooks = {"print_progress": print_progress}
+
+        self.adjust_size = adjust_size
+
+    def absolute_update(self, value):
+        pass
+
+    def relative_update(self, inc=1):
+        pass
+
+    def update_relative_value(self, inc=1):
+        self.value += inc
+        self.call()
 
     def branch(self, path_1, path_2, kwargs):
-        kwargs["callback"] = fsspec.callbacks.Callback(
-            hooks=dict(print_hook=print_hook), filepath=path_1, action=self.action
-        )
+        if self.adjust_size:
+            if Path(path_2 if self.action != "uploading" else path_1).is_dir():
+                self.size -= 1
+        kwargs["callback"] = ChildProgressCallback(self)
+
+    def branched(self, path_1, path_2, **kwargs):
+        self.branch(path_1, path_2, kwargs)
+        return kwargs["callback"]
+
+    def wrap(self, iterable):
+        if self.adjust_size:
+            paths = []
+            for lpath, rpath in iterable:
+                paths.append((lpath, rpath))
+                if Path(lpath).is_dir():
+                    self.size -= 1
+            self.adjust_size = False
+            return paths
+        else:
+            return iterable
+
+    @classmethod
+    def requires_progress(
+        cls,
+        maybe_callback: fsspec.callbacks.Callback | None,
+        print_progress: bool,
+        objectname: str,
+        action: Literal["uploading", "downloading", "synchronizing"],
+        **kwargs,
+    ):
+        if maybe_callback is None:
+            if print_progress:
+                return cls(objectname, action, **kwargs)
+            else:
+                return fsspec.callbacks.NoOpCallback()
+        return maybe_callback
 
-    def call(self, *args, **kwargs):
-        return None
+
+class ChildProgressCallback(fsspec.callbacks.Callback):
+    def __init__(self, parent: ProgressCallback):
+        super().__init__()
+
+        self.parent = parent
+
+    def parent_update(self, inc=1):
+        self.parent.update_relative_value(inc)
+
+    def relative_update(self, inc=1):
+        self.parent_update(inc / self.size)
 
 
 def download_to(self, path: UPathStr, print_progress: bool = False, **kwargs):
     """Download to a path."""
-    if print_progress:
-        # can't do path.is_dir() because path doesn't exist
-        # so assume any destination without a suffix is a dir
-        # this is temporary until we have a proper progress bar for directories
-        if os.path.splitext(path)[-1] not in {"", ".zrad", ".zarr"}:
-            cb = ProgressCallback("downloading")
-        else:
-            # todo: make proper progress bar for directories
-            cb = fsspec.callbacks.NoOpCallback()
-        kwargs["callback"] = cb
+    if print_progress and "callback" not in kwargs:
+        callback = ProgressCallback(
+            PurePosixPath(path).name, "downloading", adjust_size=True
+        )
+        kwargs["callback"] = callback
+
     self.fs.download(str(self), str(path), **kwargs)
 
 
@@ -190,20 +259,16 @@ def upload_from(
     **kwargs,
 ):
     """Upload from a local path."""
-    path_is_dir = os.path.isdir(path)
+    path = Path(path)
+    path_is_dir = path.is_dir()
     if not path_is_dir:
         dir_inplace = False
 
-    if print_progress:
-        if not path_is_dir:
-            cb = ProgressCallback("uploading")
-        else:
-            # todo: make proper progress bar for directories
-            cb = fsspec.callbacks.NoOpCallback()
-        kwargs["callback"] = cb
+    if print_progress and "callback" not in kwargs:
+        callback = ProgressCallback(path.name, "uploading")
+        kwargs["callback"] = callback
 
     if dir_inplace:
-        path = Path(path)
         source = [f for f in path.rglob("*") if f.is_file()]
         destination = [str(self / f.relative_to(path)) for f in source]
         source = [str(f) for f in source]  # type: ignore
@@ -233,7 +298,14 @@ def upload_from(
             del self.fs.dircache[bucket]
 
 
-def synchronize(self, objectpath: Path, error_no_origin: bool = True, **kwargs):
+def synchronize(
+    self,
+    objectpath: Path,
+    error_no_origin: bool = True,
+    print_progress: bool = False,
+    callback: fsspec.callbacks.Callback | None = None,
+    **kwargs,
+):
     """Sync to a local destination path."""
     # optimize the number of network requests
     if "timestamp" in kwargs:
@@ -292,15 +364,23 @@ def synchronize(self, objectpath: Path, error_no_origin: bool = True, **kwargs):
             destination_exists = False
             need_synchronize = True
         if need_synchronize:
+            callback = ProgressCallback.requires_progress(
+                callback, print_progress, objectpath.name, "synchronizing"
+            )
+            callback.set_size(len(files))
             origin_file_keys = []
-            for file, stat in files.items():
-                destination = PurePosixPath(file).relative_to(self.path)
-                origin_file_keys.append(destination.as_posix())
+            for file, stat in callback.wrap(files.items()):
+                file_key = PurePosixPath(file).relative_to(self.path)
+                origin_file_keys.append(file_key.as_posix())
                 timestamp = stat[modified_key].timestamp()
-                origin = UPath(f"{self.protocol}://{file}", **self._kwargs)
-                origin.synchronize(
-                    objectpath / destination, timestamp=timestamp, **kwargs
+
+                origin = f"{self.protocol}://{file}"
+                destination = objectpath / file_key
+                child = callback.branched(origin, destination.as_posix())
+                UPath(origin, **self._kwargs).synchronize(
+                    destination, timestamp=timestamp, callback=child, **kwargs
                 )
+                child.close()
             if destination_exists:
                 local_files = [file for file in objectpath.rglob("*") if file.is_file()]
                 if len(local_files) > len(files):
@@ -316,6 +396,10 @@ def synchronize(self, objectpath: Path, error_no_origin: bool = True, **kwargs):
         return None
 
     # synchronization logic for files
+    callback = ProgressCallback.requires_progress(
+        callback, print_progress, objectpath.name, "synchronizing"
+    )
+    kwargs["callback"] = callback
     if objectpath.exists():
         local_mts = objectpath.stat().st_mtime  # type: ignore
         need_synchronize = cloud_mts > local_mts
@@ -325,9 +409,13 @@ def synchronize(self, objectpath: Path, error_no_origin: bool = True, **kwargs):
     if need_synchronize:
         self.download_to(objectpath, **kwargs)
         os.utime(objectpath, times=(cloud_mts, cloud_mts))
+    else:
+        # nothing happens if parent_update is not defined
+        # because of Callback.no_op
+        callback.parent_update()
 
 
-def modified(self) -> Optional[datetime]:
+def modified(self) -> datetime | None:
     """Return modified time stamp."""
     mtime = self.fs.modified(str(self))
     if mtime.tzinfo is None:
@@ -340,15 +428,15 @@ def compute_file_tree(
     *,
     level: int = -1,
     only_dirs: bool = False,
-    limit: int = 1000,
-    include_paths: Optional[Set[Any]] = None,
-    skip_suffixes: Optional[List[str]] = None,
-) -> Tuple[str, int]:
+    n_max_files_per_dir_and_type: int = 100,
+    n_max_files: int = 1000,
+    include_paths: set[Any] | None = None,
+    skip_suffixes: list[str] | None = None,
+) -> tuple[str, int]:
     space = "    "
     branch = "│   "
     tee = "├── "
     last = "└── "
-    max_files_per_dir_per_type = 7
     if skip_suffixes is None:
         skip_suffixes_tuple = ()
     else:
@@ -382,14 +470,14 @@ def compute_file_tree(
         if only_dirs:
             contents = [d for d in contents if d.is_dir()]
         pointers = [tee] * (len(contents) - 1) + [last]
-        n_files_per_dir_per_type = defaultdict(lambda: 0)  # type: ignore
-        for pointer, child_path in zip(pointers, contents):
+        n_files_per_dir_and_type = defaultdict(lambda: 0)  # type: ignore
+        for pointer, child_path in zip(pointers, contents, strict=False):  # type: ignore
             if child_path.is_dir():
                 if include_dirs and child_path not in include_dirs:
                     continue
                 yield prefix + pointer + child_path.name
                 n_directories += 1
-                n_files_per_dir_per_type = defaultdict(lambda: 0)
+                n_files_per_dir_and_type = defaultdict(lambda: 0)
                 extension = branch if pointer == tee else space
                 yield from inner(child_path, prefix=prefix + extension, level=level - 1)
             elif not only_dirs:
@@ -397,21 +485,21 @@ def compute_file_tree(
                     continue
                 suffix = extract_suffix_from_path(child_path)
                 suffixes.add(suffix)
-                n_files_per_dir_per_type[suffix] += 1
+                n_files_per_dir_and_type[suffix] += 1
                 n_objects += 1
-                if n_files_per_dir_per_type[suffix] == max_files_per_dir_per_type:
+                if n_files_per_dir_and_type[suffix] == n_max_files_per_dir_and_type:
                     yield prefix + "..."
-                elif n_files_per_dir_per_type[suffix] > max_files_per_dir_per_type:
+                elif n_files_per_dir_and_type[suffix] > n_max_files_per_dir_and_type:
                     continue
                 else:
                     yield prefix + pointer + child_path.name
 
     folder_tree = ""
     iterator = inner(path, level=level)
-    for line in islice(iterator, limit):
+    for line in islice(iterator, n_max_files):
         folder_tree += f"\n{line}"
     if next(iterator, None):
-        folder_tree += f"\n... only showing {limit} out of {n_objects} files"
+        folder_tree += f"\n... only showing {n_max_files} out of {n_objects} 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 ""
@@ -426,11 +514,12 @@ def compute_file_tree(
 def view_tree(
     path: Path,
     *,
-    level: int = -1,
+    level: int = 2,
     only_dirs: bool = False,
-    limit: int = 1000,
-    include_paths: Optional[Set[Any]] = None,
-    skip_suffixes: Optional[List[str]] = None,
+    n_max_files_per_dir_and_type: int = 100,
+    n_max_files: int = 1000,
+    include_paths: set[Any] | None = None,
+    skip_suffixes: list[str] | None = None,
 ) -> None:
     """Print a visual tree structure of files & directories.
 
@@ -438,7 +527,7 @@ def view_tree(
         level: If `1`, only iterate through one level, if `2` iterate through 2
             levels, if `-1` iterate through entire hierarchy.
         only_dirs: Only iterate through directories.
-        limit: Display limit. Will only show this many files. Doesn't affect count.
+        n_max_files: Display limit. Will only show this many files. Doesn't affect count.
         include_paths: Restrict to these paths.
         skip_suffixes: Skip directories with these suffixes.
 
@@ -472,7 +561,8 @@ def view_tree(
         path,
         level=level,
         only_dirs=only_dirs,
-        limit=limit,
+        n_max_files=n_max_files,
+        n_max_files_per_dir_and_type=n_max_files_per_dir_and_type,
         include_paths=include_paths,
         skip_suffixes=skip_suffixes,
     )
@@ -497,9 +587,10 @@ def to_url(upath):
     bucket = upath._url.netloc
     if bucket == "scverse-spatial-eu-central-1":
         region = "eu-central-1"
-    elif f"s3://{bucket}" not in hosted_buckets:
-        metadata = upath.fs.call_s3("head_bucket", Bucket=upath._url.netloc)
-        region = metadata["BucketRegion"]
+    elif f"s3://{bucket}" not in HOSTED_BUCKETS:
+        response = upath.fs.call_s3("head_bucket", Bucket=upath._url.netloc)
+        headers = response["ResponseMetadata"]["HTTPHeaders"]
+        region = headers.get("x-amz-bucket-region")
     else:
         region = bucket.replace("lamin_", "")
     if region == "us-east-1":
@@ -578,7 +669,7 @@ def convert_pathlike(pathlike: UPathStr) -> UPath:
     return path
 
 
-hosted_regions = [
+HOSTED_REGIONS = [
     "eu-central-1",
     "eu-west-2",
     "us-east-1",
@@ -588,16 +679,16 @@ hosted_regions = [
 ]
 lamin_env = os.getenv("LAMIN_ENV")
 if lamin_env is None or lamin_env == "prod":
-    hosted_buckets_list = [f"s3://lamin-{region}" for region in hosted_regions]
+    hosted_buckets_list = [f"s3://lamin-{region}" for region in HOSTED_REGIONS]
     hosted_buckets_list.append("s3://scverse-spatial-eu-central-1")
-    hosted_buckets = tuple(hosted_buckets_list)
+    HOSTED_BUCKETS = tuple(hosted_buckets_list)
 else:
-    hosted_buckets = ("s3://lamin-hosted-test",)  # type: ignore
-credentials_cache: Dict[str, Dict[str, str]] = {}
+    HOSTED_BUCKETS = ("s3://lamin-hosted-test",)  # type: ignore
+credentials_cache: dict[str, dict[str, str]] = {}
 AWS_CREDENTIALS_PRESENT = None
 
 
-def create_path(path: UPath, access_token: Optional[str] = None) -> UPath:
+def create_path(path: UPath, access_token: str | None = None) -> UPath:
     path = convert_pathlike(path)
     # test whether we have an AWS S3 path
     if not isinstance(path, S3Path):
@@ -611,9 +702,8 @@ def create_path(path: UPath, access_token: Optional[str] = None) -> UPath:
         if path.fs.key is not None and path.fs.secret is not None:
             anon = False
         else:
-            # we can do
-            # path.fs.connect()
-            # and check path.fs.session._credentials, but it is slower
+            # we could do path.fs.connect()
+            # and check path.fs.session._credentials, but it'd be slower
             session = botocore.session.get_session()
             credentials = session.get_credentials()
             if credentials is None or credentials.access_key is None:
@@ -625,7 +715,7 @@ def create_path(path: UPath, access_token: Optional[str] = None) -> UPath:
 
     # test whether we are on hosted storage or not
     path_str = path.as_posix()
-    is_hosted_storage = path_str.startswith(hosted_buckets)
+    is_hosted_storage = path_str.startswith(HOSTED_BUCKETS)
 
     if not is_hosted_storage:
         # make anon request if no credentials present
@@ -652,7 +742,7 @@ def create_path(path: UPath, access_token: Optional[str] = None) -> UPath:
     )
 
 
-def get_stat_file_cloud(stat: Dict) -> Tuple[int, str, str]:
+def get_stat_file_cloud(stat: dict) -> tuple[int, str, str]:
     size = stat["size"]
     # small files
     if "-" not in stat["ETag"]:
@@ -669,7 +759,7 @@ def get_stat_file_cloud(stat: Dict) -> Tuple[int, str, str]:
     return size, hash, hash_type
 
 
-def get_stat_dir_cloud(path: UPath) -> Tuple[int, str, str, int]:
+def get_stat_dir_cloud(path: UPath) -> tuple[int, str, str, int]:
     sizes = []
     md5s = []
     objects = path.fs.find(path.as_posix(), detail=True)
@@ -701,9 +791,18 @@ def check_storage_is_empty(
     # since path.fs.find raises a PermissionError on empty hosted
     # subdirectories (see lamindb_setup/core/_settings_storage/init_storage).
     n_offset_objects = 1  # because of touched dummy file, see mark_storage_root()
-    if account_for_sqlite_file:
-        n_offset_objects += 1  # because of SQLite file
-    objects = root_upath.fs.find(root_string)
+    if root_string.startswith(HOSTED_BUCKETS):
+        # in hosted buckets, count across entire root
+        directory_string = root_string
+        # the SQLite file is not in the ".lamindb" directory
+        if account_for_sqlite_file:
+            n_offset_objects += 1  # because of SQLite file
+    else:
+        # in any other storage location, only count in .lamindb
+        if not root_string.endswith("/"):
+            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
     ask_for_deletion = (
@@ -711,9 +810,13 @@ def check_storage_is_empty(
         if raise_error
         else "consider deleting them"
     )
+    hint = "'./lamindb/_is_initialized' "
+    if n_offset_objects == 2:
+        hint += "& SQLite file"
+    hint += " ignored"
     message = (
-        f"Storage location contains {n_objects} objects "
-        f"({n_offset_objects} ignored) - {ask_for_deletion}\n{objects}"
+        f"Storage {directory_string} contains {n_objects} objects "
+        f"({hint}) - {ask_for_deletion}\n{objects}"
     )
     if n_diff > 0:
         if raise_error:

{lamindb_setup-0.70.0.dist-info → lamindb_setup-0.71.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lamindb_setup
-Version: 0.70.0
+Version: 0.71.1
 Summary: Setup & configure LaminDB.
 Author-email: Lamin Labs <laminlabs@gmail.com>
 Description-Content-Type: text/markdown
@@ -14,7 +14,9 @@ Requires-Dist: requests
 Requires-Dist: universal_pathlib==0.1.4
 Requires-Dist: botocore<2.0.0
 Requires-Dist: supabase==2.2.1
-Requires-Dist: s3fs ; extra == "aws"
+Requires-Dist: urllib3<2 ; extra == "aws"
+Requires-Dist: aiobotocore[boto3]>=2.5.4,<3.0.0 ; extra == "aws"
+Requires-Dist: s3fs>=2023.12.2,<=2024.3.1 ; extra == "aws"
 Requires-Dist: pyjwt<3.0.0 ; extra == "dev"
 Requires-Dist: psycopg2-binary ; extra == "dev"
 Requires-Dist: python-dotenv ; extra == "dev"
@@ -25,12 +27,12 @@ Requires-Dist: pytest-xdist ; extra == "dev"
 Requires-Dist: nbproject-test>=0.4.3 ; extra == "dev"
 Requires-Dist: pandas ; extra == "dev"
 Requires-Dist: django-schema-graph ; extra == "erdiagram"
-Requires-Dist: faker ; extra == "hub"
+Requires-Dist: gcsfs>=2023.12.2,<=2024.3.1 ; extra == "gcp"
 Project-URL: Home, https://github.com/laminlabs/lamindb-setup
 Provides-Extra: aws
 Provides-Extra: dev
 Provides-Extra: erdiagram
-Provides-Extra: hub
+Provides-Extra: gcp
 
 [![codecov](https://codecov.io/gh/laminlabs/lamindb-setup/branch/main/graph/badge.svg)](https://codecov.io/gh/laminlabs/lamindb-setup)
 

lamindb_setup-0.71.1.dist-info/RECORD

@@ -0,0 +1,43 @@
+lamindb_setup/__init__.py,sha256=EIyvRHHlYOX7WsAFGdKp63ho-ceFW05z_n_GV1oJkaU,1542
+lamindb_setup/_cache.py,sha256=wA7mbysANwe8hPNbjDo9bOmXJ0xIyaS5iyxIpxSWji4,846
+lamindb_setup/_check.py,sha256=28PcG8Kp6OpjSLSi1r2boL2Ryeh6xkaCL87HFbjs6GA,129
+lamindb_setup/_check_setup.py,sha256=cNEL9Q4yPpmEkGKHH8JgullWl1VUZwALJ4RHn9wZypY,2613
+lamindb_setup/_close.py,sha256=1QS9p2SCacgovYn6xqWU4zFvwHN1RgIccvzwJgFvKgU,1186
+lamindb_setup/_connect_instance.py,sha256=c0qO0dn4hnEc-toRh6pxFaAxkhzM9LVN-72XK11JtAU,12616
+lamindb_setup/_delete.py,sha256=hf8zfVJfW74QR7eK4xJNQ6HbkkZBsl5eTqj-Ni5jPo0,7232
+lamindb_setup/_django.py,sha256=EoyWvFzH0i9wxjy4JZhcoXCTckztP_Mrl6FbYQnMmLE,1534
+lamindb_setup/_exportdb.py,sha256=uTIZjKKTB7arzEr1j0O6lONiT2pRBKeOFdLvOV8ZwzE,2120
+lamindb_setup/_importdb.py,sha256=yYYShzUajTsR-cTW4CZ-UNDWZY2uE5PAgNbp-wn8Ogc,1874
+lamindb_setup/_init_instance.py,sha256=Hy4PsPpXCdl5ik3Q0ODltVbbvYjAqnLnfFza2ai8nX8,11921
+lamindb_setup/_migrate.py,sha256=4nBTFg5-BK4A2gH-D3_tcFf8EtvMnIo5Mq0e_C6_9-U,8815
+lamindb_setup/_register_instance.py,sha256=Jeu0wyvJVSVQ_n-A_7yn7xOZIP0ncJD92DRABqzPIjA,940
+lamindb_setup/_schema.py,sha256=b3uzhhWpV5mQtDwhMINc2MabGCnGLESy51ito3yl6Wc,679
+lamindb_setup/_set_managed_storage.py,sha256=BUUJzKNWNEA5KnKnFZsas0ANU6w-LBZL-CKRu-sNLPE,1268
+lamindb_setup/_setup_user.py,sha256=6Oc7Rke-yRQSZbuntdUAz8QbJ6UuPzYHI9FnYlf_q-A,3670
+lamindb_setup/_silence_loggers.py,sha256=AKF_YcHvX32eGXdsYK8MJlxEaZ-Uo2f6QDRzjKFCtws,1568
+lamindb_setup/core/__init__.py,sha256=dV9S-rQpNK9JcBn4hiEmiLnmNqfpPFJD9pqagMCaIew,416
+lamindb_setup/core/_aws_storage.py,sha256=nEjeUv4xUVpoV0Lx-zjjmyb9w804bDyaeiM-OqbfwM0,1799
+lamindb_setup/core/_deprecated.py,sha256=3qxUI1dnDlSeR0BYrv7ucjqRBEojbqotPgpShXs4KF8,2520
+lamindb_setup/core/_docs.py,sha256=3k-YY-oVaJd_9UIY-LfBg_u8raKOCNfkZQPA73KsUhs,276
+lamindb_setup/core/_hub_client.py,sha256=V0qKDsCdRn-tQy2YIk4VgXcpJFmuum6N3gcavAC7gBQ,5504
+lamindb_setup/core/_hub_core.py,sha256=FpEXPqSHXAgYegyQmsma54S3bv_mtceXrrpHXa7UeKE,15970
+lamindb_setup/core/_hub_crud.py,sha256=b1XF7AJpM9Q-ttm9nPG-r3OTRWHQaGzAGIyvmb83NTo,4859
+lamindb_setup/core/_hub_utils.py,sha256=b_M1LkdCjiMWm1EOlSb9GuPdLijwVgQDtATTpeZuXI0,1875
+lamindb_setup/core/_settings.py,sha256=jjZ_AxRXB3Y3UP6m04BAw_dhFbJbdg2-nZWmEv2LNZ8,3141
+lamindb_setup/core/_settings_instance.py,sha256=RFUcnBBUp303dbVEHcAaIm_q7lzlWg56OrKLwdam8Pg,16588
+lamindb_setup/core/_settings_load.py,sha256=NGgCDpN85j1EqoKlrYFIlZBMlBJm33gx2-wc96CP_ZQ,3922
+lamindb_setup/core/_settings_save.py,sha256=d1A-Ex-7H08mb8l7I0Oe0j0GilrfaDuprh_NMxhQAsQ,2704
+lamindb_setup/core/_settings_storage.py,sha256=VgsqdIImQRfOZ6FGNY6DLVohaSxerj_F-sWtjD9hzcs,12382
+lamindb_setup/core/_settings_store.py,sha256=dagS5c7wAMRnuZTRfCU4sKaIOyF_HwAP5Fnnn8vphno,2084
+lamindb_setup/core/_settings_user.py,sha256=P2lC4WDRAFfT-Xq3MlXJ-wMKIHCoGNhMTQfRGIAyUNQ,1344
+lamindb_setup/core/_setup_bionty_sources.py,sha256=OgPpZxN2_Wffy-ogEBz_97c_k8d2bD-DDVt89-u9GLY,3002
+lamindb_setup/core/cloud_sqlite_locker.py,sha256=NIBNAGq7TTRrip9OzMdiQKj8QOuwhL9esyM0aehUqBA,6893
+lamindb_setup/core/django.py,sha256=m0AKg2lJ1EYCtEtZ8frFFJbAR9qX0gnFcgqp7aeC2k0,3450
+lamindb_setup/core/exceptions.py,sha256=eoI7AXgATgDVzgArtN7CUvpaMUC067vsBg5LHCsWzDM,305
+lamindb_setup/core/hashing.py,sha256=mv9UCvAsSrdHYQAv3Kz7UOvjd5tIjvDTIYv_ettBuVY,2218
+lamindb_setup/core/types.py,sha256=bcYnZ0uM_2NXKJCl94Mmc-uYrQlRUUVKG3sK2N-F-N4,532
+lamindb_setup/core/upath.py,sha256=XBiHm-gxtfDIHnQmH5WjjmZzmAg5S421fjAfRrEg710,28286
+lamindb_setup-0.71.1.dist-info/LICENSE,sha256=UOZ1F5fFDe3XXvG4oNnkL1-Ecun7zpHzRxjp-XsMeAo,11324
+lamindb_setup-0.71.1.dist-info/WHEEL,sha256=Sgu64hAMa6g5FdzHxXv9Xdse9yxpGGMeagVtPMWpJQY,99
+lamindb_setup-0.71.1.dist-info/METADATA,sha256=fijK20hR12pIxHzmECdbyguUSsHvVjIYTmfumfuLReQ,1620
+lamindb_setup-0.71.1.dist-info/RECORD,,

lamindb_setup/_add_remote_storage.py

@@ -1,50 +0,0 @@
-from lamin_utils import logger
-
-from lamindb_setup.core.types import UPathStr
-
-from ._init_instance import register_user_and_storage
-from .core._settings import settings
-from .core._settings_instance import InstanceSettings
-from .core._settings_storage import StorageSettings
-
-
-def switch_default_storage(root: UPathStr, **fs_kwargs):
-    """Add a remote default storage location to a local instance.
-
-    This can be used to selectively share data.
-
-    Args:
-        root: `UPathStr` - The new storage root, e.g., an S3 bucket.
-        **fs_kwargs: Additional fsspec arguments for cloud root, e.g., profile.
-
-    Example:
-    >>> ln.setup.set.storage(
-    >>>    "s3://some-bucket",
-    >>>     profile="some_profile", # fsspec arg
-    >>>     cache_regions=True # fsspec arg for s3
-    >>> )
-
-    """
-    if settings.instance.dialect == "sqlite":
-        logger.error("can't set storage for sqlite instances.")
-        return "set-storage-failed"
-    ssettings = StorageSettings(root=root)
-    new_isettings = InstanceSettings(
-        owner=settings.instance.owner,
-        name=settings.instance.name,
-        storage=ssettings,
-        db=settings.instance.db,
-        schema=settings.instance._schema_str,
-        id=settings.instance.id,
-    )
-
-    new_isettings._persist()  # this also updates the settings object
-    register_user_and_storage(new_isettings, settings.user)
-    # we are not doing this for now because of difficulties to define the right RLS policy  # noqa
-    # https://laminlabs.slack.com/archives/C04FPE8V01W/p1687948324601929?thread_ts=1687531921.394119&cid=C04FPE8V01W
-    # if settings.instance.is_remote:
-    #     init_storage_hub(
-    #         root, account_handle=settings.instance.owner  # type: ignore
-    #     )
-
-    settings.storage._set_fs_kwargs(**fs_kwargs)