LaminDB

https://docs.lamin.ai/
Admin
LaminDB is an open-source data framework for biology that provides a unified API for managing,...
Tokens:423,196
Snippets:2,464
Trust Score:7.6
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install and Initialize LaminDB

Source: https://docs.lamin.ai/faq/import-modules

Demonstrates the initial setup steps, including installing the necessary LaminDB package with bionty support and initializing the LaminDB CLI. This sets up the environment for subsequent operations.

```shell
#!pip install 'lamindb[bionty]'
!lamin
```

--------------------------------

### Initialize and Connect to LaminDB

Source: https://docs.lamin.ai/faq/visibility

Demonstrates the initial setup and connection to a LaminDB instance using both shell commands and Python imports. It covers installing the library, initializing the LaminDB CLI, and importing the `lamindb` library with pandas.

```shell
# !pip install lamindb
!lamin
```

```shell
→ initialized lamindb: testuser1/test-branch_id
```

```python
import lamindb as ln
import pandas as pd
```

```shell
→ connected lamindb: testuser1/test-branch_id
```

--------------------------------

### LaminDB and MLFlow Integration Setup

Source: https://docs.lamin.ai/summary

Demonstrates the initial setup for integrating LaminDB with MLFlow. This includes installing necessary packages, initializing a LaminDB storage, and tracking with LaminDB.

```Python
# !pip install 'lamindb[jupyter]' torchvision lightning wandb

import lamindb as ln
import mlflow
import lightning

# Initialize LaminDB storage in the current directory
# !lamin init --storage ./lamin-mlops

# Start tracking with LaminDB
ln.track()
```

--------------------------------

### Initial Setup and Imports for Spatial ML

Source: https://docs.lamin.ai/spatial3

Imports necessary libraries like `lamindb`, `spatialdata`, and `pytorch_lightning`, sets up multiprocessing, and initializes `lamindb` tracking for the spatial guide datasets.

```Python
importwarnings

warnings.filterwarnings("ignore")

importlamindbasln
importnumpyasnp

importspatialdataassd
fromspatialdataimport transform
fromspatialdata.dataloader.datasetsimport ImageTilesDataset

importpytorch_lightningaspl
frompytorch_lightning.callbacksimport LearningRateMonitor
frompytorch_lightning.callbacks.progressimport TQDMProgressBar

importtorch.multiprocessingasmp

mp.set_start_method("spawn", force=True)

ln.track(project="spatial guide datasets")
```

--------------------------------

### Install Redun and LaminDB

Source: https://docs.lamin.ai/redun

Installs the necessary libraries for Redun and LaminDB integration, and initializes a LaminDB instance.

```shell
# pip install lamindb redun git+http://github.com/laminlabs/redun-lamin-fasta
!lamin
```

--------------------------------

### Install LaminDB and Initialize W&B Integration

Source: https://docs.lamin.ai/wandb

Installs necessary libraries for LaminDB and W&B integration, and initializes the W&B tracking command. This setup is crucial for connecting your local environment to both LaminDB and Weights & Biases services.

```bash
# !pip install 'lamindb[jupyter]' torchvision lightning wandb
!lamin!wandb
```

--------------------------------

### Install and Initialize LaminDB

Source: https://docs.lamin.ai/faq/reference-field

Installs the lamindb library and initializes a LaminDB instance. This is a prerequisite for using LaminDB functionalities.

```shell
#!pip install lamindb
!lamin
```

```shell
→ initialized lamindb: testuser1/testreference
```

--------------------------------

### Install and Initialize LaminDB CLI

Source: https://docs.lamin.ai/faq/delete

Installs the LaminDB Python package using pip and initializes the LaminDB command-line interface. This is a common setup step before interacting with LaminDB.

```shell
#!pip install lamindb
!lamin
```

--------------------------------

### Install and Initialize Lamindb

Source: https://docs.lamin.ai/faq/validate-fields

Shows the necessary steps to install the lamindb library and initialize a lamindb instance using the command-line interface.

```shell
# pip install lamindb
!lamin
```

--------------------------------

### Setup Local LaminDB Test Instance

Source: https://docs.lamin.ai/faq/acid

Installs the necessary 'lamindb' package with Jupyter and AWS support, then sets up a local PostgreSQL test instance for demonstration purposes. This prepares the environment for testing data synchronization.

```python
# !pip install 'lamindb[jupyter,aws]'
from laminci.db import setup_local_test_postgres

pgurl = setup_local_test_postgres()

```

--------------------------------

### Install and Initialize wetlab

Source: https://docs.lamin.ai/summary

Installs the wetlab package using pip and initializes a new lamin instance, enabling the bionty and wetlab modules for project setup.

```bash
pip install wetlab
lamin init --storage ./test-wetlab --modules bionty,wetlab
```

--------------------------------

### Install and Initialize LaminDB

