lamindb_setup 0.77.0__tar.gz → 0.77.2__tar.gz

{lamindb_setup-0.77.0 → lamindb_setup-0.77.2}/.github/workflows/build.yml

@@ -12,7 +12,7 @@ jobs:
   # tests only on production hub
   hub-prod:
     runs-on: ubuntu-latest
-    timeout-minutes: 6
+    timeout-minutes: 7
     steps:
       - uses: actions/checkout@v3
       - uses: actions/setup-python@v4
@@ -27,10 +27,11 @@ jobs:
       - run: pip install "laminci@git+https://x-access-token:${{ secrets.LAMIN_BUILD_DOCS }}@github.com/laminlabs/laminci"
       - run: nox -s "install(group='hub-prod')"
       - run: nox -s "build(lamin_env='prod', group='hub-prod')"
-      - uses: actions/upload-artifact@v2
+      - uses: actions/upload-artifact@v4
         with:
           name: coverage--hub-prod
           path: .coverage
+          include-hidden-files: true
 
   # tests both on production and staging hub
   hub-cloud:
@@ -83,16 +84,17 @@ jobs:
       # - uses: "google-github-actions/setup-gcloud@v0"
       - run: nox -s "install(group='hub-cloud')"
       - run: nox -s "build(lamin_env='${{ matrix.lamin_env }}', group='hub-cloud')"
-      - uses: actions/upload-artifact@v2
+      - uses: actions/upload-artifact@v4
         if: ${{ matrix.lamin_env == 'prod' }}
         with:
           name: coverage--hub-cloud
           path: .coverage
+          include-hidden-files: true
 
   # test user access to storage
   storage:
     runs-on: ubuntu-latest
-    timeout-minutes: 6
+    timeout-minutes: 7
     steps:
       - uses: actions/checkout@v4
       - uses: actions/setup-python@v4
@@ -108,15 +110,16 @@ jobs:
           TEST_INSTANCE_PRIVATE_POSTGRES: ${{ secrets.TEST_INSTANCE_PRIVATE_POSTGRES }}
           TMP_AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
           TMP_AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-      - uses: actions/upload-artifact@v2
+      - uses: actions/upload-artifact@v4
         with:
           name: coverage--storage
           path: .coverage
+          include-hidden-files: true
 
   # test low-level hub functionality
   hub-local:
     runs-on: ubuntu-latest
-    timeout-minutes: 6
+    timeout-minutes: 7
     steps:
       - uses: aws-actions/configure-aws-credentials@v4
         with:
@@ -152,10 +155,11 @@ jobs:
       - run: nox -s hub_local
         env:
           LAMIN_ENV: "local"
-      - uses: actions/upload-artifact@v2
+      - uses: actions/upload-artifact@v4
         with:
           name: coverage--hub-local
           path: .coverage
+          include-hidden-files: true
 
   coverage:
     needs: [hub-prod, hub-cloud, storage, hub-local]
@@ -169,7 +173,7 @@ jobs:
       - run: |
           pip install coverage[toml]
           pip install --no-deps .
-      - uses: actions/download-artifact@v2
+      - uses: actions/download-artifact@v4
       - name: run coverage
         run: |
           coverage combine coverage--*/.coverage*
@@ -206,7 +210,7 @@ jobs:
           cache-dependency-path: ".github/workflows/build.yml"
       - run: pip install "laminci@git+https://x-access-token:${{ secrets.LAMIN_BUILD_DOCS }}@github.com/laminlabs/laminci"
       - run: nox -s "install(group='docs')"
-      - uses: actions/download-artifact@v2
+      - uses: actions/download-artifact@v4
       - run: nox -s docs
       - uses: nwtgck/actions-netlify@v1.2
         with:

