lamindb_setup 0.77.2__py2.py3-none-any.whl → 0.77.4__py2.py3-none-any.whl

lamindb_setup/_delete.py

@@ -12,7 +12,7 @@ from .core._hub_core import delete_instance as delete_instance_on_hub
 from .core._hub_core import get_storage_records_for_instance
 from .core._settings import settings
 from .core._settings_storage import StorageSettings
-from .core.upath import check_storage_is_empty
+from .core.upath import LocalPathClasses, check_storage_is_empty
 
 if TYPE_CHECKING:
     from pathlib import Path
@@ -20,9 +20,13 @@ if TYPE_CHECKING:
     from .core._settings_instance import InstanceSettings
 
 
-def delete_cache(cache_dir: Path):
-    if cache_dir is not None and cache_dir.exists():
-        shutil.rmtree(cache_dir)
+def delete_cache(isettings: InstanceSettings):
+    # avoid init of root
+    root = isettings.storage._root_init
+    if not isinstance(root, LocalPathClasses):
+        cache_dir = isettings.storage.cache_dir / root
+        if cache_dir.exists():
+            shutil.rmtree(cache_dir)
 
 
 def delete_exclusion_dir(isettings: InstanceSettings) -> None:
@@ -35,7 +39,7 @@ def delete_by_isettings(isettings: InstanceSettings) -> None:
     settings_file = isettings._get_settings_file()
     if settings_file.exists():
         settings_file.unlink()
-    delete_cache(isettings.storage.cache_dir)
+    delete_cache(isettings)
     if isettings.dialect == "sqlite":
         try:
             if isettings._sqlite_file.exists():

lamindb_setup/_django.py

@@ -1,41 +1,41 @@
-from __future__ import annotations
-
-from typing import Optional
-
-from .core._settings import settings
-from .core.django import setup_django
-
-
-def django(command: str, package_name: str | None = None, **kwargs):
-    r"""Manage migrations.
-
-    Examples:
-
-    Reset auto-incrementing primary integer ids after a database import:
-
-    >>> import lamindb as ln
-    >>> ln.setup.django("sqlsequencereset", "lnschema_core")
-    BEGIN;
-    SELECT setval(pg_get_serial_sequence('"lnschema_core_user"','id'), coalesce(max("id"), 1), max("id") IS NOT null) FROM "lnschema_core_user";  # noqa
-    SELECT setval(pg_get_serial_sequence('"lnschema_core_storage"','id'), coalesce(max("id"), 1), max("id") IS NOT null) FROM "lnschema_core_storage";  # noqa
-    COMMIT;
-
-    You can then run the SQL output that you'll see like so:
-
-    >>> sql = \"\"\"BEGIN;
-        SELECT setval(pg_get_serial_sequence('"lnschema_core_user"','id'), coalesce(max("id"), 1), max("id") IS NOT null) FROM "lnschema_core_user";  # noqa
-        SELECT setval(pg_get_serial_sequence('"lnschema_core_storage"','id'), coalesce(max("id"), 1), max("id") IS NOT null) FROM "lnschema_core_storage";  # noqa
-        COMMIT;\"\"\"
-    >>> from django.db import connection
-    >>> with connection.cursor() as cursor:
-            cursor.execute(sql)
-
-    """
-    from django.core.management import call_command
-
-    setup_django(settings.instance)
-    if package_name is not None:
-        args = [package_name]
-    else:
-        args = []
-    call_command(command, *args, **kwargs)
+from __future__ import annotations
+
+from typing import Optional
+
+from .core._settings import settings
+from .core.django import setup_django
+
+
+def django(command: str, package_name: str | None = None, **kwargs):
+    r"""Manage migrations.
+
+    Examples:
+
+    Reset auto-incrementing primary integer ids after a database import:
+
+    >>> import lamindb as ln
+    >>> ln.setup.django("sqlsequencereset", "lnschema_core")
+    BEGIN;
+    SELECT setval(pg_get_serial_sequence('"lnschema_core_user"','id'), coalesce(max("id"), 1), max("id") IS NOT null) FROM "lnschema_core_user";  # noqa
+    SELECT setval(pg_get_serial_sequence('"lnschema_core_storage"','id'), coalesce(max("id"), 1), max("id") IS NOT null) FROM "lnschema_core_storage";  # noqa
+    COMMIT;
+
+    You can then run the SQL output that you'll see like so:
+
+    >>> sql = \"\"\"BEGIN;
+        SELECT setval(pg_get_serial_sequence('"lnschema_core_user"','id'), coalesce(max("id"), 1), max("id") IS NOT null) FROM "lnschema_core_user";  # noqa
+        SELECT setval(pg_get_serial_sequence('"lnschema_core_storage"','id'), coalesce(max("id"), 1), max("id") IS NOT null) FROM "lnschema_core_storage";  # noqa
+        COMMIT;\"\"\"
+    >>> from django.db import connection
+    >>> with connection.cursor() as cursor:
+            cursor.execute(sql)
+
+    """
+    from django.core.management import call_command
+
+    setup_django(settings.instance)
+    if package_name is not None:
+        args = [package_name]
+    else:
+        args = []
+    call_command(command, *args, **kwargs)