Source: https://docs.lamin.ai/project-flow

Installs the LaminDB library with common dependencies and initializes the LaminDB command-line interface. This sets up the environment for tracking data and experiments.

```shell
#!pip install 'lamindb[jupyter,bionty,aws]'
!lamin
```

--------------------------------

### Install and Initialize Lamindb

Source: https://docs.lamin.ai/faq/track-run-inputs

Installs the necessary Lamindb package with Jupyter support and initializes the Lamindb CLI.

```shell
# !pip install 'lamindb[jupyter]'
!lamin
```

--------------------------------

### Initialize LaminDB with Bionty Module (Shell & Python)

Source: https://docs.lamin.ai/summary

This example covers installing the necessary package, initializing a LaminDB instance with the 'bionty' module, importing the module, and verifying data access. It also includes cleanup.

```shell
# Install lamindb with bionty support
!pip install 'lamindb[bionty]'

# Initialize a new lamin instance with bionty module
!lamin init --storage testmodule --modules bionty
```

```python
# Import bionty
import bionty as bt

# Access data from bionty, e.g., Organism
# This implicitly loads the bionty instance
assert bt.Organism(name="human") is not None
print("Bionty Organism accessed successfully.")
```

```shell
# Clean up the test instance
!lamin delete --force testmodule
```

--------------------------------

### Install and Connect to LaminDB

Source: https://docs.lamin.ai/cellxgene

Installs LaminDB with necessary extensions and connects to a default LaminDB instance, often used in notebook environments. This command initiates the connection process.

```bash
# pip install 'lamindb[bionty,jupyter]'
!lamin
```

--------------------------------

### R: LaminR Client Setup and Connection

Source: https://docs.lamin.ai/summary

Instructions for setting up and connecting to LaminDB using the R client ('laminr'). This includes installing the package, connecting to a cloud or local instance, and initializing a new local instance with specified modules.

```r
# Install the laminr package from CRAN
# install.packages("laminr", dependencies = TRUE)

# Connect to a LaminDB instance (skip for local/self-hosted)
# laminr::lamin_login() 
# laminr::lamin_connect("<account>/<instance>")

# Initialize a local instance
# laminr::lamin_init(storage = "./mydata", modules = c("bionty"))
```

--------------------------------

### Install and Initialize LaminDB with Bionty

Source: https://docs.lamin.ai/bio-registries

Installs the `lamindb` package with the `bionty` plugin and initializes `lamindb` via the command line. The output indicates a successful initialization.

```shell
# pip install 'lamindb[bionty]'
!lamin
```

--------------------------------

### Execute Lamin CLI Command

Source: https://docs.lamin.ai/arrays

Executes a command using the 'lamin' command-line interface. This example shows logging in or performing an initial setup action.

```shell
!lamin!lamin
```

--------------------------------

### Install and Initialize LaminDB

Source: https://docs.lamin.ai/query-search

Installs the lamindb library with bionty extras using pip and initializes the LaminDB command-line interface.

```shell
# pip install 'lamindb[bionty]'
!lamin
```

--------------------------------

### Manage Spatial Datasets with LaminDB

Source: https://docs.lamin.ai/summary

Guides on setting up and managing spatial datasets using LaminDB, Bionty, and SpatialData. Includes installation, initialization, and project tracking.

```bash
# Install necessary libraries
pip install 'lamindb[jupyter,bionty]' spatialdata spatialdata-plot
```

```bash
# Initialize LaminDB storage and modules
!lamin init --storage ./test-spatial --modules bionty
```

```Python
import lamindb as ln
import bionty as bt
import spatialdata as sd
import warnings

# Ignore warnings for cleaner output
warnings.filterwarnings("ignore")

# Create and save a project for spatial guide datasets
spatial_guide_datasets = ln.Project(name="spatial guide datasets").save()

# Track operations within the created project
ln.track(project=spatial_guide_datasets)
```

--------------------------------

### Install Vitessce and LaminDB

Source: https://docs.lamin.ai/vitessce

Installs the necessary Python packages for Vitessce, generate-tiff-offsets, and LaminDB, including Jupyter and Bionty support. It also shows how to connect to a LaminDB instance using the `!lamin` command.

```shell
# pip install "vitessce[all]>=3.5.0"
# pip install "generate-tiff-offsets>=0.1.9"
# pip install "lamindb[jupyter,bionty]"
!lamin
```

--------------------------------

### Install and Initialize LaminDB

Source: https://docs.lamin.ai/registries

Installs the lamindb library with bionty extras using pip and initializes the LaminDB command-line interface.

```shell
# pip install 'lamindb[bionty]'
!lamin
```

--------------------------------

### Install and Initialize LaminDB

Source: https://docs.lamin.ai/faq/curate-any

Installs the necessary LaminDB and Bionty packages. The `!lamin` command initializes a LaminDB instance, setting up the environment for data curation and annotation.

