lamindb 1.10.0__tar.gz → 1.10.1__tar.gz

{lamindb-1.10.0 → lamindb-1.10.1}/.github/workflows/build.yml

@@ -69,7 +69,7 @@ jobs:
       - uses: actions/setup-python@v5
         with:
           python-version: |
-            ${{ github.ref == 'refs/heads/release' && '3.10' ||
+            ${{ github.ref == 'refs/heads/release' && '3.11' ||
                 '3.13'
                 }}
 

{lamindb-1.10.0 → lamindb-1.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: lamindb
-Version: 1.10.0
+Version: 1.10.1
 Summary: A data framework for biology.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Requires-Python: >=3.10,<3.14
@@ -11,7 +11,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: lamin_utils==0.15.0
 Requires-Dist: lamin_cli==1.6.1
-Requires-Dist: lamindb_setup[aws]==1.9.0
+Requires-Dist: lamindb_setup[aws]==1.9.1
 Requires-Dist: pyyaml
 Requires-Dist: pyarrow
 Requires-Dist: pandera>=0.24.0
@@ -19,7 +19,7 @@ Requires-Dist: typing_extensions!=4.6.0
 Requires-Dist: python-dateutil
 Requires-Dist: pandas>=2.0.0
 Requires-Dist: scipy<1.15.0
-Requires-Dist: anndata>=0.8.0,<=0.12.0
+Requires-Dist: anndata>=0.8.0,<=0.12.1
 Requires-Dist: fsspec
 Requires-Dist: graphviz
 Requires-Dist: psycopg2-binary

{lamindb-1.10.0 → lamindb-1.10.1}/docs/arrays.ipynb

@@ -102,62 +102,6 @@
     "ln.Artifact(\"s3://lamindb-ci/test-arrays/testfile.hdf5\").save()"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Note that it is also possible to register Hugging Face paths. For this `huggingface_hub` package should be installed."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We register a folder of `parquet` files as a single artifact."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": [
-     "hide-output"
-    ]
-   },
-   "outputs": [],
-   "source": [
-    "ln.Artifact(\"hf://datasets/Koncopd/lamindb-test/sharded_parquet\").save()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "We also register a collection of individual `parquet` files."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {
-    "tags": [
-     "hide-output"
-    ]
-   },
-   "outputs": [],
-   "source": [
-    "artifact_shard1 = ln.Artifact(\n",
-    "    \"hf://datasets/Koncopd/lamindb-test/sharded_parquet/louvain=0/947eee0b064440c9b9910ca2eb89e608-0.parquet\"\n",
-    ").save()\n",
-    "artifact_shard2 = ln.Artifact(\n",
-    "    \"hf://datasets/Koncopd/lamindb-test/sharded_parquet/louvain=1/947eee0b064440c9b9910ca2eb89e608-0.parquet\"\n",
-    ").save()\n",
-    "\n",
-    "ln.Collection(\n",
-    "    [artifact_shard1, artifact_shard2], key=\"sharded_parquet_collection\"\n",
-    ").save()"
-   ]
-  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -495,13 +439,20 @@
     "A dataframe stored as sharded `parquet`."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Note that it is also possible to register and access Hugging Face paths. For this `huggingface_hub` package should be installed."
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
-    "artifact = ln.Artifact.get(key=\"sharded_parquet\")"
+    "artifact = ln.Artifact.using(\"laminlabs/lamindata\").get(key=\"sharded_parquet\")"
    ]
   },
   {
@@ -572,13 +523,19 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "collection = ln.Collection.get(key=\"sharded_parquet_collection\")"
+    "collection = ln.Collection.using(\"laminlabs/lamindata\").get(\n",
+    "    key=\"sharded_parquet_collection\"\n",
+    ")"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "hide-output"
+    ]
+   },
    "outputs": [],
    "source": [
     "backed = collection.open()"
@@ -663,7 +620,7 @@
    "outputs": [],
    "source": [
     "# clean up test instance\n",
-    "!lamin delete --force test-arrays"
+    "ln.setup.delete(\"test-arrays\", force=True)"
    ]
   }
  ],

{lamindb-1.10.0 → lamindb-1.10.1}/docs/faq/pydantic-pandera.ipynb