lamindb_setup/_entry_points.py

@@ -1,22 +1,22 @@
-import sys
-import warnings
-from importlib.metadata import entry_points
-
-
-def call_registered_entry_points(group, **kwargs):
-    """load and call entry points registered under group."""
-    if sys.version_info >= (3, 10):
-        eps = entry_points(group=group)
-    else:
-        eps = entry_points().get(group, [])
-
-    for ep in eps:
-        func = ep.load()
-        try:
-            func(**kwargs)
-        except BaseException as e:
-            warnings.warn(
-                f"Error loading entry point of group {group!r}: {ep} -> {e}",
-                RuntimeWarning,
-                stacklevel=2,
-            )
+import sys
+import warnings
+from importlib.metadata import entry_points
+
+
+def call_registered_entry_points(group, **kwargs):
+    """load and call entry points registered under group."""
+    if sys.version_info >= (3, 10):
+        eps = entry_points(group=group)
+    else:
+        eps = entry_points().get(group, [])
+
+    for ep in eps:
+        func = ep.load()
+        try:
+            func(**kwargs)
+        except BaseException as e:
+            warnings.warn(
+                f"Error loading entry point of group {group!r}: {ep} -> {e}",
+                RuntimeWarning,
+                stacklevel=2,
+            )

lamindb_setup/_exportdb.py

@@ -1,68 +1,68 @@
-from __future__ import annotations
-
-from importlib import import_module
-from pathlib import Path
-
-MODELS = {
-    "core": {
-        "Collection": False,
-        "Artifact": False,
-        "Transform": False,
-        "Run": True,
-        "User": False,
-        "Storage": False,
-        "Feature": False,
-        "FeatureSet": False,
-        "ULabel": False,
-    },
-    # "bionty": {
-    #     "Organism": False,
-    #     "Gene": False,
-    #     "Protein": False,
-    #     "CellMarker": False,
-    #     "Tissue": False,
-    #     "CellType": False,
-    #     "Disease": False,
-    #     "CellLine": False,
-    #     "Phenotype": False,
-    #     "Pathway": False,
-    #     "ExperimentalFactor": False,
-    #     "DevelopmentalStage": False,
-    #     "Ethnicity": False,
-    #     "Source": False,
-    # },
-    # "wetlab": {
-    #     "ExperimentType": False,
-    #     "Experiment": False,
-    #     "Well": False,
-    #     "TreatmentTarget": False,
-    #     "Treatment": False,
-    #     "Biosample": False,
-    #     "Techsample": False,
-    # },
-}
-
-
-def exportdb() -> None:
-    directory = Path("./lamindb_export/")
-    directory.mkdir(parents=True, exist_ok=True)
-    import pandas as pd
-
-    import lamindb_setup as ln_setup
-
-    def export_registry(registry, directory):
-        table_name = registry._meta.db_table
-        df = pd.read_sql_table(table_name, ln_setup.settings.instance.db)
-        df.to_parquet(directory / f"{table_name}.parquet", compression=None)
-
-    # export data to parquet files
-    print(f"\nexporting data to parquet files in: {directory}\n")
-    for schema_name, models in MODELS.items():
-        for model_name in models.keys():
-            schema_module = import_module(f"lnschema_{schema_name}")
-            registry = getattr(schema_module, model_name)
-            export_registry(registry, directory)
-            many_to_many_names = [field.name for field in registry._meta.many_to_many]
-            for many_to_many_name in many_to_many_names:
-                link_orm = getattr(registry, many_to_many_name).through
-                export_registry(link_orm, directory)
+from __future__ import annotations
+
+from importlib import import_module
+from pathlib import Path
+
+MODELS = {
+    "core": {
+        "Collection": False,
+        "Artifact": False,
+        "Transform": False,
+        "Run": True,
+        "User": False,
+        "Storage": False,
+        "Feature": False,
+        "FeatureSet": False,
+        "ULabel": False,
+    },
+    # "bionty": {
+    #     "Organism": False,
+    #     "Gene": False,
+    #     "Protein": False,
+    #     "CellMarker": False,
+    #     "Tissue": False,
+    #     "CellType": False,
+    #     "Disease": False,
+    #     "CellLine": False,
+    #     "Phenotype": False,
+    #     "Pathway": False,
+    #     "ExperimentalFactor": False,
+    #     "DevelopmentalStage": False,
+    #     "Ethnicity": False,
+    #     "Source": False,
+    # },
+    # "wetlab": {
+    #     "ExperimentType": False,
+    #     "Experiment": False,
+    #     "Well": False,
+    #     "TreatmentTarget": False,
+    #     "Treatment": False,
+    #     "Biosample": False,
+    #     "Techsample": False,
+    # },
+}
+
+
+def exportdb() -> None:
+    directory = Path("./lamindb_export/")
+    directory.mkdir(parents=True, exist_ok=True)
+    import pandas as pd
+
+    import lamindb_setup as ln_setup
+
+    def export_registry(registry, directory):
+        table_name = registry._meta.db_table
+        df = pd.read_sql_table(table_name, ln_setup.settings.instance.db)
+        df.to_parquet(directory / f"{table_name}.parquet", compression=None)
+
+    # export data to parquet files
+    print(f"\nexporting data to parquet files in: {directory}\n")
+    for schema_name, models in MODELS.items():
+        for model_name in models.keys():
+            schema_module = import_module(f"lnschema_{schema_name}")
+            registry = getattr(schema_module, model_name)
+            export_registry(registry, directory)
+            many_to_many_names = [field.name for field in registry._meta.many_to_many]
+            for many_to_many_name in many_to_many_names:
+                link_orm = getattr(registry, many_to_many_name).through
+                export_registry(link_orm, directory)