```shell
# pip install 'lamindb[bionty,zarr]'
!lamin
```

--------------------------------

### Install and Initialize LaminDB

Source: https://docs.lamin.ai/multimodal

Installs the necessary LaminDB package with Jupyter and Bionty dependencies. It then initializes the LaminDB CLI, setting up the environment for data management.

```shell
# !pip install 'lamindb[jupyter,bionty]'
!pip install 'lamindb[jupyter,bionty]'
!lamin
```

--------------------------------

### Install and Initialize Lamindb

Source: https://docs.lamin.ai/faq/symbol-mapping

Installs the Lamindb library with Bionty support and initializes a Lamindb instance. This is a prerequisite for using Lamindb's data management features.

```shell
#!pip install 'lamindb[bionty]'
!lamin
```

--------------------------------

### Setup LaminDB Tracking and Imports

Source: https://docs.lamin.ai/cellxgene-curate

Imports necessary libraries, lamindb and bionty, and starts tracking the current run. This is crucial for logging operations and managing data lineage.

```python
import lamindb as ln
import bionty as bt

ln.track()
```

--------------------------------

### Install and Initialize lamindb with bionty

Source: https://docs.lamin.ai/summary

Installs the lamindb library with the bionty extension and initializes a lamindb instance, enabling access to biological ontologies.

```bash
# Install lamindb with bionty module
pip install 'lamindb[bionty]'

# Initialize lamindb instance with bionty module
lamin init --storage <storage_name> --modules bionty
```

--------------------------------

### Save Exemplary Datasets

Source: https://docs.lamin.ai/query-search

Demonstrates saving various artifact types (image, fastq, DataFrame) and using example datasets to populate a LaminDB instance. It also shows tracking a transform and starting a run.

```python
import lamindb as ln

ln.track("Wc8F4siRSKMZ")

ln.Artifact(ln.core.datasets.file_jpg_paradisi05(), key="images/my_image.jpg").save()
ln.Artifact(ln.core.datasets.file_fastq(), key="raw/my_fastq.fastq.gz").save()
ln.Artifact.from_df(ln.core.datasets.df_iris(), key="iris.parquet").save()
ln.examples.datasets.mini_immuno.save_mini_immuno_datasets()
```

--------------------------------

### Install and Initialize LaminDB

Source: https://docs.lamin.ai/scrna

Installs LaminDB with Jupyter and Bionty support and initializes the LaminDB CLI. This is a prerequisite for using LaminDB functionalities.

```bash
# pip install 'lamindb[jupyter,bionty]'
!lamin
```

--------------------------------

### Install & Initialize LaminDB CLI

Source: https://docs.lamin.ai/analysis-flow

Installs lamindb with Jupyter and Bionty extensions. Initializes the lamindb CLI, connecting to a default instance.

```shell
pip install 'lamindb[jupyter,bionty]'
!lamin
```

```python
import lamindb as ln
import bionty as bt
```

--------------------------------

### LaminDB Initialization for Bulk RNA-seq

Source: https://docs.lamin.ai/summary

Demonstrates the initial setup for handling bulk RNA-seq data. It shows how to install the necessary lamindb package with jupyter and bionty modules, and initialize a lamindb instance with a specified storage location and modules.

```bash
#!pip install 'lamindb[jupyter,bionty]'
!lamin init --storage test-bulkrna --modules bionty
```

```python
import lamindb as ln
import bionty as bt
import pandas as pd
import anndata as ad
from pathlib import Path
```

--------------------------------

### Install and Initialize LaminDB

Source: https://docs.lamin.ai/sc-imaging

Installs the necessary `lamindb` packages with optional dependencies for Jupyter notebooks and Bionty. Then, it initializes the `lamindb` CLI, setting up the environment for data management.

```shell
# pip install 'lamindb[jupyter,bionty]'
!lamin
```

--------------------------------

### Vitessce Interactive Visualization Setup

Source: https://docs.lamin.ai/summary

Demonstrates setting up Vitessce for interactive visualizations of data stored in LaminDB Artifacts. It includes installing necessary libraries, connecting to a LaminDB instance, and importing required modules for data handling and visualization.

```python
# Install necessary libraries (if not already installed)
# pip install "vitessce[all]>=3.5.0"
# pip install "generate-tiff-offsets>=0.1.9"
# pip install "lamindb[jupyter,bionty]"

import lamindb as ln

# Connect to your LaminDB instance (replace with your instance name)
# ln.connect("your_lamin_instance_name")
# Or use the CLI command: !lamin connect laminlabs/lamin-dev

# For demonstration purposes, assuming connection is handled externally or via CLI
# Example: !lamin connect laminlabs/lamin-dev

# Optional: track the current notebook or script
# ln.track("BZhZQ6uIbkWv")

# Import Vitessce and related modules
from urllib.request import urlretrieve
from pathlib import Path
from anndata import read_h5ad
import vitessce as vit
from vitessce import data_utils as vitdu
from generate_tiff_offsets import get_offsets
import zipfile
import json

print("Vitessce and LaminDB modules imported successfully.")
# Further steps would involve loading data from LaminDB and configuring Vitessce views.
```