@@ -11,7 +11,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "This doc explains conceptual differences between data validation with `pydantic`, `pandera`, and `lamindb`."
+    "This doc explains conceptual differences between data validation with `pydantic`, `pandera`, and `LaminDB`."
    ]
   },
   {
@@ -42,10 +42,12 @@
    "source": [
     "import pandas as pd\n",
     "import pydantic\n",
-    "from typing import Literal\n",
     "import lamindb as ln\n",
     "import bionty as bt\n",
-    "import pandera\n",
+    "import pandera.pandas as pandera\n",
+    "import pprint\n",
+    "\n",
+    "from typing import Literal, Any\n",
     "\n",
     "df = ln.core.datasets.small_dataset1()\n",
     "df"
@@ -102,7 +104,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Define the Pandera schema using DataFrameSchema\n",
     "pandera_schema = pandera.DataFrameSchema(\n",
     "    {\n",
     "        \"perturbation\": pandera.Column(\n",
@@ -127,14 +128,15 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### lamindb"
+    "### LaminDB"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Features & labels are defined on the level of the database instance. You can either define a schema with required (and optional) columns."
+    "Features & labels are defined on the level of the database instance.\n",
+    "You can either define a schema with required (and optional) columns."
    ]
   },
   {
@@ -147,8 +149,8 @@
    },
    "outputs": [],
    "source": [
-    "ln.ULabel(name=\"DMSO\").save()  # define a DMSO label\n",
-    "ln.ULabel(name=\"IFNG\").save()  # define an IFNG label\n",
+    "ln.ULabel(name=\"DMSO\").save()\n",
+    "ln.ULabel(name=\"IFNG\").save()\n",
     "\n",
     "# leverage ontologies through types ln.ULabel, bt.CellType, bt.ExperimentalFactor\n",
     "lamindb_schema = ln.Schema(\n",
@@ -308,7 +310,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### lamindb"
+    "### LaminDB"
    ]
   },
   {
@@ -317,7 +319,8 @@
    "source": [
     "Because the term `\"CD8-positive, alpha-beta T cell\"` is part of the public `CellType` ontology, validation passes the first time.\n",
     "\n",
-    "If validation and not passed, we could have resolved the issue simply by adding a new term to the `CellType` registry rather than editing the code. This also puts downstream data scientists into a position to update ontologies."
+    "If validation had not passed, we could have resolved the issue simply by adding a new term to the `CellType` registry rather than editing the code.\n",
+    "This also puts downstream data scientists into a position to update ontologies."
    ]
   },
   {
@@ -380,7 +383,7 @@
    "source": [
     "## Overview of validation properties\n",
     "\n",
-    "Importantly, LaminDB offers not only a `DataFrameCurator`, but also a `AnnDataCurator`, `MuDataCurator`, `SpatialDataCurator`, `TiledbsomaCurator`.\n",
+    "Importantly, LaminDB offers not only a `DataFrameCurator`, but also a `AnnDataCurator`, `MuDataCurator`, `SpatialDataCurator`, and `TiledbsomaCurator`.\n",
     "\n",
     "The below overview only concerns validating dataframes."
    ]
@@ -464,7 +467,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "If you don't expect a need for Curator functionality for updating ontologies and standaridization, you can also use the `Artifact` constructor."
+    "If you don't expect a need for Curator functionality for updating ontologies and standardization, you can also use the `Artifact` constructor."
    ]
   },
   {
@@ -561,11 +564,242 @@
    "source": [
     "artifact.schema.features.df()"
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Nested data with dynamic keys"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We will now examine another more complex example where data is nested with potentially arbitrary (dynamic) keys.\n",
+    "The example is inspired by the [CELLxGENE schema](https://github.com/chanzuckerberg/single-cell-curation/blob/main/schema/6.0.0/schema.md#uns-dataset-metadata) where annotations are stored as dictionaries in the AnnData `.uns` slot."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "uns_dict = ln.core.datasets.dict_cxg_uns()\n",
+    "pprint.pprint(uns_dict)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### pydantic"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Pydantic is primed to deal with nested data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Images(pydantic.BaseModel):\n",
+    "    fullres: str\n",
+    "    hires: str\n",
+    "\n",
+    "\n",
+    "class Scalefactors(pydantic.BaseModel):\n",
+    "    spot_diameter_fullres: float\n",
+    "    tissue_hires_scalef: float\n",
+    "\n",
+    "\n",
+    "class Library(pydantic.BaseModel):\n",
+    "    images: Images\n",
+    "    scalefactors: Scalefactors\n",
+    "\n",
+    "\n",
+    "class Spatial(pydantic.BaseModel):\n",
+    "    is_single: bool\n",
+    "    model_config = {\"extra\": \"allow\"}\n",
+    "\n",
+    "    def __init__(self, **data):\n",
+    "        libraries = {}\n",
+    "        other_fields = {}\n",
+    "\n",
+    "        # store all libraries under a single key for validation\n",
+    "        for key, value in data.items():\n",
+    "            if key.startswith(\"library_\"):\n",
+    "                libraries[key] = Library(**value)\n",
+    "            else:\n",
+    "                other_fields[key] = value\n",
+    "\n",
+    "        other_fields[\"libraries\"] = libraries\n",
+    "        super().__init__(**other_fields)\n",
+    "\n",
+    "\n",
+    "class SpatialDataSchema(pydantic.BaseModel):\n",
+    "    organism_ontology_term_id: str\n",
+    "    spatial: Spatial\n",
+    "\n",
+    "\n",
+    "validated_data = SpatialDataSchema(**uns_dict)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "However, pydantic either requires all dictionary keys to be known beforehand to construct the Model classes or workarounds to collect all keys for a single model."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### pandera"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Pandera cannot validate dictionaries because it is designed for structured dataframe data.\n",
+    "Therefore, we need to flatten the dictionary to transform it into a DataFrame:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def _flatten_dict(d: dict[Any, Any], parent_key: str = \"\", sep: str = \"_\"):\n",
+    "    items = []\n",
+    "    for k, v in d.items():\n",
+    "        new_key = f\"{parent_key}{sep}{k}\" if parent_key else k\n",
+    "        if isinstance(v, dict):\n",
+    "            items.extend(_flatten_dict(v, new_key, sep=sep).items())\n",
+    "        else:\n",
+    "            items.append((new_key, v))\n",
+    "    return dict(items)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def create_dynamic_schema(flattened_data: dict[str, Any]):\n",
+    "    schema_dict = {\n",
+    "        \"organism_ontology_term_id\": pandera.Column(str),\n",
+    "        \"spatial_is_single\": pandera.Column(bool),\n",
+    "    }\n",
+    "\n",
+    "    for key in flattened_data.keys():\n",
+    "        if key.startswith(\"spatial_library_\") and key.endswith(\"_images_fullres\"):\n",
+    "            lib_prefix = key.replace(\"_images_fullres\", \"\")\n",
+    "            schema_dict.update(\n",
+    "                {\n",
+    "                    f\"{lib_prefix}_images_fullres\": pandera.Column(str),\n",
+    "                    f\"{lib_prefix}_images_hires\": pandera.Column(str),\n",
+    "                    f\"{lib_prefix}_scalefactors_spot_diameter_fullres\": pandera.Column(\n",
+    "                        float\n",
+    "                    ),\n",
+    "                    f\"{lib_prefix}_scalefactors_tissue_hires_scalef\": pandera.Column(\n",
+    "                        float\n",
+    "                    ),\n",
+    "                }\n",
+    "            )\n",
+    "\n",
+    "    return pandera.DataFrameSchema(schema_dict)\n",
+    "\n",
+    "\n",
+    "flattened = _flatten_dict(uns_dict)\n",
+    "df = pd.DataFrame([flattened])\n",
+    "spatial_schema = create_dynamic_schema(flattened)\n",
+    "validated_df = spatial_schema.validate(df)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Analogously to pydantic, pandera does not have out of the box support for dynamically named keys.\n",
+    "Therefore, it is necessary to dynamically construct a pydantic schema."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### LaminDB"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Similarly, LaminDB currently requires constructing flattened dataframes to dynamically create features for the schema, which can then be used for validation with the DataFrameCurator.\n",
+    "Future improvements are expected, including support for a dictionary-specific curator."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "tags": [
+     "hide-output"
+    ]
+   },
+   "outputs": [],
+   "source": [
+    "def create_dynamic_schema(flattened_data: dict[str, Any]) -> ln.Schema:\n",
+    "    features = []\n",
+    "\n",
+    "    for key, value in flattened_data.items():\n",
+    "        if key == \"organism_ontology_term_id\":\n",
+    "            features.append(ln.Feature(name=key, dtype=bt.Organism.ontology_id).save())\n",
+    "        elif isinstance(value, bool):\n",
+    "            features.append(ln.Feature(name=key, dtype=bool).save())\n",
+    "        elif isinstance(value, (int, float)):\n",
+    "            features.append(ln.Feature(name=key, dtype=float).save())\n",
+    "        else:\n",
+    "            features.append(ln.Feature(name=key, dtype=str).save())\n",
+    "\n",
+    "    return ln.Schema(\n",
+    "        name=\"Spatial data schema\", features=features, coerce_dtype=True\n",
+    "    ).save()\n",
+    "\n",
+    "\n",
+    "flattened = _flatten_dict(uns_dict)\n",
+    "flattened_df = pd.DataFrame([flattened])\n",
+    "spatial_schema = create_dynamic_schema(flattened)\n",
+    "curator = ln.curators.DataFrameCurator(flattened_df, spatial_schema)\n",
+    "curator.validate()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "```{note}\n",
+    "Curators for scverse data structures allow for the specification of schema slots that access and validate dataframes in nested dictionary attributes like `.attrs` or `.uns`.\n",
+    "These schema slots use colon-separated paths like `'attrs:sample'` or `'uns:spatial:images'` to to target specific dataframes for validation.\n",
+    "```"
+   ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "py311",
+   "display_name": "lamindb",
    "language": "python",
    "name": "python3"
   },
@@ -579,7 +813,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.11"
+   "version": "3.12.8"
   }
  },
  "nbformat": 4,

