lamindb_setup 1.5.0__tar.gz → 1.5.2__tar.gz

{lamindb_setup-1.5.0 → lamindb_setup-1.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lamindb_setup
-Version: 1.5.0
+Version: 1.5.2
 Summary: Setup & configure LaminDB.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Requires-Python: >=3.10
@@ -13,8 +13,8 @@ Requires-Dist: appdirs<2.0.0
 Requires-Dist: requests
 Requires-Dist: universal_pathlib==0.2.6
 Requires-Dist: botocore<2.0.0
-Requires-Dist: supabase>=2.8.1,<2.12.0
-Requires-Dist: gotrue<2.12.0
+Requires-Dist: supabase>=2.8.1,<=2.15.0
+Requires-Dist: gotrue<=2.12.0
 Requires-Dist: storage3!=0.11.2; python_version < '3.11'
 Requires-Dist: pyjwt<3.0.0
 Requires-Dist: psutil

lamindb_setup-1.5.0/docs/hub-prod/test-connect-anonymously-set-token.ipynb → lamindb_setup-1.5.2/docs/hub-prod/test-connect-anonymously.ipynb

@@ -14,9 +14,7 @@
    "outputs": [],
    "source": [
     "import pytest\n",
-    "import lamindb_setup as ln_setup\n",
-    "from lamindb_setup.core.django import db_token_manager\n",
-    "from django.db.utils import ProgrammingError"
+    "import lamindb_setup as ln_setup"
    ]
   },
   {
@@ -47,26 +45,6 @@
     "assert ln_setup.settings.storage._root is None"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# this just tests that the function is setup properly\n",
-    "# the actual functionality is tested in lamindb\n",
-    "# set_token sql function is not defined\n",
-    "db_token_manager.debug = True\n",
-    "db_token_manager.set(\"test\")\n",
-    "\n",
-    "with pytest.raises(ProgrammingError):\n",
-    "    ln_setup.settings.storage.record  # makes a db query through django\n",
-    "\n",
-    "db_token_manager.reset()  # turn off token\n",
-    "\n",
-    "ln_setup.settings.storage.record"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,

{lamindb_setup-1.5.0 → lamindb_setup-1.5.2}/lamindb_setup/__init__.py

@@ -33,7 +33,7 @@ Modules & settings:
 
 """
 
-__version__ = "1.5.0"  # denote a release candidate for 0.1.0 with 0.1rc1
+__version__ = "1.5.2"  # denote a release candidate for 0.1.0 with 0.1rc1
 
 import os
 

{lamindb_setup-1.5.0 → lamindb_setup-1.5.2}/lamindb_setup/_schema_metadata.py

@@ -150,6 +150,7 @@ class FieldMetadata(BaseModel):
     is_link_table: bool
     is_primary_key: bool
     is_editable: bool
+    max_length: int | None = None
     relation_type: RelationType | None = None
     related_field_name: str | None = None
     related_model_name: str | None = None
@@ -168,6 +169,10 @@ class _ModelHandler:
         self.included_modules = included_modules
         self.fields = self._get_fields_metadata(self.model)
         self.is_link_table = issubclass(model, LinkORM)
+        self.name_field = model._name_field if hasattr(model, "_name_field") else None
+        self.ontology_id_field = (
+            model._ontology_id_field if hasattr(model, "_ontology_id_field") else None
+        )
 
     def to_dict(self, include_django_objects: bool = True):
         _dict = {
@@ -175,6 +180,8 @@ class _ModelHandler:
             "class_name": self.class_name,
             "table_name": self.table_name,
             "is_link_table": self.is_link_table,
+            "name_field": self.name_field,
+            "ontology_id_field": self.ontology_id_field,
         }
 
         for field_name in self.fields.keys():
@@ -243,18 +250,21 @@ class _ModelHandler:
         internal_type = field.get_internal_type()
         model_name = field.model._meta.model_name
         relation_type = self._get_relation_type(model, field)
+
+        schema_name = field.model.__get_module_name__()
+
         if field.related_model is None:
-            schema_name = field.model.__get_module_name__()
             related_model_name = None
             related_schema_name = None
             related_field_name = None
             is_editable = field.editable
+            max_length = field.max_length
         else:
             related_model_name = field.related_model._meta.model_name
             related_schema_name = field.related_model.__get_module_name__()
-            schema_name = field.model.__get_module_name__()
             related_field_name = field.remote_field.name
             is_editable = False
+            max_length = None
 
         field_name = field.name
         is_primary_key = getattr(field, "primary_key", False)
@@ -289,6 +299,7 @@ class _ModelHandler:
             is_link_table=issubclass(field.model, LinkORM),
             is_primary_key=is_primary_key,
             is_editable=is_editable,
+            max_length=max_length,
             column_name=column,
             relation_type=relation_type,
             related_schema_name=related_schema_name

{lamindb_setup-1.5.0 → lamindb_setup-1.5.2}/lamindb_setup/core/_settings_user.py

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

{lamindb_setup-1.5.0 → lamindb_setup-1.5.2}/lamindb_setup/core/django.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 # flake8: noqa
 import builtins
 import os
+import jwt
+import time
 from pathlib import Path
 import time
 from ._settings_instance import InstanceSettings
@@ -14,15 +16,47 @@ IS_MIGRATING = False
 CONN_MAX_AGE = 299
 
 
+# db token that refreshes on access if needed
+class DBToken:
+    def __init__(
+        self, instance: InstanceSettings | dict, access_token: str | None = None
+    ):
+        self.instance = instance
+        self.access_token = access_token
+        # initialized in token_query
+        self._token: str | None = None
+        self._token_query: str | None = None
+        self._expiration: float
+
+    def _refresh_token(self):
+        from ._hub_core import access_db
+        from psycopg2.extensions import adapt
+
+        self._token = access_db(self.instance, self.access_token)
+        self._token_query = (
+            f"SELECT set_token({adapt(self._token).getquoted().decode()}, true);"
+        )
+        self._expiration = jwt.decode(self._token, options={"verify_signature": False})[
+            "exp"
+        ]
+
+    @property
+    def token_query(self) -> str:
+        # refresh token if needed
+        if self._token is None or time.time() >= self._expiration:
+            self._refresh_token()
+
+        return self._token_query  # type: ignore
+
+
 # a class to manage jwt in dbs
 class DBTokenManager:
-    def __init__(self, debug: bool = False):
+    def __init__(self):
         from django.db.transaction import Atomic
 
-        self.debug = debug
         self.original_atomic_enter = Atomic.__enter__
 
-        self.tokens: dict[str, str] = {}
+        self.tokens: dict[str, DBToken] = {}
 
     def get_connection(self, connection_name: str):
         from django.db import connections
@@ -32,19 +66,11 @@ class DBTokenManager:
 
         return connection
 
-    def set(self, token: str, connection_name: str = "default"):
+    def set(self, token: DBToken, connection_name: str = "default"):
         from django.db.transaction import Atomic
 
-        # no adapt in psycopg3
-        from psycopg2.extensions import adapt
-
         connection = self.get_connection(connection_name)
 
-        # escape correctly to avoid wrangling with params
-        set_token_query = (
-            f"SELECT set_token({adapt(token).getquoted().decode()}, true); "
-        )
-
         def set_token_wrapper(execute, sql, params, many, context):
             not_in_atomic_block = (
                 context is None
@@ -53,12 +79,7 @@ class DBTokenManager:
             )
             # ignore atomic blocks
             if not_in_atomic_block:
-                sql = set_token_query + sql
-            elif self.debug:
-                print("--in atomic block--")
-
-            if self.debug:
-                print(sql)
+                sql = token.token_query + sql
             result = execute(sql, params, many, context)
             # this ensures that psycopg3 in the current env doesn't break this wrapper
             # psycopg3 returns a cursor
@@ -69,30 +90,29 @@ class DBTokenManager:
                 and result is not None
                 and hasattr(result, "nextset")
             ):
-                if self.debug:
-                    print("(shift cursor)")
                 result.nextset()
             return result
 
         connection.execute_wrappers.append(set_token_wrapper)
 
+        self.tokens[connection_name] = token
+
         # ensure we set the token only once for an outer atomic block
         def __enter__(atomic):
             self.original_atomic_enter(atomic)
-            is_same_connection = (
-                "default" if atomic.using is None else atomic.using
-            ) == connection_name
-            if is_same_connection and len(connection.atomic_blocks) == 1:
-                # use raw psycopg2 connection here
-                # atomic block ensures connection
-                if self.debug:
-                    print("(set transaction token)")
-                connection.connection.cursor().execute(set_token_query)
+            connection_name = "default" if atomic.using is None else atomic.using
+            if connection_name in self.tokens:
+                # here we don't use the connection from the closure
+                # because Atomic is a single class to manage transactions for all connections
+                connection = self.get_connection(connection_name)
+                if len(connection.atomic_blocks) == 1:
+                    token = self.tokens[connection_name]
+                    # use raw psycopg2 connection here
+                    # atomic block ensures connection
+                    connection.connection.cursor().execute(token.token_query)
 
         Atomic.__enter__ = __enter__
 
-        self.tokens[connection_name] = token
-
     def reset(self, connection_name: str = "default"):
         from django.db.transaction import Atomic
 
@@ -103,7 +123,6 @@ class DBTokenManager:
             for w in connection.execute_wrappers
             if getattr(w, "__name__", None) != "set_token_wrapper"
         ]
-        Atomic.__enter__ = self.original_atomic_enter
 
         self.tokens.pop(connection_name, None)
 
@@ -198,9 +217,7 @@ def setup_django(
         BaseDatabaseWrapper.close_if_health_check_failed = close_if_health_check_failed
 
         if isettings._fine_grained_access and isettings._db_permissions == "jwt":
-            from ._hub_core import access_db
-
-            db_token = access_db(isettings)
+            db_token = DBToken(isettings)
             db_token_manager.set(db_token)  # sets for the default connection
 
     if configure_only:

{lamindb_setup-1.5.0 → lamindb_setup-1.5.2}/lamindb_setup/core/upath.py

@@ -51,6 +51,21 @@ VALID_SIMPLE_SUFFIXES = {
     ".xml",
     ".qs",  # https://cran.r-project.org/web/packages/qs/vignettes/vignette.html
     ".rds",
+    ".pt",
+    ".pth",
+    ".ckpt",
+    ".state_dict",
+    ".keras",
+    ".pb",
+    ".pbtxt",
+    ".savedmodel",
+    ".pkl",
+    ".pickle",
+    ".bin",
+    ".safetensors",
+    ".model",
+    ".mlmodel",
+    ".mar",
     #
     # with readers (see below)
     #

{lamindb_setup-1.5.0 → lamindb_setup-1.5.2}/pyproject.toml

@@ -18,8 +18,8 @@ dependencies = [
     "requests",
     "universal_pathlib==0.2.6",  # is still experimental, need pinning
     "botocore<2.0.0",
-    "supabase>=2.8.1,<2.12.0", # from 2.8.1 has correct lower bounds on gotrue
-    "gotrue<2.12.0", # supabase doesn't have this upper bound
+    "supabase>=2.8.1,<=2.15.0", # from 2.8.1 has correct lower bounds on gotrue
+    "gotrue<=2.12.0", # supabase doesn't have this upper bound
     "storage3!=0.11.2; python_version < '3.11'", # 0.11.2 breaks python 3.10 through usage of new types
     "pyjwt<3.0.0", # needed to decode jwt for sign in with the new api key
     "psutil",

{lamindb_setup-1.5.0 → lamindb_setup-1.5.2}/tests/hub-local/scripts/script-connect-fine-grained-access.py

@@ -2,7 +2,8 @@ import os
 
 import lamindb_setup as ln_setup
 import pytest
-from django.db import transaction
+from django.db import connection, transaction
+from django.db.utils import ProgrammingError
 from lamindb_setup.core._hub_core import access_db
 from lamindb_setup.core.django import db_token_manager
 
@@ -16,15 +17,28 @@ assert isettings._fine_grained_access
 assert isettings._db_permissions == "jwt"
 assert isettings._api_url is not None
 
-# test querying
-db_token_manager.debug = True
-
 storage_record = isettings.storage.record
 
 isettings.storage._record = None
 with transaction.atomic():
     assert isettings.storage.record.id == storage_record.id
 
+# check directly
+assert db_token_manager.tokens
+
+with connection.cursor() as cur:
+    cur.execute("SELECT get_account_id();")
+    account_id = cur.fetchall()[0][0]
+assert account_id == ln_setup.settings.user._uuid
+
+# check reset
+db_token_manager.reset()
+assert not db_token_manager.tokens
+
+# check after reset
+with pytest.raises(ProgrammingError) as error, connection.cursor() as cur:
+    cur.execute("SELECT get_account_id();")
+assert "JWT is not set" in error.exconly()
 # check calling access_db with a dict
 instance_dict = {
     "owner": isettings.owner,

{lamindb_setup-1.5.0 → lamindb_setup-1.5.2}/tests/hub-local/test_update_schema_in_hub.py

@@ -44,6 +44,14 @@ def test_update_schema_in_hub(setup_instance):
     assert not schema["schema_json"]["core"]["artifact"]["is_link_table"]
     assert schema["schema_json"]["core"]["artifactulabel"]["is_link_table"]
 
+    assert schema["schema_json"]["core"]["artifact"]["name_field"] is None
+    assert schema["schema_json"]["core"]["artifact"]["ontology_id_field"] is None
+    assert schema["schema_json"]["bionty"]["gene"]["name_field"] == "symbol"
+    assert (
+        schema["schema_json"]["bionty"]["gene"]["ontology_id_field"]
+        == "ensembl_gene_id"
+    )
+
     assert schema["schema_json"]["core"]["artifact"]["fields"]["id"] == {
         "type": "AutoField",
         "column_name": "id",
@@ -54,6 +62,24 @@ def test_update_schema_in_hub(setup_instance):
         "is_link_table": False,
         "is_primary_key": True,
         "is_editable": True,  # Primary key are read-only even if is_editable is True
+        "max_length": None,
+        "relation_type": None,
+        "related_field_name": None,
+        "related_model_name": None,
+        "related_schema_name": None,
+    }
+
+    assert schema["schema_json"]["core"]["artifact"]["fields"]["uid"] == {
+        "type": "CharField",
+        "column_name": "uid",
+        "through": None,
+        "field_name": "uid",
+        "model_name": "artifact",
+        "schema_name": "core",
+        "is_link_table": False,
+        "is_primary_key": False,
+        "is_editable": False,
+        "max_length": 20,
         "relation_type": None,
         "related_field_name": None,
         "related_model_name": None,
@@ -70,6 +96,7 @@ def test_update_schema_in_hub(setup_instance):
         "is_link_table": False,
         "is_primary_key": False,
         "is_editable": False,
+        "max_length": 64,
         "relation_type": None,
         "related_field_name": None,
         "related_model_name": None,
@@ -90,6 +117,7 @@ def test_update_schema_in_hub(setup_instance):
         "is_link_table": False,
         "is_primary_key": False,
         "is_editable": False,
+        "max_length": None,
         "relation_type": "many-to-one",
         "related_field_name": "created_artifacts",
         "related_model_name": "user",
@@ -110,6 +138,7 @@ def test_update_schema_in_hub(setup_instance):
         "is_link_table": False,
         "is_primary_key": False,
         "is_editable": False,
+        "max_length": None,
         "relation_type": "many-to-many",
         "related_field_name": "genes",
         "related_model_name": "pathway",
@@ -130,6 +159,7 @@ def test_update_schema_in_hub(setup_instance):
         "is_link_table": False,
         "is_primary_key": False,
         "is_editable": False,
+        "max_length": None,
         "relation_type": "many-to-many",
         "related_field_name": "wells",
         "related_model_name": "artifact",
@@ -150,6 +180,7 @@ def test_update_schema_in_hub(setup_instance):
         "is_link_table": False,
         "is_primary_key": False,
         "is_editable": False,
+        "max_length": None,
         "relation_type": "many-to-many",
         "related_field_name": "successors",
         "related_model_name": "transform",
@@ -170,6 +201,7 @@ def test_update_schema_in_hub(setup_instance):
         "is_link_table": False,
         "is_primary_key": False,
         "is_editable": False,
+        "max_length": None,
         "relation_type": "many-to-many",
         "related_field_name": "predecessors",
         "related_model_name": "transform",