--------------------------------

### Save Exemplary Datasets

Source: https://docs.lamin.ai/registries

Demonstrates saving various artifact types (image, fastq, DataFrame) and using example datasets to populate a LaminDB instance. It also shows tracking a transform and starting a run.

```python
import lamindb as ln

ln.track("Wc8F4siRSKMZ")

ln.Artifact(ln.core.datasets.file_jpg_paradisi05(), key="images/my_image.jpg").save()
ln.Artifact(ln.core.datasets.file_fastq(), key="raw/my_fastq.fastq.gz").save()
ln.Artifact.from_df(ln.core.datasets.df_iris(), key="iris.parquet").save()
ln.examples.datasets.mini_immuno.save_mini_immuno_datasets()
```

--------------------------------

### Install LaminDB and Run Initial Command

Source: https://docs.lamin.ai/celltypist

Installs the LaminDB library with Jupyter and Bionty dependencies, and executes the initial 'lamin' command for setting up the environment.

```python
# pip install 'lamindb[jupyter,bionty]'
!lamin
```

--------------------------------

### Install and Initialize LaminDB

Source: https://docs.lamin.ai/ehr

Installs the lamindb library with bionty support using pip and initializes the lamindb command-line interface.

```shell
# pip install 'lamindb[bionty]'
!lamin
```

--------------------------------

### Install and Initialize LaminDB

Source: https://docs.lamin.ai/bulkrna

Installs the LaminDB library with necessary dependencies for Jupyter notebooks and Bionty, and initializes the LaminDB command-line interface.

```shell
# !pip install 'lamindb[jupyter,bionty]'
!lamin
```

--------------------------------

### Configure LaminDB Instance Setup

Source: https://docs.lamin.ai/summary

Details various configuration options available during LaminDB instance setup, including cloud storage, database connections, custom instance names, and mounting additional schema modules.

```Shell
--storage s3://my-bucket
```

```Shell
--db postgresql://<user>:<pwd>@<hostname>:<port>/<dbname>
```

```Shell
--name my-name
```

```Shell
--modules bionty,wetlab,custom1
```

--------------------------------

### Install Dependencies and Run Lamin CLI

Source: https://docs.lamin.ai/rdf-sparql

Installs the necessary Python libraries, including lamindb with bionty support and rdflib, and then executes the lamin command-line interface.

```bash
pip install 'lamindb[bionty]' rdflib
!lamin
```

--------------------------------

### Install and Initialize Lamindb

Source: https://docs.lamin.ai/track

Install the lamindb package with Jupyter support using pip and initialize the lamindb CLI. The `!lamin` command sets up the environment for tracking.

```bash
# pip install 'lamindb[jupyter]'
!lamin
```

--------------------------------

### Install and Initialize LaminDB

Source: https://docs.lamin.ai/facs

Installs the necessary LaminDB packages with Jupyter and Bionty support. It then initializes the LaminDB CLI environment, typically setting up a local instance or connecting to a remote one.

```shell
# !pip install 'lamindb[jupyter,bionty]'
!lamin
```

--------------------------------

### Install LaminDB and Connect to Instance

Source: https://docs.lamin.ai/arc-virtual-cell-atlas

Installs LaminDB with essential extensions for data analysis and connects to the default LaminDB instance. The output confirms the connection to the 'laminlabs/arc-virtual-cell-atlas' instance.

```bash
# pip install 'lamindb[jupyter,bionty,wetlab,gcp]'
!lamin
```

--------------------------------

### Install and Initialize LaminDB

Source: https://docs.lamin.ai/curate

Installs the lamindb library with bionty dependencies using pip and initializes the LaminDB command-line interface. This is a prerequisite for using LaminDB for data curation.

```shell
# pip install 'lamindb[bionty]'
!lamin
```

--------------------------------

### Install lamindb with extras

Source: https://docs.lamin.ai/setup

Installs the lamindb package with specified optional dependencies. Use extras like 'jupyter' for notebook integration or 'bionty' for biological ontologies.

```shell
pip install 'lamindb[jupyter,bionty]'
```

--------------------------------

### Initialize lamindb instance

Source: https://docs.lamin.ai/faq/setup

Demonstrates the correct way to initialize a lamindb instance using `ln.setup.init()`, specifying the storage path. The output confirms successful initialization.

```python
ln.setup.init(storage="./testsetup")

```

```python
→ initialized lamindb: testuser1/testsetup

```

--------------------------------

### Install LaminDB and Dependencies

Source: https://docs.lamin.ai/rxrx