{lamindb-1.10.0 → lamindb-1.10.1}/lamindb/__init__.py

@@ -108,7 +108,7 @@ Backwards compatibility.
 
 # ruff: noqa: I001
 # denote a release candidate for 0.1.0 with 0.1rc1, 0.1a1, 0.1b1, etc.
-__version__ = "1.10.0"
+__version__ = "1.10.1"
 
 import warnings
 

{lamindb-1.10.0 → lamindb-1.10.1}/lamindb/core/storage/_anndata_accessor.py

@@ -340,6 +340,12 @@ if ZARR_INSTALLED:
                 ds = sparse_dataset(elem)
                 return _subset_sparse(ds, indices)
             else:
+                indices = tuple(
+                    idim.tolist()
+                    if isinstance(idim, np.ndarray) and idim.dtype == "bool"
+                    else idim
+                    for idim in indices
+                )
                 return read_elem_partial(elem, indices=indices)
 
     # this is needed because accessing zarr.Group.keys() directly is very slow

{lamindb-1.10.0 → lamindb-1.10.1}/lamindb/examples/datasets/__init__.py

@@ -36,11 +36,12 @@ Directories.
    dir_scrnaseq_cellranger
    dir_iris_images
 
-Dataframe, AnnData, MuData.
+Dictionary, Dataframe, AnnData, MuData, SpatialData.
 
 .. autosummary::
    :toctree: .
 