{lamindb_setup-0.77.0 → lamindb_setup-0.77.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lamindb_setup
-Version: 0.77.0
+Version: 0.77.2
 Summary: Setup & configure LaminDB.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Description-Content-Type: text/markdown

{lamindb_setup-0.77.0 → lamindb_setup-0.77.2}/lamindb_setup/__init__.py

@@ -34,7 +34,7 @@ Modules & settings:
 
 """
 
-__version__ = "0.77.0"  # denote a release candidate for 0.1.0 with 0.1rc1
+__version__ = "0.77.2"  # denote a release candidate for 0.1.0 with 0.1rc1
 
 import os as _os
 import sys as _sys
@@ -45,6 +45,7 @@ from ._close import close
 from ._connect_instance import connect, load
 from ._delete import delete
 from ._django import django
+from ._entry_points import call_registered_entry_points as _call_registered_entry_points
 from ._init_instance import init
 from ._migrate import migrate
 from ._register_instance import register
@@ -68,4 +69,7 @@ if _os.name == "nt":
 
         threading.excepthook = _except_hook
 
+# provide a way for other packages to run custom code on import
+_call_registered_entry_points("lamindb_setup.on_import")
+
 settings.__doc__ = """Global :class:`~lamindb.setup.core.SetupSettings`."""

{lamindb_setup-0.77.0 → lamindb_setup-0.77.2}/lamindb_setup/_connect_instance.py

@@ -12,6 +12,7 @@ from ._init_instance import MESSAGE_NO_MULTIPLE_INSTANCE, load_from_isettings
 from ._migrate import check_whether_migrations_in_sync
 from ._silence_loggers import silence_loggers
 from .core._hub_core import connect_instance as load_instance_from_hub
+from .core._hub_core import connect_instance_new as load_instance_from_hub_edge
 from .core._hub_utils import (
     LaminDsn,
     LaminDsnModel,
@@ -126,7 +127,10 @@ def _connect_instance(
         # on the hub
         # do not call hub if the user is anonymous
         if owner != "anonymous":
-            hub_result = load_instance_from_hub(owner=owner, name=name)
+            if settings.user.handle in {"Koncopd", "sunnyosun", "falexwolf"}:
+                hub_result = load_instance_from_hub_edge(owner=owner, name=name)
+            else:
+                hub_result = load_instance_from_hub(owner=owner, name=name)
         else:
             hub_result = "anonymous-user"
         # if hub_result is not a string, it means it made a request

lamindb_setup-0.77.2/lamindb_setup/_entry_points.py

@@ -0,0 +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,
+            )

{lamindb_setup-0.77.0 → lamindb_setup-0.77.2}/lamindb_setup/_setup_user.py

@@ -28,7 +28,7 @@ def load_user(email: str | None = None, handle: str | None = None) -> UserSettin
     if settings_file.exists():
         user_settings = load_user_settings(settings_file)
         save_user_settings(user_settings)  # needed to save to current_user.env
-        assert user_settings.email is not None
+        assert user_settings.email is not None or user_settings.api_key is not None
     else:
         user_settings = load_or_create_user_settings()
         if email is None:
@@ -74,13 +74,15 @@ def login(
             # within UserSettings, we still call it "password" for a while
             user_settings.password = key
 
-        if user_settings.email is None:
-            raise SystemExit(f"✗ No stored user email, please call: lamin login {user}")
-
         if user_settings.password is None:
-            raise SystemExit(
-                "✗ No stored API key, please call: lamin login <your-email> --key <API-key>"
-            )
+            api_key = user_settings.api_key
+            if api_key is None:
+                raise SystemExit(
+                    "✗ No stored API key, please call: "
+                    "`lamin login` or `lamin login <your-email> --key <API-key>`"
+                )
+        elif user_settings.email is None:
+            raise SystemExit(f"✗ No stored user email, please call: lamin login {user}")
     else:
         user_settings = load_or_create_user_settings()
 
@@ -94,6 +96,7 @@ def login(
         )
     else:
         response = sign_in_hub_api_key(api_key)
+        user_settings.password = None
 
     if isinstance(response, Exception):
         raise response

{lamindb_setup-0.77.0 → lamindb_setup-0.77.2}/lamindb_setup/core/_hub_client.py

@@ -131,7 +131,7 @@ def call_with_fallback_auth(
         try:
             if renew_token:
                 logger.warning(
-                    "renewing expired lamin token: call `lamin login` to avoid this"
+                    "renewing expired lamin token: call `lamin login <your-handle>` to avoid this"
                 )
             client = connect_hub_with_auth(
                 renew_token=renew_token, fallback_env=fallback_env

{lamindb_setup-0.77.0 → lamindb_setup-0.77.2}/lamindb_setup/core/_hub_core.py

@@ -277,7 +277,6 @@ def _init_instance(isettings: InstanceSettings, client: Client) -> None:
         "id": isettings._id.hex,
         "account_id": settings.user._uuid.hex,  # type: ignore
         "name": isettings.name,
-        "storage_id": isettings.storage._uuid.hex,  # type: ignore
         "lnid": isettings.uid,
         "schema_str": isettings._schema_str,
         "lamindb_version": lamindb_version,
@@ -340,7 +339,7 @@ def _connect_instance(
         # get default storage
         storage = select_default_storage_by_instance_id(instance["id"], client)
         if storage is None:
-            return "storage-does-not-exist-on-hub"
+            return "default-storage-does-not-exist-on-hub"
     else:
         account = instance_account_storage.pop("account")
         storage = instance_account_storage.pop("storage")
@@ -367,6 +366,73 @@ def _connect_instance(
     return instance, storage  # type: ignore
 
 
+def _connect_instance_new(
+    owner: str,  # account_handle
+    name: str,  # instance_name
+    client: Client,
+) -> tuple[dict, dict] | str:
+    response = client.functions.invoke(
+        "get-instance-settings", invoke_options={"body": {"owner": owner, "name": name}}
+    )
+    # no instance found, check why is that
+    if response == b"{}":
+        # try the via single requests, will take more time
+        account = select_account_by_handle(owner, client)
+        if account is None:
+            return "account-not-exists"
+        instance = select_instance_by_name(account["id"], name, client)
+        if instance is None:
+            return "instance-not-found"
+        # get default storage
+        storage = select_default_storage_by_instance_id(instance["id"], client)
+        if storage is None:
+            return "default-storage-does-not-exist-on-hub"
+        logger.warning(
+            "Could not find instance via API, but found directly querying hub."
+        )
+    else:
+        instance = json.loads(response)
+        storage = instance.pop("storage")
+
+    if instance["db_scheme"] is not None:
+        db_user_name, db_user_password = None, None
+        if "db_user_name" in instance and "db_user_password" in instance:
+            db_user_name, db_user_password = (
+                instance["db_user_name"],
+                instance["db_user_password"],
+            )
+        else:
+            db_user = select_db_user_by_instance(instance["id"], client)
+            if db_user is not None:
+                db_user_name, db_user_password = (
+                    db_user["db_user_name"],
+                    db_user["db_user_password"],
+                )
+        db_dsn = LaminDsn.build(
+            scheme=instance["db_scheme"],
+            user=db_user_name if db_user_name is not None else "none",
+            password=db_user_password if db_user_password is not None else "none",
+            host=instance["db_host"],
+            port=instance["db_port"],
+            database=instance["db_database"],
+        )
+        instance["db"] = db_dsn
+    return instance, storage  # type: ignore
+
+
+def connect_instance_new(
+    *,
+    owner: str,  # account_handle
+    name: str,  # instance_name
+) -> tuple[dict, dict] | str:
+    from ._settings import settings
+
+    if settings.user.handle != "anonymous":
+        return call_with_fallback_auth(_connect_instance_new, owner=owner, name=name)
+    else:
+        return call_with_fallback(_connect_instance_new, owner=owner, name=name)
+
+
 def access_aws(storage_root: str, access_token: str | None = None) -> dict[str, dict]:
     from ._settings import settings
 

{lamindb_setup-0.77.0 → lamindb_setup-0.77.2}/lamindb_setup/core/_settings_instance.py

@@ -333,6 +333,12 @@ class InstanceSettings:
     @property
     def db(self) -> str:
         """Database connection string (URI)."""
+        if "LAMINDB_DJANGO_DATABASE_URL" in os.environ:
+            logger.warning(
+                "LAMINDB_DJANGO_DATABASE_URL env variable "
+                f"is set to {os.environ['LAMINDB_DJANGO_DATABASE_URL']}. "
+                "It overwrites all db connections and is used instead of `instance.db`."
+            )
         if self._db is None:
             # here, we want the updated sqlite file
             # hence, we don't use self._sqlite_file_local()

{lamindb_setup-0.77.0 → lamindb_setup-0.77.2}/lamindb_setup/core/_settings_save.py

@@ -55,7 +55,7 @@ def save_settings(
                         settings_key = f"_{store_key.rstrip('_')}"
                     else:
                         settings_key = store_key
-                    value = getattr(settings, settings_key)
+                    value = getattr(settings, settings_key, None)
                 if value is None:
                     value = "null"
                 elif isinstance(value, UUID):

{lamindb_setup-0.77.0 → lamindb_setup-0.77.2}/lamindb_setup/core/_settings_store.py

@@ -49,12 +49,14 @@ def system_storage_settings_file():
 
 
 class InstanceSettingsStore(BaseSettings):
+    api_url: Optional[str] = None
     owner: str
     name: str
     storage_root: str
     storage_region: Optional[str]  # take old type annotations here because pydantic
     db: Optional[str]  # doesn't like new types on 3.9 even with future annotations
     schema_str: Optional[str]
+    schema_id: Optional[str] = None
     id: str
     git_repo: Optional[str]
     keep_artifacts_local: Optional[bool]

{lamindb_setup-0.77.0 → lamindb_setup-0.77.2}/lamindb_setup/core/django.py

@@ -42,6 +42,7 @@ def setup_django(
     # configuration
     if not settings.configured:
         default_db = dj_database_url.config(
+            env="LAMINDB_DJANGO_DATABASE_URL",
             default=isettings.db,
             # see comment next to patching BaseDatabaseWrapper below
             conn_max_age=CONN_MAX_AGE,

{lamindb_setup-0.77.0 → lamindb_setup-0.77.2}/tests/hub-cloud/test_login.py

@@ -29,12 +29,14 @@ def test_login():
 
 def test_login_api_key():
     ln_setup.login("testuser1")
+    save_password = ln_setup.settings.user.password
     # obtain API key
-    expires_at = (datetime.now(tz=timezone.utc) + timedelta(days=1)).strftime(
-        "%Y-%m-%d"
-    )
+    expires_at = datetime.now(tz=timezone.utc) + timedelta(days=1)
     api_key = create_api_key(
-        {"expires_at": expires_at, "description": "test_login_api_key"}
+        {
+            "expires_at": expires_at.strftime("%Y-%m-%d"),
+            "description": "test_login_api_key",
+        }
     )
 
     ln_setup.logout()
@@ -50,12 +52,22 @@ def test_login_api_key():
     ln_setup.login()
     assert ln_setup.settings.user.handle == "testuser1"
     assert ln_setup.settings.user.api_key == api_key
+    assert ln_setup.settings.user.password is None
 
     ln_setup.logout()
 
     ln_setup.login(api_key=api_key)
     assert ln_setup.settings.user.handle == "testuser1"
     assert ln_setup.settings.user.api_key == api_key
+    assert ln_setup.settings.user.password is None
+
+    ln_setup.logout()
+
+    # load from handle env
+    ln_setup.login("testuser1")
+    assert ln_setup.settings.user.handle == "testuser1"
+    assert ln_setup.settings.user.api_key == api_key
+    assert ln_setup.settings.user.password is None
 
     # clean up
     # here checks also refreshing access token with api_key
@@ -64,4 +76,7 @@ def test_login_api_key():
     hub.auth.sign_out({"scope": "local"})
 
     # login back with email to populate all fields
-    ln_setup.login("testuser1@lamin.ai")
+    ln_setup.login("testuser1@lamin.ai", key=save_password)
+    assert ln_setup.settings.user.handle == "testuser1"
+    assert ln_setup.settings.user.api_key is None
+    assert ln_setup.settings.user.password == save_password

{lamindb_setup-0.77.0 → lamindb_setup-0.77.2}/tests/hub-local/test_all.py

@@ -8,10 +8,13 @@ import pytest
 from gotrue.errors import AuthApiError
 from lamindb_setup.core._hub_client import (
     Environment,
+    connect_hub,
     connect_hub_with_auth,
 )
 from lamindb_setup.core._hub_core import (
+    _connect_instance_new,
     connect_instance,
+    connect_instance_new,
     init_instance,
     init_storage,
     sign_in_hub,
@@ -255,6 +258,48 @@ def test_db_user(
     assert db_user["name"] == "write"
 
 
+def test_connect_instance_new(create_myinstance, create_testadmin1_session):
+    admin_client, _ = create_testadmin1_session
+
+    owner, name = ln_setup.settings.user.handle, create_myinstance["name"]
+    instance, storage = connect_instance_new(owner=owner, name=name)
+    assert instance["name"] == name
+    assert instance["owner"] == owner
+    assert instance["api_url"] is None
+    assert instance["db_permissions"] == "write"
+    assert storage["root"] == "s3://lamindb-ci/myinstance"
+    assert "schema_id" in instance
+
+    # add db_server from seed_local_test
+    admin_client.table("instance").update(
+        {"db_server_id": "e36c7069-2129-4c78-b2c6-323e2354b741"}
+    ).eq("id", instance["id"]).execute()
+
+    instance, _ = connect_instance_new(owner=owner, name=name)
+    assert instance["api_url"] == "http://localhost:8000"
+
+    # test anon access to public instance
+    update_instance(
+        instance_id=create_myinstance["id"],
+        instance_fields={"public": True},
+        client=admin_client,
+    )
+
+    anon_client = connect_hub()
+    instance, _ = _connect_instance_new(owner=owner, name=name, client=anon_client)
+
+    update_instance(
+        instance_id=create_myinstance["id"],
+        instance_fields={"public": False},
+        client=admin_client,
+    )
+    # test non-existent
+    result = connect_instance_new(owner="user-not-exists", name=name)
+    assert result == "account-not-exists"
+    result = connect_instance_new(owner=owner, name="instance-not-exists")
+    assert result == "instance-not-found"
+
+
 def test_connect_instance(create_myinstance, create_testadmin1_session):
     # trigger return for inexistent handle
     assert "account-not-exists" == connect_instance(

{lamindb_setup-0.77.0 → lamindb_setup-0.77.2}/tests/hub-local/test_update_schema_in_hub.py

@@ -82,7 +82,7 @@ def test_update_schema_in_hub(setup_instance):
         "schema_name": "core",
         "is_link_table": False,
         "relation_type": "many-to-one",
-        "related_field_name": "artifact",
+        "related_field_name": "created_artifacts",
         "related_model_name": "user",
         "related_schema_name": "core",
     }
@@ -111,7 +111,7 @@ def test_update_schema_in_hub(setup_instance):
         "through": {
             "left_key": "well_id",
             "right_key": "artifact_id",
-            "link_table_name": "wetlab_well_artifacts",
+            "link_table_name": "wetlab_artifactwell",
         },
         "field_name": "artifacts",
         "model_name": "well",

lamindb_setup-0.77.2/tests/storage/test_entry_point.py

@@ -0,0 +1,76 @@
+import shlex
+import subprocess
+import sys
+
+import pytest
+
+pyproject_toml = """\
+[project]
+name = "my_custom_module"
+version = "0.0.1"
+
+# pyproject.toml
+[project.entry-points."lamindb_setup.on_import"]
+my_custom_function = "my_custom_module:my_custom_function"
+"""
+
+my_custom_module = """\
+import os
+
+def my_custom_function():
+    os.environ["MY_CUSTOM_ENV_VAR"] = "1"
+"""
+
+
+@pytest.fixture
+def installed_custom_module(tmp_path):
+    (tmp_path / "pyproject.toml").write_text(pyproject_toml)
+    (tmp_path / "my_custom_module.py").write_text(my_custom_module)
+    cmd_install = [sys.executable, "-m", "pip", "install", str(tmp_path)]
+    cmd_cleanup = [sys.executable, "-m", "pip", "uninstall", "my_custom_module", "-y"]
+
+    subprocess.run(shlex.join(cmd_install), shell=True, check=True)
+    try:
+        yield
+    finally:
+        subprocess.run(shlex.join(cmd_cleanup), shell=True, check=True)
+
+
+@pytest.mark.parametrize(
+    "output,install_custom",
+    [
+        pytest.param(b"0", False, id="no-entry-point"),
+        pytest.param(b"1", True, id="with-entry-point"),
+    ],
+)
+def test_on_import_entry_point(output, install_custom, request):
+    if install_custom:
+        request.getfixturevalue("installed_custom_module")
+
+    cmd = [
+        sys.executable,
+        "-c",
+        "import lamindb_setup; import os; print(os.environ.get('MY_CUSTOM_ENV_VAR', '0'), end='')",
+    ]
+    out = subprocess.run(
+        shlex.join(cmd),
+        shell=True,
+        capture_output=True,
+        env={"PYTHONWARNINGS": "error"},
+    )
+    assert out.returncode == 0
+    assert out.stderr == b""
+    assert out.stdout == output
+
+
+def test_call_registered_entry_points(installed_custom_module):
+    from lamindb_setup._entry_points import call_registered_entry_points
+
+    call_registered_entry_points("lamindb_setup.on_import")
+
+
+def test_broken_entry_points_does_not_crash(installed_custom_module):
+    from lamindb_setup._entry_points import call_registered_entry_points
+
+    with pytest.warns(RuntimeWarning, match="Error loading entry point"):
+        call_registered_entry_points("lamindb_setup.on_import", broken_kwarg=object())