Installs the required LaminDB packages, including bionty and wetlab, along with Jupyter support and GCP integration. It also initializes the LaminDB command-line interface.

```shell
# !pip install 'lamindb[bionty,jupyter,gcp]' wetlab
!lamin
```

--------------------------------

### Install Dependencies for LaminDB & MLflow

Source: https://docs.lamin.ai/mlflow

Installs necessary libraries for using LaminDB with MLflow, including PyTorch, Lightning, and MLflow itself. Also runs the lamin CLI for initial setup or connection.

```bash
# !pip install 'lamindb[jupyter]' torchvision lightning wandb
!lamin
```

--------------------------------

### Install and Initialize LaminDB

Source: https://docs.lamin.ai/enrichr

Installs the `lamindb` package with Jupyter and Bionty extensions using pip and initializes the LaminDB command-line interface. This sets up the environment for using LaminDB functionalities.

```shell
# !pip install 'lamindb[jupyter,bionty]'
!lamin
```

--------------------------------

### scPortrait Project Setup and Processing

Source: https://docs.lamin.ai/sc-imaging2

Initializes a scPortrait project, creates necessary directories, loads input image paths, and runs the segmentation and extraction pipelines. It handles project configuration and overwrites existing data.

```python
# Get image paths in correct channel order
input_image_paths = [
    images.filter(ulabels__name=channel).one().cache()
    for channel in ["DAPI", "Alexa488", "mCherry"]
]

# Create output directory and unique project ID
output_directory = "processed_data"
unique_project_id = f"{shared_features['cell_line_clone']}/{shared_features['stimulation']}/{shared_features['FOV']}".replace(
    " ", "_"
)
project_location = f"{output_directory}/{unique_project_id}/scportrait_project"

# Create directories
Path(project_location).mkdir(parents=True, exist_ok=True)

# Initialize the scPortrait project
project = Project(
    project_location=project_location,
    config_path=config_file_af.cache(),
    segmentation_f=CytosolSegmentationCellpose,
    extraction_f=HDF5CellExtraction,
    overwrite=True,
)

# Load images and process
project.load_input_from_tif_files(
    input_image_paths, overwrite=True, channel_names=["DAPI", "Alexa488", "mCherry"]
)
project.segment()
project.extract()
```

--------------------------------

### Lamin CLI Commands

Source: https://docs.lamin.ai/summary

Provides examples of LaminDB command-line interface (CLI) commands for managing instances, including disconnecting, deleting, and installing packages.

```APIDOC
!lamin disconnect

!pip install 'lamindb[jupyter]'

!lamin delete --force testsetup
```

--------------------------------

### Introduction Notebook Reference

Source: https://docs.lamin.ai/introduction

References an introductory notebook for the project, providing an entry point for understanding the project's scope and initial setup.

```markdown
id |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |   
1 | OEnHo1pP4NLG0000 | introduction.ipynb | Introduction | notebook | None | None | None | None | 1 | None | None | True | 2025-07-31 08:48:27.898000+00:00 | 1 | None | 1  
```
ULabel

```
```

--------------------------------

### Introduction Notebook Reference

Source: https://docs.lamin.ai/guide

References an introductory notebook for the project, providing an entry point for understanding the project's scope and initial setup.

```markdown
id |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |   
1 | OEnHo1pP4NLG0000 | introduction.ipynb | Introduction | notebook | None | None | None | None | 1 | None | None | True | 2025-07-31 08:48:27.898000+00:00 | 1 | None | 1  
```
ULabel

```
```

--------------------------------

### Get Public Gene Data

Source: https://docs.lamin.ai/bionty

Retrieves public gene data for a specified organism. This is a common starting point for accessing biological information within the Lamin AI ecosystem.

```python
gene_pub = bt.Gene.public(organism="mouse")
gene_pub
```

--------------------------------

### Initialize LaminDB Instance

Source: https://docs.lamin.ai/summary

Installs the lamindb library with bionty support and initializes a new LaminDB instance with specified storage and modules.

```bash
# pip install 'lamindb[bionty]'
!lamin init --storage ./test-registries --modules bionty
```

--------------------------------

### Introduction Notebook Reference

Source: https://docs.lamin.ai/index

References an introductory notebook for the project, providing an entry point for understanding the project's scope and initial setup.

```markdown
id |  |  |  |  |  |  |  |  |  |  |  |  |  |  |  |   
1 | OEnHo1pP4NLG0000 | introduction.ipynb | Introduction | notebook | None | None | None | None | 1 | None | None | True | 2025-07-31 08:48:27.898000+00:00 | 1 | None | 1  
```
ULabel

```
```

--------------------------------

### Get Specific Ontology Source

Source: https://docs.lamin.ai/summary

Retrieve a specific ontology source by its entity type and name, for example, the 'ncbitaxon' source for the 'bionty.Organism' entity. This source can then be used for data validation or import.