lamindb_setup/_importdb.py

@@ -1,50 +1,50 @@
-from __future__ import annotations
-
-from importlib import import_module
-from pathlib import Path
-
-from ._exportdb import MODELS
-
-
-def import_registry(registry, directory, connection):
-    import pandas as pd
-
-    table_name = registry._meta.db_table
-    df = pd.read_parquet(directory / f"{table_name}.parquet")
-    old_foreign_key_columns = [
-        column for column in df.columns if column.endswith("_old")
-    ]
-    for column in old_foreign_key_columns:
-        df.drop(column, axis=1, inplace=True)
-    df.to_sql(table_name, connection, if_exists="append", index=False)
-
-
-def importdb() -> None:
-    # import data from parquet files
-    directory = Path("./lamindb_export/")
-    if directory.exists():
-        response = input(
-            f"\n\nDo you want to import registries from here: {directory}? (y/n)\n"
-        )
-        if response != "y":
-            return None
-    from sqlalchemy import create_engine, text
-
-    import lamindb_setup as ln_setup
-
-    engine = create_engine(ln_setup.settings.instance.db, echo=False)
-    with engine.begin() as connection:
-        if ln_setup.settings.instance.dialect == "postgresql":
-            connection.execute(text("SET CONSTRAINTS ALL DEFERRED;"))
-        for schema_name, models in MODELS.items():
-            for model_name in models.keys():
-                print(model_name)
-                schema_module = import_module(f"lnschema_{schema_name}")
-                registry = getattr(schema_module, model_name)
-                import_registry(registry, directory, connection)
-                many_to_many_names = [
-                    field.name for field in registry._meta.many_to_many
-                ]
-                for many_to_many_name in many_to_many_names:
-                    link_orm = getattr(registry, many_to_many_name).through
-                    import_registry(link_orm, directory, connection)
+from __future__ import annotations
+
+from importlib import import_module
+from pathlib import Path
+
+from ._exportdb import MODELS
+
+
+def import_registry(registry, directory, connection):
+    import pandas as pd
+
+    table_name = registry._meta.db_table
+    df = pd.read_parquet(directory / f"{table_name}.parquet")
+    old_foreign_key_columns = [
+        column for column in df.columns if column.endswith("_old")
+    ]
+    for column in old_foreign_key_columns:
+        df.drop(column, axis=1, inplace=True)
+    df.to_sql(table_name, connection, if_exists="append", index=False)
+
+
+def importdb() -> None:
+    # import data from parquet files
+    directory = Path("./lamindb_export/")
+    if directory.exists():
+        response = input(
+            f"\n\nDo you want to import registries from here: {directory}? (y/n)\n"
+        )
+        if response != "y":
+            return None
+    from sqlalchemy import create_engine, text
+
+    import lamindb_setup as ln_setup
+
+    engine = create_engine(ln_setup.settings.instance.db, echo=False)
+    with engine.begin() as connection:
+        if ln_setup.settings.instance.dialect == "postgresql":
+            connection.execute(text("SET CONSTRAINTS ALL DEFERRED;"))
+        for schema_name, models in MODELS.items():
+            for model_name in models.keys():
+                print(model_name)
+                schema_module = import_module(f"lnschema_{schema_name}")
+                registry = getattr(schema_module, model_name)
+                import_registry(registry, directory, connection)
+                many_to_many_names = [
+                    field.name for field in registry._meta.many_to_many
+                ]
+                for many_to_many_name in many_to_many_names:
+                    link_orm = getattr(registry, many_to_many_name).through
+                    import_registry(link_orm, directory, connection)