+   dict_cxg_uns
    df_iris
    df_iris_in_meter
    df_iris_in_meter_study1
@@ -55,6 +56,7 @@ Dataframe, AnnData, MuData.
    mudata_papalexi21_subset
    schmidt22_crispra_gws_IFNG
    schmidt22_perturbseq
+   spatialdata_blobs
 
 Other.
 
@@ -76,6 +78,7 @@ from ._core import (
     df_iris_in_meter,
     df_iris_in_meter_study1,
     df_iris_in_meter_study2,
+    dict_cxg_uns,
     dir_iris_images,
     dir_scrnaseq_cellranger,
     file_bam,

{lamindb-1.10.0 → lamindb-1.10.1}/lamindb/examples/datasets/_core.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 from urllib.request import urlretrieve
 
 import anndata as ad
@@ -418,6 +418,38 @@ def mudata_papalexi21_subset() -> MuData:  # pragma: no cover
     return mdata
 
 
+def dict_cxg_uns() -> dict[str, Any]:
+    """An example CELLxGENE AnnData `.uns` dictionary."""
+    uns = {
+        "organism_ontology_term_id": "NCBITaxon:9606",
+        "spatial": {
+            "is_single": True,
+            "library_1": {  # Dynamic library_id key
+                "images": {
+                    "fullres": "path/to/fullres.jpg",
+                    "hires": "path/to/hires.jpg",
+                },
+                "scalefactors": {
+                    "spot_diameter_fullres": 89.43,
+                    "tissue_hires_scalef": 0.177,
+                },
+            },
+            "library_2": {  # Another dynamic library_id key
+                "images": {
+                    "fullres": "path/to/fullres_2.jpg",
+                    "hires": "path/to/hires_2.jpg",
+                },
+                "scalefactors": {
+                    "spot_diameter_fullres": 120.34,
+                    "tissue_hires_scalef": 0.355,
+                },
+            },
+        },
+    }
+
+    return uns
+
+
 def df_iris() -> pd.DataFrame:
     """The iris collection as in sklearn.
 

{lamindb-1.10.0 → lamindb-1.10.1}/lamindb/examples/schemas/_anndata.py

@@ -10,7 +10,7 @@ if TYPE_CHECKING:
 
 
 def anndata_ensembl_gene_ids_and_valid_features_in_obs() -> Schema:
-    """Return a schema for an AnnData with Ensembl gene IDs and valid features in obs.
+    """An `AnnData` schema validating Ensembl gene IDs and valid features in obs.
 
     .. literalinclude:: scripts/define_schema_anndata_ensembl_gene_ids_and_valid_features_in_obs.py
         :language: python

{lamindb-1.10.0 → lamindb-1.10.1}/lamindb/examples/schemas/_simple.py

@@ -10,7 +10,7 @@ if TYPE_CHECKING:
 
 
 def valid_features() -> Schema:
-    """Return a schema for an AnnData with Ensembl gene IDs and valid features in obs.
+    """A `DataFrame` schema that validates that columns map on existing features.
 
     .. literalinclude:: scripts/define_valid_features.py
         :language: python

{lamindb-1.10.0 → lamindb-1.10.1}/noxfile.py

@@ -100,9 +100,9 @@ def install_ci(session, group):
         run(session, "uv pip install --system tiledbsoma")
         run(session, "uv pip install --system polars")
     elif group == "tutorial":
-        extras += "jupyter,bionty,zarr"
-        run(session, "uv pip install --system huggingface_hub")
-        run(session, "uv pip install --system polars")
+        extras += "jupyter,bionty"
+        # anndata here to prevent installing older version on release
+        run(session, "uv pip install --system huggingface_hub polars anndata==0.12.1")
     elif group == "guide":
         extras += "bionty,zarr,jupyter"
         run(session, "uv pip install --system scanpy mudata spatialdata tiledbsoma")
@@ -250,7 +250,7 @@ def test(session, group):
             f"pytest {coverage_args} ./tests/core {duration_args}",
         )
     elif group == "unit-storage":
-        run(session, f"pytest {coverage_args} ./tests/storage {duration_args}")
+        run(session, f"pytest -s {coverage_args} ./tests/storage {duration_args}")
     elif group == "tutorial":
         run(session, "lamin logout")
         run(

{lamindb-1.10.0 → lamindb-1.10.1}/pyproject.toml

@@ -18,7 +18,7 @@ dependencies = [
     # Lamin PINNED packages
     "lamin_utils==0.15.0",
     "lamin_cli==1.6.1",
-    "lamindb_setup[aws]==1.9.0",
+    "lamindb_setup[aws]==1.9.1",
     # others
     "pyyaml",
     "pyarrow",
@@ -29,7 +29,7 @@ dependencies = [
     # backed sparse is incompatible with 1.15.0 for anndata 1.11.1
     # vitessce requires anndata<=1.11.0 now
     "scipy<1.15.0",
-    "anndata>=0.8.0,<=0.12.0",  # will upgrade to new anndata releases
+    "anndata>=0.8.0,<=0.12.1",  # will upgrade to new anndata releases
     "fsspec",
     "graphviz",
     "psycopg2-binary",

{lamindb-1.10.0 → lamindb-1.10.1}/tests/permissions/scripts/setup_access.py

@@ -19,7 +19,7 @@ def create_jwt_user(dsn_admin: str, jwt_role_name: str):
 
 pgurl = "postgresql://postgres:pwd@0.0.0.0:5432/pgtest"  # admin db connection url
 jwt_db_url = create_jwt_user(pgurl, jwt_role_name=f"{instance_id.hex}_jwt")
-_install_db_module(None, pgurl, instance_id=instance_id)
+_install_db_module(None, pgurl, instance_id=instance_id, public=False)
 
 print("Created jwt db connection")