```python
source = bt.Source.get(entity="bionty.Organism", name="ncbitaxon")
source
```

--------------------------------

### Display All Currently Used Ontologies

Source: https://docs.lamin.ai/protein

Provides an example of how to filter all bionty.Source objects where currently_used is True and display the results as a DataFrame. This is useful for getting an overview of all active ontologies within the Bionty library.

```Python
bt.Source.filter(currently_used=True).df()
```

--------------------------------

### Lookup and Access Cell Types

Source: https://docs.lamin.ai/bio-registries

Retrieves all available cell types from the registry and allows access to specific records via attribute access. This example shows how to get the hematopoietic stem cell record.

```Python
cell_types = bt.CellType.lookup()
hsc_record = cell_types.hematopoietic_stem_cell
hsc_record
```

--------------------------------

### Setup Local Test Postgres and Initialize LaminDB

Source: https://docs.lamin.ai/faq/search

This snippet demonstrates setting up a local PostgreSQL test instance using `setup_local_test_postgres` and then initializing a LaminDB instance. It uses a combination of Python and shell commands.

```python
from laminci.dbimport import setup_local_test_postgres

pgurl = setup_local_test_postgres()
!lamin{pgurl}
```

--------------------------------

### LaminDB CLI Initialization and Login

Source: https://docs.lamin.ai/summary

Shows essential command-line interface commands for LaminDB. Includes logging into a LaminDB instance and initializing a new project with a specified storage backend (e.g., S3).

```shell
# Log in to a LaminDB instance
lamin login testuser1

# Initialize a new LaminDB project with S3 storage
lamin init --storage s3://lamindb-ci/test-arrays
```

--------------------------------

### Get Dataset2 Function

Source: https://docs.lamin.ai/lamindb.examples.datasets.mini_immuno

Retrieves dataset2 from the mini_immuno example dataset. This function is part of the lamindb library for data analysis and management. It returns either a pandas DataFrame or an AnnData object, depending on the internal processing.

```APIDOC
lamindb.examples.datasets.mini_immuno.get_dataset2(_otype_ , _gene_symbols_in_index =False_)

  Retrieves dataset2 from the mini_immuno example dataset.

  Parameters:
    _otype_: Type of the dataset to retrieve.
    _gene_symbols_in_index: Boolean flag to indicate if gene symbols should be in the index (defaults to False).

  Returns:
    DataFrame | AnnData: The dataset, returned as either a pandas DataFrame or an AnnData object.
```

--------------------------------

### Import Libraries and Setup

Source: https://docs.lamin.ai/summary

Imports necessary libraries for spatial data analysis and sets up tracking for the project. It also configures warnings to be ignored.

```python
import lamindb as ln
import bionty as bt
import squidpy as sq
import scanpy as sc
import spatialdata_plot
import warnings

warnings.filterwarnings("ignore")

ln.track(project="spatial guide datasets")
```

--------------------------------

### Setup LaminDB Environment and Track Run

Source: https://docs.lamin.ai/facs

Imports core LaminDB libraries and Bionty for biological data handling. It sets the global organism to 'human' and initiates tracking for a specific transform ID, starting a new run within the LaminDB instance.

```python
import lamindb as ln
import bionty as bt
import readfcs

bt.settings.organism = "human"  # globally set organism to human

ln.track("OWuTtS4SApon0000")
```

--------------------------------

### Install LaminR from CRAN

Source: https://docs.lamin.ai/setup-laminr

Installs the stable version of the laminr package from the Comprehensive R Archive Network (CRAN). This is the recommended method for most users seeking a reliable installation.

```R
install.packages("laminr")
```

--------------------------------

### LaminDB Examples

Source: https://docs.lamin.ai/lamindb.base.fields

Example datasets and schema definitions for lamindb.

```APIDOC
lamindb.examples:
  schemas:
    valid_features(): Example of valid features.
    anndata_ensembl_gene_ids_and_valid_features_in_obs(): Example AnnData with gene IDs and features.
  datasets:
    mini_immuno(): Example dataset: mini_immuno.
    anndata_with_obs(): Example dataset: AnnData with observation metadata.
    file_fcs(): Example dataset: FCS file.
    file_fcs_alpert19(): Example dataset: FCS file (Alpert19).
```

--------------------------------

### Install Lamindb with Bionty

Source: https://docs.lamin.ai/gene

Installs the lamindb library with the bionty extension, which is necessary for accessing public ontologies.

```shell
# pip install 'lamindb[bionty]'
!lamin
```

--------------------------------

### Initialize LaminDB Project and Track Runs

Source: https://docs.lamin.ai/summary

Shows how to install LaminDB with specific modules and initialize a new project. It also includes tracking a run with a given ID.

```bash
# pip install 'lamindb[bionty]'
!lamin init --storage ./test-curate --modules bionty
```

```python
import lamindb as ln

ln.track("MCeA3reqZG2e")
```

--------------------------------

### LaminDB API: Initialization and Viewing

Source: https://docs.lamin.ai/summary

Covers essential LaminDB API calls for initializing a new instance and viewing the current database content. These are foundational commands for setting up and inspecting LaminDB projects.

```APIDOC
LaminDB Initialization and Viewing API:

lamin init --storage <path> [--name <name>]
  - Initializes a new LaminDB instance.
  - Parameters:
    - --storage: Path to the storage directory for LaminDB.
    - --name: Optional name for the LaminDB instance.

lamin delete --force <name>
  - Deletes a LaminDB instance.
  - Parameters:
    - --force: Forces deletion without confirmation.

ln.view()
  - Displays the current content of the LaminDB database.
  - Returns nothing, prints to console.
```

--------------------------------

### Install laminr with all dependencies

Source: https://docs.lamin.ai/summary

Installs the laminr R package along with all suggested additional packages. This ensures all optional functionalities are available.

```R
install.packages("laminr", dependencies = TRUE)
```

--------------------------------

### Install lamindb with bionty

Source: https://docs.lamin.ai/public-ontologies

Installs the lamindb library along with the bionty extension, which is used for managing biological entities and their associated ontologies.

```bash
!pip install 'lamindb[bionty]'
```

--------------------------------

### Initialize LaminDB and Bionty Module

Source: https://docs.lamin.ai/summary

Provides commands to initialize a LaminDB instance with the bionty module and install necessary packages.

```bash
# Install lamindb with bionty support
pip install 'lamindb[bionty]'

# Initialize a new LaminDB instance in a local directory
lamin init --storage ./test-registries --modules bionty
```

--------------------------------

### LaminDB Initialization Configuration Options

Source: https://docs.lamin.ai/introduction

Demonstrates various command-line options for configuring LaminDB initialization, including specifying cloud storage, database connection strings, custom instance names, and mounting additional schema modules.

```Shell
--storage s3://my-bucket
```

```Shell
--db postgresql://<user>:<pwd>@<hostname>:<port>/<dbname>
```

```Shell
--name my-name
```

```Shell
--modules bionty,wetlab,custom1
```

--------------------------------

### Initialize and Track Spatial Project

Source: https://docs.lamin.ai/spatial

Imports necessary libraries (lamindb, bionty, spatialdata), configures warnings, creates a LaminDB project for spatial data, and starts tracking the current run.

```python
importlamindbasln
importbiontyasbt
importspatialdataassd
importwarnings

warnings.filterwarnings("ignore")

spatial_guide_datasets = ln.Project(name="spatial guide datasets").save()
ln.track(project=spatial_guide_datasets)
```

--------------------------------

### lamindb Examples API

Source: https://docs.lamin.ai/clinicore

Provides access to example datasets and schema definitions for demonstrating lamindb functionalities.

```APIDOC
lamindb.examples.schemas.valid_features
  - Example of valid features schema.

lamindb.examples.schemas.anndata_ensembl_gene_ids_and_valid_features_in_obs
  - Example schema for AnnData with Ensembl gene IDs and features in obs.

lamindb.examples.datasets.mini_immuno
  - Example dataset: mini_immuno.

lamindb.examples.datasets.anndata_with_obs
  - Example dataset: AnnData with observations.

lamindb.examples.datasets.file_fcs
  - Example dataset: FCS file.

lamindb.examples.datasets.file_fcs_alpert19
  - Example dataset: FCS file (Alpert19).
```

--------------------------------

### LaminDB Initialization Configuration Options

Source: https://docs.lamin.ai/index

Demonstrates various command-line options for configuring LaminDB initialization, including specifying cloud storage, database connection strings, custom instance names, and mounting additional schema modules.

```Shell
--storage s3://my-bucket
```

```Shell
--db postgresql://<user>:<pwd>@<hostname>:<port>/<dbname>
```

```Shell
--name my-name
```

```Shell
--modules bionty,wetlab,custom1
```

--------------------------------

### Install LaminR with Dependencies

Source: https://docs.lamin.ai/setup-laminr

Installs the laminr package along with all suggested dependencies from CRAN. This ensures that all optional functionalities and required packages are available for use.

```R
install.packages("laminr",dependencies=TRUE)
```

--------------------------------

### Initialize LaminDB Instance

Source: https://docs.lamin.ai/summary

Installs necessary packages and initializes a new LaminDB instance with specified storage and modules. This sets up the environment for data transfer operations.

```shell
# pip install 'lamindb[jupyter,bionty]'
!lamin init --storage ./test-transfer --modules bionty
```

--------------------------------

### LaminDB Initialization Configuration Options

Source: https://docs.lamin.ai/guide

Demonstrates various command-line options for configuring LaminDB initialization, including specifying cloud storage, database connection strings, custom instance names, and mounting additional schema modules.

```Shell
--storage s3://my-bucket
```

```Shell
--db postgresql://<user>:<pwd>@<hostname>:<port>/<dbname>
```

```Shell
--name my-name
```

```Shell
--modules bionty,wetlab,custom1
```

--------------------------------

### Initialize and Track Data with LaminDB

Source: https://docs.lamin.ai/facs3

Demonstrates how to import necessary libraries (lamindb, bionty), track data using ln.track, and shows connection and run creation messages. This sets up the environment for data management.

```python
import lamindb as ln
import bionty as bt

ln.track("wukchS8V976U0000")
```

--------------------------------

### Create and Track Project with Lamindb

Source: https://docs.lamin.ai/track

Demonstrates creating a project, auto-linking entities to it, and saving an artifact. It shows how to initialize a project, set up tracking, and save an artifact, linking it implicitly to the active project.

```python
import lamindb as ln

my_project = ln.Project(name="My project").save()  # create a project

ln.track(project="My project")  # auto-link entities to "My project"

ln.Artifact(ln.core.datasets.file_fcs(), key="my_file.fcs").save()  # save an artifact
```

--------------------------------

### Initialize LaminDB Locally

Source: https://docs.lamin.ai/summary

Shows how to set up a local LaminDB instance. This includes commands for shell, Python, and R environments, specifying a local directory for storage.

```shell
lamin init --storage ./mydir
```

```python
import lamindb as ln
ln.setup.init(storage="./mydir")
```

```r
library(laminr)
lamin_init(storage="./mydir")
```

--------------------------------

### LaminDB Installation and Initialization

Source: https://docs.lamin.ai/faq/idempotency

Installs LaminDB with Jupyter support using pip and initializes the LaminDB command-line interface. This is a prerequisite for using LaminDB in many environments.

```shell
# pip install 'lamindb[jupyter]'
!lamin
```

--------------------------------

### Initialize LaminDB Instance

Source: https://docs.lamin.ai/faq/keep-artifacts-local

Initializes a new LaminDB instance, logging in the user and setting up the instance for use. This command-line step is crucial before programmatically interacting with LaminDB.

```shell
!lamin!lamin
```

--------------------------------

### LaminDB API: Tracking and Initialization

Source: https://docs.lamin.ai/summary

Details the essential LaminDB functions for initializing the environment and starting a tracking session for ML experiments.

```APIDOC
ln.init(storage=..., db=...)
  - Initializes LaminDB. If storage is a path, it sets up a local SQLite DB.
  - Example: ln.init(storage='./lamin-mlops')

ln.track()
  - Starts a tracking session, enabling logging of operations and artifacts.
  - Typically called after initialization.
```

--------------------------------

### Install Lamin R Package

Source: https://docs.lamin.ai/summary

Installs the 'laminr' R package from CRAN, including necessary dependencies. This is the initial step for using Lamin.ai within an R environment.

```r
install.packages("laminr", dependencies = TRUE)
```

--------------------------------

### Initialize LaminDB Instance

Source: https://docs.lamin.ai/lamindb.setup

Initializes a LaminDB instance. It handles storage configuration, instance naming, database connection, and module loading. Supports various storage backends and database types.

```APIDOC
lamindb.setup.init(_*, storage='.', name=None, db=None, modules=None, **kwargs)
    Initializes a LaminDB instance.

    Parameters:
      storage (lamindb.core.types.UPathStr, default: '.'): A local or remote folder ('s3://...' or 'gs://...'). Defaults to current working directory.
      name (str | None, default: None): Instance name. If not passed, it will equal the folder name passed to storage.
      db (PostgresDsn | None, default: None): Database connection URL. Defaults to None, which implies an SQLite file in the storage location.
      modules (str | None, default: None): Comma-separated string of schema modules.
      **kwargs: Keyword arguments for low-level control.

    Return type:
      None
```

--------------------------------

### Install and Connect laminr R Package

Source: https://docs.lamin.ai/introduction

Installs the laminr R package from CRAN and connects to a LaminDB instance. The login step can be skipped for local or self-hosted instances.

```r
install.packages("laminr",dependencies=TRUE)# install the laminr package from CRAN
laminr::lamin_login()# <-- you can skip this for local & self-hosted instances
laminr::lamin_connect("<account>/<instance>")# <-- replace with your instance
```

--------------------------------

### Install and Connect laminr R Package

Source: https://docs.lamin.ai/index

Installs the laminr R package from CRAN and connects to a LaminDB instance. The login step can be skipped for local or self-hosted instances.

```r
install.packages("laminr",dependencies=TRUE)# install the laminr package from CRAN
laminr::lamin_login()# <-- you can skip this for local & self-hosted instances
laminr::lamin_connect("<account>/<instance>")# <-- replace with your instance
```
Tokens:
Raw