# Python API ## airflow.providers.lamindb.operators.flow Operators that open and close the LaminDB flow run of a DAG run. Both run lamindb inside a virtualenv, so the worker needs no lamindb. ### LaminDBFlowInitOperator ```python LaminDBFlowInitOperator( *, task_id: str = "lamindb_flow_init", is_setup: bool = True, lamindb_conn_id: str | None = default_conn_name, lamindb_instance: str | None = None, lamindb_version: str | None = None, lamindb_cache_dir: str | None = None, **kwargs: Any, ) ``` Bases: `_LaminDBFlowOperator` Start the LaminDB flow run for this DAG run, in a virtualenv. Creates (or restarts, on retry) a `Run` of the DAG file's `Transform` and tags it with the DAG run so downstream LaminDB steps can find it. Wrap the steps in `with init >> finish:` to wire them, or let steps with `auto_flow=True` add and wire one. Returns the flow run uid. Marked as an Airflow *setup* task by default, pairing with the *teardown* `LaminDBFlowFinishOperator`; pass `is_setup=False` to opt out. Accepts every `PythonVirtualenvOperator` argument except `python_callable`, `op_args` and `op_kwargs`. ### LaminDBFlowFinishOperator ```python LaminDBFlowFinishOperator( *, task_id: str = "lamindb_flow_finish", is_teardown: bool = True, lamindb_conn_id: str | None = default_conn_name, lamindb_instance: str | None = None, lamindb_version: str | None = None, lamindb_cache_dir: str | None = None, **kwargs: Any, ) ``` Bases: `_LaminDBFlowOperator` Close the LaminDB flow run with the DAG run's outcome, in a virtualenv. Marked as an Airflow *teardown* task by default: it runs after every other task (`trigger_rule=all_done_setup_success`) and is ignored when Airflow decides the DAG run state, so a failed step still fails the DAG run. Marks the flow run errored if any other task in the DAG run failed. Pass `is_teardown=False` together with your own `trigger_rule` to opt out. Accepts every `PythonVirtualenvOperator` argument except `python_callable`, `op_args` and `op_kwargs`. ## airflow.providers.lamindb.decorators.python\_virtualenv `@task.lamindb_venv`: run the function as a LaminDB step inside a virtualenv. ### lamindb\_venv\_task ```python lamindb_venv_task( python_callable: Callable[..., Any] | None = None, multiple_outputs: bool | None = None, **kwargs: Any, ) ``` `@task.lamindb_venv`: run the function as a LaminDB step inside a virtualenv. Accepts every `@task.virtualenv` argument, plus: - `lamindb_conn_id`: Airflow connection of type `lamindb` with the Lamin API key and the instance; default `lamindb_default`. The virtualenv gets them instead of the worker's `~/.lamin`. `None` uses lamindb's own configuration instead. Templated, e.g. from an upstream task's XCom. - `lamindb_instance`: instance slug to connect to; overrides the connection's. Templated. - `lamindb_version`: version of `lamindb-core` added to `requirements` unless you list lamindb yourself, 2.8.1 or newer; defaults to the instance's version on LaminHub (with a connection), else the latest. - `lamindb_cache_dir`: absolute path of a lamindb cache shared between tasks, set as `LAMIN_CACHE_DIR`; overrides the connection's `cache_dir` extra. Templated. - `auto_flow`: wire `init >> step >> finish` with the DAG's flow operators, adding ones with the same Python, index and LaminDB settings if the DAG has none yet. Default `False`; mapped steps are never auto-wired. - `track`: record the call in LaminDB. Default `True`; with `False` the function runs exactly as under `@task.virtualenv`, and lamindb is not added to `requirements`. The worker needs no lamindb. ## airflow.providers.lamindb.decorators.kubernetes `@task.lamindb_k8s`: run the function as a LaminDB step in a Kubernetes pod. ### lamindb\_k8s\_task ```python lamindb_k8s_task( python_callable: Callable[..., Any] | None = None, multiple_outputs: bool | None = None, **kwargs: Any, ) ``` `@task.lamindb_k8s`: run the function as a LaminDB step in a Kubernetes pod. Accepts every `@task.kubernetes` argument, plus `lamindb_conn_id` (Airflow connection of type `lamindb`; the pod only gets its instance, not its API key), `lamindb_instance` (instance slug; overrides the connection's; both templated), `auto_flow` (wire flow operators, which run in a virtualenv on the worker, if the DAG has none yet; default `False`) and `track` (record the call in LaminDB; with `False` it runs exactly as under `@task.kubernetes`). The image must have lamindb 2.8.1 or newer installed (the step fails on older versions) and credentials for the instance, e.g. `LAMIN_API_KEY` from a Kubernetes secret. The worker needs no lamindb. Requires `pip install "apache-airflow-providers-lamindb[cncf.kubernetes]"`. The step needs the `lamindb_default` connection (or the one named by `lamindb_conn_id`) and fails if it is missing. Pass `lamindb_conn_id=None` to use only the pod's own lamindb configuration, together with `lamindb_instance` to pin the instance. The auto-wired flow operators get the same `lamindb_conn_id`, so with `None` they use the worker's lamindb configuration (`LAMIN_API_KEY`, `LAMIN_CURRENT_INSTANCE`, `~/.lamin`) in their virtualenv. ## airflow.providers.lamindb.triggers.records ### LaminDBRecordEventTrigger ```python LaminDBRecordEventTrigger( registry: str, *, events: str | Sequence[str] = ("created",), branch: str | int | None = "main", filter: FilterLike | None = None, changed_fields: Sequence[str] | None = None, **kwargs: Any, ) ``` Bases: `LaminDBDbWriteEventTrigger` Fire an event for every record of a LaminDB registry that is created, updated or deleted. Use it in an `AssetWatcher` to schedule DAGs on LaminDB changes. Each event payload contains the `event` (`created`/`updated`/`deleted`), the current `record` (`None` for hard deletes), the `previous` values logged with the write, the `changed_fields` of updates, `changed_by` and the underlying `dbwrite` log entry. With `branch` set (`main` by default), events are relative to that branch: `created` also covers records that arrive on the branch by merging a contribution branch or by restoring them from the trash or archive, and `deleted` also covers records moved off the branch, for example to the trash via `record.delete()`. For registries without branches, `branch` is ignored. Parameters: - **`registry`** (`str`) – Registry to watch, e.g. `LaminDBRegistry.COLLECTION`, `"core.run"`, `"core.record"` or `"bionty.celltype"`. - **`events`** (`str | Sequence[str]`, default: `('created',)` ) – Events to report, any of `created`, `updated` and `deleted`. - **`branch`** (`str | int | None`, default: `'main'` ) – Name or id of the branch to watch; `None` reports raw inserts, updates and deletes on all branches. - **`filter`** (`FilterLike | None`, default: `None` ) – Filter the record must match, built with `F`, e.g. `F(ArtifactField.KEY).startswith("raw/")`, or a LaminHub REST filter such as `{"key": {"startswith": "raw/"}}`. It's evaluated against the current record; for hard deletes against the deleted row, which only supports direct fields. - **`changed_fields`** (`Sequence[str] | None`, default: `None` ) – Only report updates that change at least one of these fields, e.g. `[ArtifactField.KEY]`. Records that hold trigger cursors (see `cursor_store`) are never reported. They are recognized by the `registry` and `reference_type` of this trigger's own `RecordCursorStore` (by default `core.record` and `airflow_trigger_cursor`), so give triggers that store cursors in the registry they watch the same settings. ### LaminDBArtifactEventTrigger ```python LaminDBArtifactEventTrigger( *, key: str | None = None, key_prefix: str | None = None, suffix: str | Sequence[str] | None = None, kind: str | Sequence[str] | None = None, include_internal: bool = False, wait_for_upload: bool = True, **kwargs: Any, ) ``` Bases: `LaminDBRecordEventTrigger` Fire an event for every LaminDB artifact that is created, updated or deleted. A specialization of `LaminDBRecordEventTrigger` for `core.artifact`. By default, the `created` event fires only once the artifact's upload to storage has completed (`wait_for_upload`), so that downstream tasks can load it right away. Artifacts that LaminDB creates internally (run logs, environments) are ignored unless `include_internal` is set. Parameters: - **`key`** (`str | None`, default: `None` ) – Only artifacts with this exact key. - **`key_prefix`** (`str | None`, default: `None` ) – Only artifacts whose key starts with this prefix, e.g. `"raw/"`. - **`suffix`** (`str | Sequence[str] | None`, default: `None` ) – Only artifacts with this suffix (or any of these suffixes), e.g. `".parquet"`. - **`kind`** (`str | Sequence[str] | None`, default: `None` ) – Only artifacts of this kind (or any of these kinds), e.g. `ArtifactKind.DATASET`. - **`include_internal`** (`bool`, default: `False` ) – Also report artifacts LaminDB creates internally. - **`wait_for_upload`** (`bool`, default: `True` ) – Report `created` only once the upload to storage has completed and skip updates of artifacts that are being uploaded. - **`events`** – See `LaminDBRecordEventTrigger`. - **`branch`** – See `LaminDBRecordEventTrigger`. - **`filter`** – Additional filter, see `LaminDBRecordEventTrigger`. - **`changed_fields`** – See `LaminDBRecordEventTrigger`. ## airflow.providers.lamindb.triggers.branches ### LaminDBBranchStatusEventTrigger ```python LaminDBBranchStatusEventTrigger( *, to_status: str | Sequence[str] | None = None, from_status: str | Sequence[str] | None = None, branch_name: str | Sequence[str] | None = None, **kwargs: Any, ) ``` Bases: `LaminDBDbWriteEventTrigger` Fire an event whenever the status of a LaminDB branch changes. Branch statuses are `standalone`, `draft` and `review` (a Change Request is open), and `merged` and `closed`. The event payload contains `from_status`, `to_status`, the `branch` (with its current `status`), `changed_by` and the underlying `dbwrite` entry. Parameters: - **`to_status`** (`str | Sequence[str] | None`, default: `None` ) – Only report transitions to this status (or any of these statuses). - **`from_status`** (`str | Sequence[str] | None`, default: `None` ) – Only report transitions from this status (or any of these statuses). - **`branch_name`** (`str | Sequence[str] | None`, default: `None` ) – Only report branches whose name matches this glob pattern (or any of these patterns), e.g. `"release-*"`. ### LaminDBBranchBlockEventTrigger ```python LaminDBBranchBlockEventTrigger( *, kinds: str | Sequence[str] = BLOCK_KINDS, branch_name: str | Sequence[str] | None = None, **kwargs: Any, ) ``` Bases: `LaminDBDbWriteEventTrigger` Fire an event whenever a comment or readme is added to a LaminDB branch. Comments and readmes are `core.branchblock` records; a new readme version is a new block. The event payload contains the `kind`, the `block` (including its Markdown `content`), the `branch`, `changed_by` and the underlying `dbwrite` entry. Parameters: - **`kinds`** (`str | Sequence[str]`, default: `BLOCK_KINDS` ) – Block kinds to report, `comment` and/or `readme`. - **`branch_name`** (`str | Sequence[str] | None`, default: `None` ) – Only report blocks on branches whose name matches this glob pattern (or any of these patterns). ## airflow.providers.lamindb.triggers.base ### LaminDBDbWriteEventTrigger ```python LaminDBDbWriteEventTrigger( *, lamindb_conn_id: str | None = default_conn_name, instance: str | None = None, poll_interval: float = 30.0, batch_size: int = MAX_PAGE_SIZE, max_batches_per_poll: int = 10, cursor_store: CursorStore | Mapping[str, Any] | None = None, ) ``` Bases: `BaseEventTrigger` Base class for event-driven scheduling triggers that watch the LaminHub database write log. LaminHub logs every `INSERT`, `UPDATE` and `DELETE` on a LaminDB instance's database in the `hubmodule.dbwrite` registry ("Changes → Database writes" in the LaminHub UI). Subclasses define which writes to poll and how to turn them into trigger events. The trigger polls writes with an id greater than its cursor, and stores the cursor under `state_key` so that a restarted triggerer resumes where it left off. The cursor is committed at least `commit_delay` seconds after the events were yielded, which gives Airflow time to persist them: events are delivered at least once. It is only committed when the trigger processed new writes. On the first start the trigger only reports writes that happen from then on. Parameters: - **`lamindb_conn_id`** (`str | None`, default: `default_conn_name` ) – Airflow connection of type `lamindb`. - **`instance`** (`str | None`, default: `None` ) – LaminDB instance `owner/name`; overrides the connection's instance. - **`poll_interval`** (`float`, default: `30.0` ) – Seconds between polls of the write log. - **`batch_size`** (`int`, default: `MAX_PAGE_SIZE` ) – Number of writes fetched per request (at most 200). - **`max_batches_per_poll`** (`int`, default: `10` ) – Maximum number of batches processed per poll cycle. - **`cursor_store`** (`CursorStore | Mapping[str, Any] | None`, default: `None` ) – Where and how to store the cursor: `AssetCursorStore` (default) in the asset state store of the `AssetWatcher`'s assets, or `RecordCursorStore` in a record of the watched instance. Both also set the `commit_delay`. #### state\_key ```python state_key: str ``` Key of the cursor (and default name of its record); changes when the trigger's filters change. ## airflow.providers.lamindb.triggers.cursors Where the event triggers keep the id of the last processed database write. Pass a trigger `cursor_store=AssetCursorStore()` (the default) to keep it in the watched asset's Airflow asset state store, or `cursor_store=RecordCursorStore()` to keep it in a record of the watched instance itself. ### DEFAULT\_COMMIT\_DELAY ```python DEFAULT_COMMIT_DELAY = 5.0 ``` Default minimum seconds between yielding events and committing the cursor past them. ### CursorStore ```python CursorStore(*, commit_delay: float = DEFAULT_COMMIT_DELAY) ``` Where and how an event trigger keeps its cursor; use a subclass. Parameters: - **`commit_delay`** (`float`, default: `DEFAULT_COMMIT_DELAY` ) – Minimum seconds between yielding events and committing the cursor past them, which gives Airflow time to persist the events. Longer delays save less often, but redeliver more events after a crash. #### coerce ```python coerce(value: CursorStore | Mapping[str, Any] | None) -> CursorStore ``` Accept a store, its `serialize` form (as in serialized trigger kwargs) or None. #### open ```python open( *, hook: LaminDBHook, asset_state_store: Any, key: str, description: str ) -> CursorBackend ``` The backend that loads and saves the cursor under `key` while the trigger runs. ### AssetCursorStore ```python AssetCursorStore(*, commit_delay: float = DEFAULT_COMMIT_DELAY) ``` Bases: `CursorStore` Keep the cursor in the asset state store of the `AssetWatcher`'s assets. The cursor lives in Airflow's metadata database next to the asset events. A trigger outside an `AssetWatcher` has no asset state store and keeps its cursor in memory only. ### RecordCursorStore ```python RecordCursorStore( *, commit_delay: float = DEFAULT_COMMIT_DELAY, registry: str = "core.record", field: str = "extra_data", record_type: str | None = CURSOR_RECORD_TYPE_NAME, reference_type: str | None = CURSOR_REFERENCE_TYPE, branch: str | int = "main", space: str | int | None = None, name: str | None = None, description: str | None = None, ) ``` Bases: `CursorStore` Keep the cursor in a record of the watched instance; needs write access to the instance. The defaults keep each trigger's cursor in its own `core.record` on `main`, grouped under the record type `Airflow trigger cursors`. The record and its type are created on the first save. Deleting the record resets the cursor when the trigger restarts; a running trigger creates the record again on its next save. Parameters: - **`registry`** (`str`, default: `'core.record'` ) – Registry of the cursor records. It needs the fields `name`, `branch`, `space` and `field`, plus `reference_type` and `type`/`is_type` unless those are disabled below. - **`field`** (`str`, default: `'extra_data'` ) – JSON field that holds the cursor, `{"dbwrite_id": ..., "instance_id": ...}`. - **`record_type`** (`str | None`, default: `CURSOR_RECORD_TYPE_NAME` ) – Name of the record type (`is_type=True`) that groups the cursor records; `None` for no type, for registries without types. - **`reference_type`** (`str | None`, default: `CURSOR_REFERENCE_TYPE` ) – Marker in `reference_type` that identifies cursor records, so that record triggers on `registry` can skip them; `None` for no marker. Then such triggers report the cursor records like any other record. A record trigger watching `registry` itself needs a marker, so it rejects `None`. - **`branch`** (`str | int`, default: `'main'` ) – Branch (name or id) of the cursor records and their type. - **`space`** (`str | int | None`, default: `None` ) – Space (name or id) of the cursor records and their type, e.g. a restricted space that only the Airflow API key can write to; `None` for LaminHub's default space. - **`name`** (`str | None`, default: `None` ) – Name of the cursor record; `None` for the trigger's `state_key`. A fixed name must be unique per trigger, or triggers overwrite each other's cursors. - **`description`** (`str | None`, default: `None` ) – Description of the cursor record; `None` to describe the trigger. - **`commit_delay`** (`float`, default: `DEFAULT_COMMIT_DELAY` ) – See `CursorStore`. ## airflow.providers.lamindb.sensors.branches ### LaminDBBranchStatusSensor ```python LaminDBBranchStatusSensor( *, branch: str | int, target_status: str | Sequence[str] = "merged", failure_status: str | Sequence[str] = ("closed",), lamindb_conn_id: str | None = default_conn_name, instance: str | None = None, deferrable: bool = getboolean("operators", "default_deferrable", fallback=False), **kwargs: Any, ) ``` Bases: `BaseSensorOperator` Wait until a LaminDB branch reaches a status, e.g. until its Change Request is merged. Returns the branch (with its `status`), which is pushed to XCom. Fails without retries if the branch reaches one of the `failure_status` statuses (by default, when the Change Request is closed without merging). Network errors, rate limiting and LaminHub server errors don't end the wait; the sensor checks again later. For more information on how to use this sensor, take a look at the [guide](). Parameters: - **`branch`** (`str | int`) – Branch name or id. - **`target_status`** (`str | Sequence[str]`, default: `'merged'` ) – Status (or statuses) to wait for, any of `standalone`, `draft`, `review`, `merged` and `closed`. - **`failure_status`** (`str | Sequence[str]`, default: `('closed',)` ) – Status (or statuses) that fail the sensor. - **`lamindb_conn_id`** (`str | None`, default: `default_conn_name` ) – Airflow connection of type `lamindb`. - **`instance`** (`str | None`, default: `None` ) – LaminDB instance `owner/name`; overrides the connection's instance. - **`deferrable`** (`bool`, default: `getboolean('operators', 'default_deferrable', fallback=False)` ) – Wait in the triggerer instead of occupying a worker slot. ## airflow.providers.lamindb.sensors.records ### LaminDBRecordSensor ```python LaminDBRecordSensor( *, registry: str, filter: FilterLike | None = None, branch: str | int | None = "main", min_count: int = 1, limit: int = 100, wait_for_upload: bool | None = None, lamindb_conn_id: str | None = default_conn_name, instance: str | None = None, deferrable: bool = getboolean("operators", "default_deferrable", fallback=False), **kwargs: Any, ) ``` Bases: `BaseSensorOperator` Wait until records matching a filter exist in a LaminDB registry. Returns the matching records (newest first, at most `limit`), which are pushed to XCom. Network errors, rate limiting and LaminHub server errors don't end the wait; the sensor checks again later. For more information on how to use this sensor, take a look at the [guide](). Parameters: - **`registry`** (`str`) – Registry to query, e.g. `LaminDBRegistry.RUN`, `"core.artifact"` or `"bionty.celltype"`. - **`filter`** (`FilterLike | None`, default: `None` ) – Filter built with `F`, e.g. `F(ArtifactField.KEY) == "raw/sample1.fastq.gz"`, or a LaminHub REST filter such as `{"key": {"eq": "raw/sample1.fastq.gz"}}`. It's validated when the DAG is parsed. - **`branch`** (`str | int | None`, default: `'main'` ) – Only records on this branch (name or id); `None` for all branches and for registries without branches. - **`min_count`** (`int`, default: `1` ) – Number of matching records to wait for. - **`limit`** (`int`, default: `100` ) – Maximum number of records returned. - **`wait_for_upload`** (`bool | None`, default: `None` ) – Ignore artifacts whose upload to storage is still in progress. - **`lamindb_conn_id`** (`str | None`, default: `default_conn_name` ) – Airflow connection of type `lamindb`. - **`instance`** (`str | None`, default: `None` ) – LaminDB instance `owner/name`; overrides the connection's instance. - **`deferrable`** (`bool`, default: `getboolean('operators', 'default_deferrable', fallback=False)` ) – Wait in the triggerer instead of occupying a worker slot. ### LaminDBArtifactSensor ```python LaminDBArtifactSensor( *, key: str | None = None, key_prefix: str | None = None, suffix: str | Sequence[str] | None = None, kind: str | Sequence[str] | None = None, include_internal: bool = False, wait_for_upload: bool = True, **kwargs: Any, ) ``` Bases: `LaminDBRecordSensor` Wait until LaminDB artifacts matching some criteria exist and their upload has completed. Returns the matching artifacts (newest first, at most `limit`), which are pushed to XCom. For more information on how to use this sensor, take a look at the [guide](). Parameters: - **`key`** (`str | None`, default: `None` ) – Artifact key, e.g. `"raw/sample1.fastq.gz"`. - **`key_prefix`** (`str | None`, default: `None` ) – Key prefix, e.g. `"raw/"`. - **`suffix`** (`str | Sequence[str] | None`, default: `None` ) – Suffix (or suffixes), e.g. `".parquet"`. - **`kind`** (`str | Sequence[str] | None`, default: `None` ) – Artifact kind (or kinds), e.g. `ArtifactKind.DATASET`. - **`include_internal`** (`bool`, default: `False` ) – Also consider artifacts LaminDB creates internally (run logs, ...). - **`filter`** – Additional filter, see `LaminDBRecordSensor`. - **`wait_for_upload`** (`bool`, default: `True` ) – Ignore artifacts whose upload is still in progress (default). ## airflow.providers.lamindb.hooks.lamindb ### DEFAULT\_HUB\_API\_URL ```python DEFAULT_HUB_API_URL = 'https://aws.us-east-1.lamin.ai/api' ``` ### LaminDBHook ```python LaminDBHook( lamindb_conn_id: str | None = default_conn_name, instance: str | None = None, *, timeout: float = 30.0, retries: int = 3, retry_backoff: float = 1.0, **kwargs: Any, ) ``` Bases: `BaseHook` Interact with LaminDB instances hosted on LaminHub via the LaminHub REST API. The connection's password is a Lamin API key; it is exchanged for a short-lived access token that is refreshed automatically. Without an API key, requests are anonymous, which works for public instances. The instance (`owner/name`) is read from the connection's `instance` extra and can be overridden per hook. Instances on lamindb older than 2.8.1 are rejected with `LaminDBVersionError`. Parameters: - **`lamindb_conn_id`** (`str | None`, default: `default_conn_name` ) – Airflow connection of type `lamindb`. `None` means anonymous access with default settings, which requires `instance` to be passed. - **`instance`** (`str | None`, default: `None` ) – LaminDB instance slug `owner/name`. Overrides the connection's instance. - **`timeout`** (`float`, default: `30.0` ) – Timeout for HTTP requests in seconds. - **`retries`** (`int`, default: `3` ) – Number of retries for connection errors and retryable HTTP status codes (429 and 5xx). - **`retry_backoff`** (`float`, default: `1.0` ) – Base delay in seconds for the exponential retry backoff. #### get\_conn ```python get_conn() -> Client ``` Return the (lazily created) synchronous HTTP client. #### get\_async\_conn ```python get_async_conn() -> AsyncClient ``` Return the (lazily created) asynchronous HTTP client. #### get\_instance\_slug ```python get_instance_slug() -> str ``` Return the configured instance `owner/name` without contacting LaminHub. #### get\_api\_key ```python get_api_key() -> str | None ``` Return the connection's Lamin API key, or `None` for anonymous access. #### get\_cache\_dir ```python get_cache_dir() -> str | None ``` Return the connection's `cache_dir` extra: the lamindb cache shared by virtualenv tasks. #### get\_instance ```python get_instance() -> LaminDBInstance ``` Return the configured instance (resolves its id and regional API URL on first use). Raises `LaminDBVersionError` if the instance runs lamindb older than 2.8.1. #### get\_schema ```python get_schema() -> dict[str, Any] ``` Return the instance schema: `{module: {model: {"table_name": ..., "fields": ...}}}`. #### get\_registry ```python get_registry(registry: str | Registry) -> Registry ``` Resolve a registry name such as `core.artifact` or `bionty.gene`. #### query\_records ```python query_records( registry: str | Registry, filter: FilterLike | None = None, *, select: Sequence[str] | None = None, order_by: Sequence[str | Mapping[str, Any]] | None = None, limit: int = 50, offset: int = 0, include_foreign_keys: bool = True, search: str | None = None, branch_ids: Sequence[int] | None = None, ) -> list[dict[str, Any]] ``` Query records of a registry. Parameters: - **`registry`** (`str | Registry`) – Registry name such as `core.artifact`, `core.run` or `bionty.gene`, or a `LaminDBRegistry` member. - **`filter`** (`FilterLike | None`, default: `None` ) – Filter built with `F`, e.g. `F(ArtifactField.SUFFIX) == ".csv"`, or a LaminHub REST filter such as `{"suffix": {"eq": ".csv"}}`, see [https://docs.lamin.ai/rest]() - **`select`** (`Sequence[str] | None`, default: `None` ) – Fields (and relations such as `created_by(handle)`) to return. - **`order_by`** (`Sequence[str | Mapping[str, Any]] | None`, default: `None` ) – Sort order, for example `["-created_at"]`. Defaults to ascending `id`. - **`limit`** (`int`, default: `50` ) – Maximum number of records; requests are paginated in pages of 200. - **`offset`** (`int`, default: `0` ) – Number of records to skip. - **`include_foreign_keys`** (`bool`, default: `True` ) – Include foreign key columns (`run_id`, `branch_id`, ...). - **`search`** (`str | None`, default: `None` ) – Full-text search string. - **`branch_ids`** (`Sequence[int] | None`, default: `None` ) – Restrict the query scope to these branch ids. #### get\_records\_by\_ids ```python get_records_by_ids( registry: str | Registry, ids: Iterable[int], filter: FilterLike | None = None ) -> dict[int, dict[str, Any]] ``` Fetch records by id, optionally restricted by an additional filter. Returns `{id: record}`. #### query\_dbwrites ```python query_dbwrites( filter: FilterLike | None = None, *, after_id: int | None = None, limit: int = MAX_PAGE_SIZE, descending: bool = False, ) -> list[dict[str, Any]] ``` Query the LaminHub database write log, ordered by id. Every `INSERT`, `UPDATE` and `DELETE` on the instance database is logged with `table_name`, `sqlrecord_id`, `event_type`, `branch_id` and `data`. For updates, `data` holds the *previous* values of the changed fields; for deletes the full previous row; for inserts it is `null`. #### get\_latest\_dbwrite\_id ```python get_latest_dbwrite_id() -> int ``` Return the id of the most recent database write (`0` if there is none). #### get\_branch ```python get_branch(branch: str | int) -> dict[str, Any] | None ``` Return a branch record by name or id, or `None` if it doesn't exist. #### get\_users ```python get_users(ids: Iterable[int]) -> dict[int, dict[str, Any]] ``` Return `{id: user}` for the given user ids. #### insert\_records ```python insert_records( registry: str | Registry, records: Sequence[Mapping[str, Any]] ) -> list[dict[str, Any]] ``` Insert records into a registry and return the created rows. Needs write access to the instance. Fields are column names, e.g. `{"name": "treated"}` or `{"type_id": 3}`. Inserts are not retried after errors that may have reached LaminHub, so a failed request never creates a record twice. #### update\_record ```python update_record( registry: str | Registry, uid: str, values: Mapping[str, Any] ) -> dict[str, Any] | None ``` Update fields of the record with `uid` and return the updated row (if LaminHub returns it). #### test\_connection ```python test_connection() -> tuple[bool, str] ``` Test the connection by resolving the instance and reading its database write log. #### aget\_instance ```python aget_instance() -> LaminDBInstance ``` Async version of `get_instance`. #### aget\_schema ```python aget_schema() -> dict[str, Any] ``` Async version of `get_schema`. #### aget\_registry ```python aget_registry(registry: str | Registry) -> Registry ``` Async version of `get_registry`. #### aquery\_records ```python aquery_records( registry: str | Registry, filter: FilterLike | None = None, *, select: Sequence[str] | None = None, order_by: Sequence[str | Mapping[str, Any]] | None = None, limit: int = 50, offset: int = 0, include_foreign_keys: bool = True, search: str | None = None, branch_ids: Sequence[int] | None = None, ) -> list[dict[str, Any]] ``` Async version of `query_records`. #### aget\_records\_by\_ids ```python aget_records_by_ids( registry: str | Registry, ids: Iterable[int], filter: FilterLike | None = None ) -> dict[int, dict[str, Any]] ``` Async version of `get_records_by_ids`. #### aquery\_dbwrites ```python aquery_dbwrites( filter: FilterLike | None = None, *, after_id: int | None = None, limit: int = MAX_PAGE_SIZE, descending: bool = False, ) -> list[dict[str, Any]] ``` Async version of `query_dbwrites`. #### aget\_latest\_dbwrite\_id ```python aget_latest_dbwrite_id() -> int ``` Async version of `get_latest_dbwrite_id`. #### aget\_branch ```python aget_branch(branch: str | int) -> dict[str, Any] | None ``` Async version of `get_branch`. #### aget\_users ```python aget_users(ids: Iterable[int]) -> dict[int, dict[str, Any]] ``` Async version of `get_users`. #### ainsert\_records ```python ainsert_records( registry: str | Registry, records: Sequence[Mapping[str, Any]] ) -> list[dict[str, Any]] ``` Async version of `insert_records`. #### aupdate\_record ```python aupdate_record( registry: str | Registry, uid: str, values: Mapping[str, Any] ) -> dict[str, Any] | None ``` Async version of `update_record`. ### LaminDBInstance ```python LaminDBInstance( owner: str, name: str, id: str, api_url: str, lnid: str | None = None, schema_str: str | None = None, public: bool | None = None, lamindb_version: str | None = None, ) ``` A LaminDB instance registered on LaminHub. ### Registry ```python Registry(module: str, model: str, table_name: str) ``` A LaminDB registry (a Django model), addressed by schema module and model name. ## airflow.providers.lamindb.utils.filters Build, validate and evaluate LaminHub REST filters. Filters select records by their fields. Build them with `F` and the field enums, or write the JSON form of the [LaminHub REST API]() directly. These are equivalent: ```python F(ArtifactField.KEY).startswith("raw/") & (F(ArtifactField.SIZE) > 1_000_000) {"and": [{"key": {"startswith": "raw/"}}, {"size": {"gt": 1000000}}]} ``` ### F ```python F(*path: str) ``` A field to filter on, e.g. `F(ArtifactField.KEY)`, `F("key")` or `F("created_by.handle")`. Compare it with a value to get a `Condition`, using Python's comparison operators (`==`, `!=`, `>`, `>=`, `<`, `<=`) or the methods of this class. Combine conditions with `&` (and) and `|` (or); as `&` and `|` bind more tightly than comparisons, wrap comparisons in parentheses: ```python (F(ArtifactField.SUFFIX) == ".parquet") & (F(ArtifactField.SIZE) > 1_000_000) F(ArtifactField.KEY).startswith("raw/") | F(ArtifactField.KIND).is_in([ArtifactKind.DATASET]) ``` Pass several fields to follow relations: `F(ArtifactField.CREATED_BY, UserField.HANDLE)` is the path `created_by.handle`. Index JSON fields with keys: `F(RunField.PARAMS)["learning_rate"]`. Parameters: - **`path`** (`str`, default: `()` ) – Field enum members or field names, e.g. `ArtifactField.KEY` or `"key"`. #### path ```python path: str ``` The field path in the LaminHub REST format, e.g. `created_by.handle`. #### op ```python op(operator: FilterOperator | str, value: Any) -> Condition ``` Compare with any `FilterOperator`, e.g. `F("key").op(FilterOperator.EQ, "a.csv")`. #### eq ```python eq(value: Any) -> Condition ``` Equal to `value` (`==`); `None` selects `null` values. #### ne ```python ne(value: Any) -> Condition ``` Distinct from `value`, including `null` values (`!=`); `None` selects non-null values. #### gt ```python gt(value: str | float | date) -> Condition ``` Greater than `value` (`>`). #### gte ```python gte(value: str | float | date) -> Condition ``` Greater than or equal to `value` (`>=`). #### lt ```python lt(value: str | float | date) -> Condition ``` Less than `value` (`<`). #### lte ```python lte(value: str | float | date) -> Condition ``` Less than or equal to `value` (`<=`). #### is\_in ```python is_in(values: Iterable[Any]) -> Condition ``` Equal to any of `values`; an empty list matches nothing. #### not\_in ```python not_in(values: Iterable[Any]) -> Condition ``` Equal to none of `values`. #### is\_null ```python is_null() -> Condition ``` The field is `null`. #### is\_not\_null ```python is_not_null() -> Condition ``` The field is not `null`. #### startswith ```python startswith(prefix: str) -> Condition ``` The string starts with `prefix` (case-sensitive). #### endswith ```python endswith(suffix: str) -> Condition ``` The string ends with `suffix` (case-sensitive). #### contains ```python contains(value: str | float | bool) -> Condition ``` The string contains `value` (case-sensitive), or the JSON array has the element `value`. #### count ```python count() -> Count ``` The number of related records, e.g. `F(TransformField.RUNS).count() >= 2`. ### Count ```python Count(field: F) ``` The number of related records of a relation, see `F.count`. #### eq ```python eq(n: int) -> Condition ``` Exactly `n` related records (`==`). #### ne ```python ne(n: int) -> Condition ``` Not exactly `n` related records (`!=`). #### gt ```python gt(n: int) -> Condition ``` More than `n` related records (`>`). #### gte ```python gte(n: int) -> Condition ``` At least `n` related records (`>=`). #### lt ```python lt(n: int) -> Condition ``` Fewer than `n` related records (`<`). #### lte ```python lte(n: int) -> Condition ``` At most `n` related records (`<=`). ### FilterExpression Base class of filters built in Python: `Condition`, `And` and `Or`. Combine filters with `&` (and) and `|` (or); the other operand may also be a LaminHub REST filter dict. `to_dict` returns the JSON form that the LaminHub REST API expects. #### to\_dict ```python to_dict() -> dict[str, Any] ``` Return the filter in the JSON form of the LaminHub REST API. #### from\_dict ```python from_dict(node: Mapping[str, Any]) -> FilterExpression ``` Parse and validate a LaminHub REST filter, e.g. `{"key": {"eq": "raw/a.csv"}}`. ### Condition ```python Condition(field: F | str, operator: FilterOperator | str, value: Any) ``` Bases: `FilterExpression` A condition on a field, e.g. `Condition(ArtifactField.KEY, FilterOperator.STARTSWITH, "raw/")`. Comparing an `F` creates conditions too, e.g. `F(ArtifactField.KEY).startswith("raw/")`. Parameters: - **`field`** (`F | str`) – The field, as an `F`, a field enum member or a field name. - **`operator`** (`FilterOperator | str`) – A `FilterOperator` or its name, e.g. `"startswith"`. - **`value`** (`Any`) – The value to compare with; enum members, dates, tuples and sets are converted to their JSON form. ### And ```python And(*filters: FilterLike) ``` Bases: `_Group` All filters match, e.g. `And(F("suffix") == ".csv", F("size") > 0)`; like `&`. ### Or ```python Or(*filters: FilterLike) ``` Bases: `_Group` At least one filter matches, e.g. `Or(F("suffix") == ".csv", F("suffix") == ".tsv")`; like `|`. ## airflow.providers.lamindb.utils.enums Enums for building LaminHub REST filters: registries, filter operators, registry fields and values. The field enums reflect the core registries of LaminDB 2.11. Use them with `F`, for example `F(ArtifactField.KEY) == "raw/a.csv"`. Plain strings work for every field, including fields of other schema modules such as `bionty`. ### LaminDBRegistry Bases: `_StrEnum` Registries (`module.model`) to pass as `registry` to sensors, triggers and the hook. #### ARTIFACT ```python ARTIFACT = 'core.artifact' ``` #### COLLECTION ```python COLLECTION = 'core.collection' ``` #### RUN ```python RUN = 'core.run' ``` #### TRANSFORM ```python TRANSFORM = 'core.transform' ``` #### RECORD ```python RECORD = 'core.record' ``` #### ULABEL ```python ULABEL = 'core.ulabel' ``` #### FEATURE ```python FEATURE = 'core.feature' ``` #### SCHEMA ```python SCHEMA = 'core.schema' ``` #### PROJECT ```python PROJECT = 'core.project' ``` #### REFERENCE ```python REFERENCE = 'core.reference' ``` #### STORAGE ```python STORAGE = 'core.storage' ``` #### BRANCH ```python BRANCH = 'core.branch' ``` #### SPACE ```python SPACE = 'core.space' ``` #### USER ```python USER = 'core.user' ``` #### BIONTY\_CELL\_LINE ```python BIONTY_CELL_LINE = 'bionty.cellline' ``` #### BIONTY\_CELL\_MARKER ```python BIONTY_CELL_MARKER = 'bionty.cellmarker' ``` #### BIONTY\_CELL\_TYPE ```python BIONTY_CELL_TYPE = 'bionty.celltype' ``` #### BIONTY\_DEVELOPMENTAL\_STAGE ```python BIONTY_DEVELOPMENTAL_STAGE = 'bionty.developmentalstage' ``` #### BIONTY\_DISEASE ```python BIONTY_DISEASE = 'bionty.disease' ``` #### BIONTY\_ETHNICITY ```python BIONTY_ETHNICITY = 'bionty.ethnicity' ``` #### BIONTY\_EXPERIMENTAL\_FACTOR ```python BIONTY_EXPERIMENTAL_FACTOR = 'bionty.experimentalfactor' ``` #### BIONTY\_GENE ```python BIONTY_GENE = 'bionty.gene' ``` #### BIONTY\_ORGANISM ```python BIONTY_ORGANISM = 'bionty.organism' ``` #### BIONTY\_PATHWAY ```python BIONTY_PATHWAY = 'bionty.pathway' ``` #### BIONTY\_PHENOTYPE ```python BIONTY_PHENOTYPE = 'bionty.phenotype' ``` #### BIONTY\_PROTEIN ```python BIONTY_PROTEIN = 'bionty.protein' ``` #### BIONTY\_SOURCE ```python BIONTY_SOURCE = 'bionty.source' ``` #### BIONTY\_TISSUE ```python BIONTY_TISSUE = 'bionty.tissue' ``` ### FilterOperator Bases: `_StrEnum` Operators of LaminHub REST filters, see [https://docs.lamin.ai/rest](). #### EQ ```python EQ = 'eq' ``` Equal to the value. #### NE ```python NE = 'ne' ``` Distinct from the value, including `null` on SQL columns. #### GT ```python GT = 'gt' ``` Greater than the value (a string or number). #### GTE ```python GTE = 'gte' ``` Greater than or equal to the value (a string or number). #### LT ```python LT = 'lt' ``` Less than the value (a string or number). #### LTE ```python LTE = 'lte' ``` Less than or equal to the value (a string or number). #### IN ```python IN = 'in' ``` Equal to any of the listed values; an empty list matches nothing. #### NOT\_IN ```python NOT_IN = 'notin' ``` Equal to none of the listed values. #### IS\_NULL ```python IS_NULL = 'isnull' ``` `True` selects `null` values, `False` selects non-null values. #### STARTSWITH ```python STARTSWITH = 'startswith' ``` Case-sensitive prefix. #### ENDSWITH ```python ENDSWITH = 'endswith' ``` Case-sensitive suffix. #### CONTAINS ```python CONTAINS = 'contains' ``` Case-sensitive substring of strings, or element of JSON arrays. #### COUNT\_EQ ```python COUNT_EQ = 'count_eq' ``` Number of related records equals the value. #### COUNT\_NE ```python COUNT_NE = 'count_ne' ``` Number of related records differs from the value. #### COUNT\_GT ```python COUNT_GT = 'count_gt' ``` Number of related records is greater than the value. #### COUNT\_GTE ```python COUNT_GTE = 'count_gte' ``` Number of related records is at least the value. #### COUNT\_LT ```python COUNT_LT = 'count_lt' ``` Number of related records is less than the value. #### COUNT\_LTE ```python COUNT_LTE = 'count_lte' ``` Number of related records is at most the value. #### is\_count ```python is_count: bool ``` Whether the operator compares the number of related records. ### ArtifactKind Bases: `_StrEnum` Values of `ArtifactField.KIND`. #### DATASET ```python DATASET = 'dataset' ``` #### MODEL ```python MODEL = 'model' ``` #### PLAN ```python PLAN = 'plan' ``` #### LAMINDB\_RUN ```python LAMINDB_RUN = '__lamindb_run__' ``` Created by LaminDB for runs (logs, reports, environments). #### LAMINDB\_CONFIG ```python LAMINDB_CONFIG = '__lamindb_config__' ``` Created by LaminDB for configurations. ### TransformKind Bases: `_StrEnum` Values of `TransformField.KIND`. #### PIPELINE ```python PIPELINE = 'pipeline' ``` #### NOTEBOOK ```python NOTEBOOK = 'notebook' ``` #### SCRIPT ```python SCRIPT = 'script' ``` #### FUNCTION ```python FUNCTION = 'function' ``` ### RunStatus Bases: `IntEnum` Run statuses, as the codes stored in `RunField.STATUS_CODE`. #### SCHEDULED ```python SCHEDULED = -3 ``` #### RESTARTED ```python RESTARTED = -2 ``` #### STARTED ```python STARTED = -1 ``` #### COMPLETED ```python COMPLETED = 0 ``` #### ERRORED ```python ERRORED = 1 ``` #### ABORTED ```python ABORTED = 2 ``` ### RegistryField Bases: `_StrEnum` Base class of the registry field enums. Members that are relations know the registry they point to (`related`), so that `F` can follow them, for example `F(ArtifactField.CREATED_BY, UserField.HANDLE)`. Foreign keys (`..._ID` members) hold the id of the related record and can be compared directly. #### related ```python related: LaminDBRegistry | None ``` ### ArtifactField Bases: `RegistryField` Fields of `core.artifact` (`LaminDBRegistry.ARTIFACT`). #### ID ```python ID = 'id' ``` #### UID ```python UID = 'uid' ``` #### CREATED\_AT ```python CREATED_AT = 'created_at' ``` #### DESCRIPTION ```python DESCRIPTION = 'description' ``` #### EXTRA\_DATA ```python EXTRA_DATA = 'extra_data' ``` #### HASH ```python HASH = 'hash' ``` #### IS\_LATEST ```python IS_LATEST = 'is_latest' ``` #### IS\_LOCKED ```python IS_LOCKED = 'is_locked' ``` #### KEY ```python KEY = 'key' ``` #### KIND ```python KIND = 'kind' ``` #### N\_FILES ```python N_FILES = 'n_files' ``` #### N\_OBSERVATIONS ```python N_OBSERVATIONS = 'n_observations' ``` #### OTYPE ```python OTYPE = 'otype' ``` #### SIZE ```python SIZE = 'size' ``` #### SUFFIX ```python SUFFIX = 'suffix' ``` #### UPDATED\_AT ```python UPDATED_AT = 'updated_at' ``` #### VERSION\_TAG ```python VERSION_TAG = 'version_tag' ``` #### BRANCH\_ID ```python BRANCH_ID = 'branch_id' ``` #### CREATED\_BY\_ID ```python CREATED_BY_ID = 'created_by_id' ``` #### CREATED\_ON\_ID ```python CREATED_ON_ID = 'created_on_id' ``` #### RUN\_ID ```python RUN_ID = 'run_id' ``` #### SCHEMA\_ID ```python SCHEMA_ID = 'schema_id' ``` #### SPACE\_ID ```python SPACE_ID = 'space_id' ``` #### STORAGE\_ID ```python STORAGE_ID = 'storage_id' ``` #### BRANCH ```python BRANCH = ('branch', LaminDBRegistry.BRANCH) ``` #### CREATED\_BY ```python CREATED_BY = ('created_by', LaminDBRegistry.USER) ``` #### CREATED\_ON ```python CREATED_ON = ('created_on', LaminDBRegistry.BRANCH) ``` #### RUN ```python RUN = ('run', LaminDBRegistry.RUN) ``` #### SCHEMA ```python SCHEMA = ('schema', LaminDBRegistry.SCHEMA) ``` #### SPACE ```python SPACE = ('space', LaminDBRegistry.SPACE) ``` #### STORAGE ```python STORAGE = ('storage', LaminDBRegistry.STORAGE) ``` #### ARTIFACTS ```python ARTIFACTS = ('artifacts', LaminDBRegistry.ARTIFACT) ``` #### COLLECTIONS ```python COLLECTIONS = ('collections', LaminDBRegistry.COLLECTION) ``` #### INPUT\_OF\_RUNS ```python INPUT_OF_RUNS = ('input_of_runs', LaminDBRegistry.RUN) ``` #### LINKED\_BY\_ARTIFACTS ```python LINKED_BY_ARTIFACTS = ('linked_by_artifacts', LaminDBRegistry.ARTIFACT) ``` #### LINKED\_BY\_RUNS ```python LINKED_BY_RUNS = ('linked_by_runs', LaminDBRegistry.RUN) ``` #### LINKED\_IN\_RECORDS ```python LINKED_IN_RECORDS = ('linked_in_records', LaminDBRegistry.RECORD) ``` #### PROJECTS ```python PROJECTS = ('projects', LaminDBRegistry.PROJECT) ``` #### RECORDS ```python RECORDS = ('records', LaminDBRegistry.RECORD) ``` #### RECREATING\_RUNS ```python RECREATING_RUNS = ('recreating_runs', LaminDBRegistry.RUN) ``` #### REFERENCES ```python REFERENCES = ('references', LaminDBRegistry.REFERENCE) ``` #### RUNS ```python RUNS = ('runs', LaminDBRegistry.RUN) ``` #### SCHEMAS ```python SCHEMAS = ('schemas', LaminDBRegistry.SCHEMA) ``` #### ULABELS ```python ULABELS = ('ulabels', LaminDBRegistry.ULABEL) ``` #### USERS ```python USERS = ('users', LaminDBRegistry.USER) ``` ### CollectionField Bases: `RegistryField` Fields of `core.collection` (`LaminDBRegistry.COLLECTION`). #### ID ```python ID = 'id' ``` #### UID ```python UID = 'uid' ``` #### CREATED\_AT ```python CREATED_AT = 'created_at' ``` #### DESCRIPTION ```python DESCRIPTION = 'description' ``` #### HASH ```python HASH = 'hash' ``` #### IS\_LATEST ```python IS_LATEST = 'is_latest' ``` #### IS\_LOCKED ```python IS_LOCKED = 'is_locked' ``` #### KEY ```python KEY = 'key' ``` #### REFERENCE ```python REFERENCE = 'reference' ``` #### REFERENCE\_TYPE ```python REFERENCE_TYPE = 'reference_type' ``` #### UPDATED\_AT ```python UPDATED_AT = 'updated_at' ``` #### VERSION\_TAG ```python VERSION_TAG = 'version_tag' ``` #### BRANCH\_ID ```python BRANCH_ID = 'branch_id' ``` #### CREATED\_BY\_ID ```python CREATED_BY_ID = 'created_by_id' ``` #### CREATED\_ON\_ID ```python CREATED_ON_ID = 'created_on_id' ``` #### META\_ARTIFACT\_ID ```python META_ARTIFACT_ID = 'meta_artifact_id' ``` #### RUN\_ID ```python RUN_ID = 'run_id' ``` #### SCHEMA\_ID ```python SCHEMA_ID = 'schema_id' ``` #### SPACE\_ID ```python SPACE_ID = 'space_id' ``` #### BRANCH ```python BRANCH = ('branch', LaminDBRegistry.BRANCH) ``` #### CREATED\_BY ```python CREATED_BY = ('created_by', LaminDBRegistry.USER) ``` #### CREATED\_ON ```python CREATED_ON = ('created_on', LaminDBRegistry.BRANCH) ``` #### META\_ARTIFACT ```python META_ARTIFACT = ('meta_artifact', LaminDBRegistry.ARTIFACT) ``` #### RUN ```python RUN = ('run', LaminDBRegistry.RUN) ``` #### SCHEMA ```python SCHEMA = ('schema', LaminDBRegistry.SCHEMA) ``` #### SPACE ```python SPACE = ('space', LaminDBRegistry.SPACE) ``` #### ARTIFACTS ```python ARTIFACTS = ('artifacts', LaminDBRegistry.ARTIFACT) ``` #### INPUT\_OF\_RUNS ```python INPUT_OF_RUNS = ('input_of_runs', LaminDBRegistry.RUN) ``` #### LINKED\_IN\_RECORDS ```python LINKED_IN_RECORDS = ('linked_in_records', LaminDBRegistry.RECORD) ``` #### PROJECTS ```python PROJECTS = ('projects', LaminDBRegistry.PROJECT) ``` #### RECORDS ```python RECORDS = ('records', LaminDBRegistry.RECORD) ``` #### RECREATING\_RUNS ```python RECREATING_RUNS = ('recreating_runs', LaminDBRegistry.RUN) ``` #### REFERENCES ```python REFERENCES = ('references', LaminDBRegistry.REFERENCE) ``` #### ULABELS ```python ULABELS = ('ulabels', LaminDBRegistry.ULABEL) ``` ### RunField Bases: `RegistryField` Fields of `core.run` (`LaminDBRegistry.RUN`). #### ID ```python ID = 'id' ``` #### UID ```python UID = 'uid' ``` #### CLI\_ARGS ```python CLI_ARGS = 'cli_args' ``` #### CREATED\_AT ```python CREATED_AT = 'created_at' ``` #### DESCRIPTION ```python DESCRIPTION = 'description' ``` #### ENTRYPOINT ```python ENTRYPOINT = 'entrypoint' ``` #### EXTRA\_DATA ```python EXTRA_DATA = 'extra_data' ``` #### FINISHED\_AT ```python FINISHED_AT = 'finished_at' ``` #### IS\_LOCKED ```python IS_LOCKED = 'is_locked' ``` #### NAME ```python NAME = 'name' ``` #### PARAMS ```python PARAMS = 'params' ``` #### REFERENCE ```python REFERENCE = 'reference' ``` #### REFERENCE\_TYPE ```python REFERENCE_TYPE = 'reference_type' ``` #### STARTED\_AT ```python STARTED_AT = 'started_at' ``` #### STATUS\_CODE ```python STATUS_CODE = '_status_code' ``` The run status as a code, compare it with `RunStatus`. #### UPDATED\_AT ```python UPDATED_AT = 'updated_at' ``` #### BRANCH\_ID ```python BRANCH_ID = 'branch_id' ``` #### CREATED\_BY\_ID ```python CREATED_BY_ID = 'created_by_id' ``` #### CREATED\_ON\_ID ```python CREATED_ON_ID = 'created_on_id' ``` #### ENVIRONMENT\_ID ```python ENVIRONMENT_ID = 'environment_id' ``` #### INITIATED\_BY\_RUN\_ID ```python INITIATED_BY_RUN_ID = 'initiated_by_run_id' ``` #### PLAN\_ID ```python PLAN_ID = 'plan_id' ``` #### REPORT\_ID ```python REPORT_ID = 'report_id' ``` #### SPACE\_ID ```python SPACE_ID = 'space_id' ``` #### TRANSFORM\_ID ```python TRANSFORM_ID = 'transform_id' ``` #### BRANCH ```python BRANCH = ('branch', LaminDBRegistry.BRANCH) ``` #### CREATED\_BY ```python CREATED_BY = ('created_by', LaminDBRegistry.USER) ``` #### CREATED\_ON ```python CREATED_ON = ('created_on', LaminDBRegistry.BRANCH) ``` #### ENVIRONMENT ```python ENVIRONMENT = ('environment', LaminDBRegistry.ARTIFACT) ``` #### INITIATED\_BY\_RUN ```python INITIATED_BY_RUN = ('initiated_by_run', LaminDBRegistry.RUN) ``` #### PLAN ```python PLAN = ('plan', LaminDBRegistry.ARTIFACT) ``` #### REPORT ```python REPORT = ('report', LaminDBRegistry.ARTIFACT) ``` #### SPACE ```python SPACE = ('space', LaminDBRegistry.SPACE) ``` #### TRANSFORM ```python TRANSFORM = ('transform', LaminDBRegistry.TRANSFORM) ``` #### ARTIFACTS ```python ARTIFACTS = ('artifacts', LaminDBRegistry.ARTIFACT) ``` #### INPUT\_ARTIFACTS ```python INPUT_ARTIFACTS = ('input_artifacts', LaminDBRegistry.ARTIFACT) ``` #### INPUT\_COLLECTIONS ```python INPUT_COLLECTIONS = ('input_collections', LaminDBRegistry.COLLECTION) ``` #### INPUT\_RECORDS ```python INPUT_RECORDS = ('input_records', LaminDBRegistry.RECORD) ``` #### LINKED\_ARTIFACTS ```python LINKED_ARTIFACTS = ('linked_artifacts', LaminDBRegistry.ARTIFACT) ``` #### LINKED\_IN\_RECORDS ```python LINKED_IN_RECORDS = ('linked_in_records', LaminDBRegistry.RECORD) ``` #### OUTPUT\_ARTIFACTS ```python OUTPUT_ARTIFACTS = ('output_artifacts', LaminDBRegistry.ARTIFACT) ``` #### OUTPUT\_COLLECTIONS ```python OUTPUT_COLLECTIONS = ('output_collections', LaminDBRegistry.COLLECTION) ``` #### OUTPUT\_RECORDS ```python OUTPUT_RECORDS = ('output_records', LaminDBRegistry.RECORD) ``` #### OUTPUT\_TRANSFORMS ```python OUTPUT_TRANSFORMS = ('output_transforms', LaminDBRegistry.TRANSFORM) ``` #### PROJECTS ```python PROJECTS = ('projects', LaminDBRegistry.PROJECT) ``` #### RECORDS ```python RECORDS = ('records', LaminDBRegistry.RECORD) ``` #### RECREATED\_ARTIFACTS ```python RECREATED_ARTIFACTS = ('recreated_artifacts', LaminDBRegistry.ARTIFACT) ``` #### RECREATED\_COLLECTIONS ```python RECREATED_COLLECTIONS = ('recreated_collections', LaminDBRegistry.COLLECTION) ``` #### ULABELS ```python ULABELS = ('ulabels', LaminDBRegistry.ULABEL) ``` ### TransformField Bases: `RegistryField` Fields of `core.transform` (`LaminDBRegistry.TRANSFORM`). #### ID ```python ID = 'id' ``` #### UID ```python UID = 'uid' ``` #### CREATED\_AT ```python CREATED_AT = 'created_at' ``` #### DESCRIPTION ```python DESCRIPTION = 'description' ``` #### HASH ```python HASH = 'hash' ``` #### IS\_LATEST ```python IS_LATEST = 'is_latest' ``` #### IS\_LOCKED ```python IS_LOCKED = 'is_locked' ``` #### KEY ```python KEY = 'key' ``` #### KIND ```python KIND = 'kind' ``` #### REFERENCE ```python REFERENCE = 'reference' ``` #### REFERENCE\_TYPE ```python REFERENCE_TYPE = 'reference_type' ``` #### SOURCE\_CODE ```python SOURCE_CODE = 'source_code' ``` #### UPDATED\_AT ```python UPDATED_AT = 'updated_at' ``` #### VERSION\_TAG ```python VERSION_TAG = 'version_tag' ``` #### BRANCH\_ID ```python BRANCH_ID = 'branch_id' ``` #### CREATED\_BY\_ID ```python CREATED_BY_ID = 'created_by_id' ``` #### CREATED\_ON\_ID ```python CREATED_ON_ID = 'created_on_id' ``` #### ENVIRONMENT\_ID ```python ENVIRONMENT_ID = 'environment_id' ``` #### PLAN\_ID ```python PLAN_ID = 'plan_id' ``` #### RUN\_ID ```python RUN_ID = 'run_id' ``` #### SPACE\_ID ```python SPACE_ID = 'space_id' ``` #### BRANCH ```python BRANCH = ('branch', LaminDBRegistry.BRANCH) ``` #### CREATED\_BY ```python CREATED_BY = ('created_by', LaminDBRegistry.USER) ``` #### CREATED\_ON ```python CREATED_ON = ('created_on', LaminDBRegistry.BRANCH) ``` #### ENVIRONMENT ```python ENVIRONMENT = ('environment', LaminDBRegistry.ARTIFACT) ``` #### PLAN ```python PLAN = ('plan', LaminDBRegistry.ARTIFACT) ``` #### RUN ```python RUN = ('run', LaminDBRegistry.RUN) ``` #### SPACE ```python SPACE = ('space', LaminDBRegistry.SPACE) ``` #### LINKED\_IN\_RECORDS ```python LINKED_IN_RECORDS = ('linked_in_records', LaminDBRegistry.RECORD) ``` #### PREDECESSORS ```python PREDECESSORS = ('predecessors', LaminDBRegistry.TRANSFORM) ``` #### PROJECTS ```python PROJECTS = ('projects', LaminDBRegistry.PROJECT) ``` #### RECORDS ```python RECORDS = ('records', LaminDBRegistry.RECORD) ``` #### REFERENCES ```python REFERENCES = ('references', LaminDBRegistry.REFERENCE) ``` #### RUNS ```python RUNS = ('runs', LaminDBRegistry.RUN) ``` #### SUCCESSORS ```python SUCCESSORS = ('successors', LaminDBRegistry.TRANSFORM) ``` #### ULABELS ```python ULABELS = ('ulabels', LaminDBRegistry.ULABEL) ``` ### RecordField Bases: `RegistryField` Fields of `core.record` (`LaminDBRegistry.RECORD`). #### ID ```python ID = 'id' ``` #### UID ```python UID = 'uid' ``` #### CREATED\_AT ```python CREATED_AT = 'created_at' ``` #### DESCRIPTION ```python DESCRIPTION = 'description' ``` #### EXTRA\_DATA ```python EXTRA_DATA = 'extra_data' ``` #### IS\_LOCKED ```python IS_LOCKED = 'is_locked' ``` #### IS\_TYPE ```python IS_TYPE = 'is_type' ``` #### NAME ```python NAME = 'name' ``` #### REFERENCE ```python REFERENCE = 'reference' ``` #### REFERENCE\_TYPE ```python REFERENCE_TYPE = 'reference_type' ``` #### UPDATED\_AT ```python UPDATED_AT = 'updated_at' ``` #### BRANCH\_ID ```python BRANCH_ID = 'branch_id' ``` #### CREATED\_BY\_ID ```python CREATED_BY_ID = 'created_by_id' ``` #### CREATED\_ON\_ID ```python CREATED_ON_ID = 'created_on_id' ``` #### RUN\_ID ```python RUN_ID = 'run_id' ``` #### SCHEMA\_ID ```python SCHEMA_ID = 'schema_id' ``` #### SPACE\_ID ```python SPACE_ID = 'space_id' ``` #### TYPE\_ID ```python TYPE_ID = 'type_id' ``` #### BRANCH ```python BRANCH = ('branch', LaminDBRegistry.BRANCH) ``` #### CREATED\_BY ```python CREATED_BY = ('created_by', LaminDBRegistry.USER) ``` #### CREATED\_ON ```python CREATED_ON = ('created_on', LaminDBRegistry.BRANCH) ``` #### RUN ```python RUN = ('run', LaminDBRegistry.RUN) ``` #### SCHEMA ```python SCHEMA = ('schema', LaminDBRegistry.SCHEMA) ``` #### SPACE ```python SPACE = ('space', LaminDBRegistry.SPACE) ``` #### TYPE ```python TYPE = ('type', LaminDBRegistry.RECORD) ``` #### ARTIFACTS ```python ARTIFACTS = ('artifacts', LaminDBRegistry.ARTIFACT) ``` #### CHILDREN ```python CHILDREN = ('children', LaminDBRegistry.RECORD) ``` #### COLLECTIONS ```python COLLECTIONS = ('collections', LaminDBRegistry.COLLECTION) ``` #### INPUT\_OF\_RUNS ```python INPUT_OF_RUNS = ('input_of_runs', LaminDBRegistry.RUN) ``` #### LINKED\_ARTIFACTS ```python LINKED_ARTIFACTS = ('linked_artifacts', LaminDBRegistry.ARTIFACT) ``` #### LINKED\_COLLECTIONS ```python LINKED_COLLECTIONS = ('linked_collections', LaminDBRegistry.COLLECTION) ``` #### LINKED\_IN\_RECORDS ```python LINKED_IN_RECORDS = ('linked_in_records', LaminDBRegistry.RECORD) ``` #### LINKED\_PROJECTS ```python LINKED_PROJECTS = ('linked_projects', LaminDBRegistry.PROJECT) ``` #### LINKED\_RECORDS ```python LINKED_RECORDS = ('linked_records', LaminDBRegistry.RECORD) ``` #### LINKED\_REFERENCES ```python LINKED_REFERENCES = ('linked_references', LaminDBRegistry.REFERENCE) ``` #### LINKED\_RUNS ```python LINKED_RUNS = ('linked_runs', LaminDBRegistry.RUN) ``` #### LINKED\_TRANSFORMS ```python LINKED_TRANSFORMS = ('linked_transforms', LaminDBRegistry.TRANSFORM) ``` #### LINKED\_ULABELS ```python LINKED_ULABELS = ('linked_ulabels', LaminDBRegistry.ULABEL) ``` #### LINKED\_USERS ```python LINKED_USERS = ('linked_users', LaminDBRegistry.USER) ``` #### PARENTS ```python PARENTS = ('parents', LaminDBRegistry.RECORD) ``` #### PROJECTS ```python PROJECTS = ('projects', LaminDBRegistry.PROJECT) ``` #### REFERENCES ```python REFERENCES = ('references', LaminDBRegistry.REFERENCE) ``` #### RUNS ```python RUNS = ('runs', LaminDBRegistry.RUN) ``` #### TRANSFORMS ```python TRANSFORMS = ('transforms', LaminDBRegistry.TRANSFORM) ``` ### ULabelField Bases: `RegistryField` Fields of `core.ulabel` (`LaminDBRegistry.ULABEL`). #### ID ```python ID = 'id' ``` #### UID ```python UID = 'uid' ``` #### CREATED\_AT ```python CREATED_AT = 'created_at' ``` #### DESCRIPTION ```python DESCRIPTION = 'description' ``` #### IS\_LOCKED ```python IS_LOCKED = 'is_locked' ``` #### IS\_TYPE ```python IS_TYPE = 'is_type' ``` #### NAME ```python NAME = 'name' ``` #### REFERENCE ```python REFERENCE = 'reference' ``` #### REFERENCE\_TYPE ```python REFERENCE_TYPE = 'reference_type' ``` #### UPDATED\_AT ```python UPDATED_AT = 'updated_at' ``` #### BRANCH\_ID ```python BRANCH_ID = 'branch_id' ``` #### CREATED\_BY\_ID ```python CREATED_BY_ID = 'created_by_id' ``` #### CREATED\_ON\_ID ```python CREATED_ON_ID = 'created_on_id' ``` #### RUN\_ID ```python RUN_ID = 'run_id' ``` #### SPACE\_ID ```python SPACE_ID = 'space_id' ``` #### TYPE\_ID ```python TYPE_ID = 'type_id' ``` #### BRANCH ```python BRANCH = ('branch', LaminDBRegistry.BRANCH) ``` #### CREATED\_BY ```python CREATED_BY = ('created_by', LaminDBRegistry.USER) ``` #### CREATED\_ON ```python CREATED_ON = ('created_on', LaminDBRegistry.BRANCH) ``` #### RUN ```python RUN = ('run', LaminDBRegistry.RUN) ``` #### SPACE ```python SPACE = ('space', LaminDBRegistry.SPACE) ``` #### TYPE ```python TYPE = ('type', LaminDBRegistry.ULABEL) ``` #### ARTIFACTS ```python ARTIFACTS = ('artifacts', LaminDBRegistry.ARTIFACT) ``` #### BRANCHES ```python BRANCHES = ('branches', LaminDBRegistry.BRANCH) ``` #### CHILDREN ```python CHILDREN = ('children', LaminDBRegistry.ULABEL) ``` #### COLLECTIONS ```python COLLECTIONS = ('collections', LaminDBRegistry.COLLECTION) ``` #### LINKED\_IN\_RECORDS ```python LINKED_IN_RECORDS = ('linked_in_records', LaminDBRegistry.RECORD) ``` #### PARENTS ```python PARENTS = ('parents', LaminDBRegistry.ULABEL) ``` #### PROJECTS ```python PROJECTS = ('projects', LaminDBRegistry.PROJECT) ``` #### RUNS ```python RUNS = ('runs', LaminDBRegistry.RUN) ``` #### TRANSFORMS ```python TRANSFORMS = ('transforms', LaminDBRegistry.TRANSFORM) ``` ### FeatureField Bases: `RegistryField` Fields of `core.feature` (`LaminDBRegistry.FEATURE`). #### ID ```python ID = 'id' ``` #### UID ```python UID = 'uid' ``` #### ARRAY\_RANK ```python ARRAY_RANK = 'array_rank' ``` #### ARRAY\_SHAPE ```python ARRAY_SHAPE = 'array_shape' ``` #### ARRAY\_SIZE ```python ARRAY_SIZE = 'array_size' ``` #### COERCE ```python COERCE = 'coerce' ``` #### CREATED\_AT ```python CREATED_AT = 'created_at' ``` #### DEFAULT\_VALUE ```python DEFAULT_VALUE = 'default_value' ``` #### DESCRIPTION ```python DESCRIPTION = 'description' ``` #### IS\_LOCKED ```python IS_LOCKED = 'is_locked' ``` #### IS\_TYPE ```python IS_TYPE = 'is_type' ``` #### NAME ```python NAME = 'name' ``` #### NULLABLE ```python NULLABLE = 'nullable' ``` #### SYNONYMS ```python SYNONYMS = 'synonyms' ``` #### UNIT ```python UNIT = 'unit' ``` #### UPDATED\_AT ```python UPDATED_AT = 'updated_at' ``` #### BRANCH\_ID ```python BRANCH_ID = 'branch_id' ``` #### CREATED\_BY\_ID ```python CREATED_BY_ID = 'created_by_id' ``` #### CREATED\_ON\_ID ```python CREATED_ON_ID = 'created_on_id' ``` #### RUN\_ID ```python RUN_ID = 'run_id' ``` #### SPACE\_ID ```python SPACE_ID = 'space_id' ``` #### TYPE\_ID ```python TYPE_ID = 'type_id' ``` #### BRANCH ```python BRANCH = ('branch', LaminDBRegistry.BRANCH) ``` #### CREATED\_BY ```python CREATED_BY = ('created_by', LaminDBRegistry.USER) ``` #### CREATED\_ON ```python CREATED_ON = ('created_on', LaminDBRegistry.BRANCH) ``` #### RUN ```python RUN = ('run', LaminDBRegistry.RUN) ``` #### SPACE ```python SPACE = ('space', LaminDBRegistry.SPACE) ``` #### TYPE ```python TYPE = ('type', LaminDBRegistry.FEATURE) ``` #### PROJECTS ```python PROJECTS = ('projects', LaminDBRegistry.PROJECT) ``` #### SCHEMAS ```python SCHEMAS = ('schemas', LaminDBRegistry.SCHEMA) ``` ### SchemaField Bases: `RegistryField` Fields of `core.schema` (`LaminDBRegistry.SCHEMA`). #### ID ```python ID = 'id' ``` #### UID ```python UID = 'uid' ``` #### COERCE ```python COERCE = 'coerce' ``` #### CREATED\_AT ```python CREATED_AT = 'created_at' ``` #### DESCRIPTION ```python DESCRIPTION = 'description' ``` #### FLEXIBLE ```python FLEXIBLE = 'flexible' ``` #### HASH ```python HASH = 'hash' ``` #### IS\_LOCKED ```python IS_LOCKED = 'is_locked' ``` #### IS\_TYPE ```python IS_TYPE = 'is_type' ``` #### ITYPE ```python ITYPE = 'itype' ``` #### MAXIMAL\_SET ```python MAXIMAL_SET = 'maximal_set' ``` #### MINIMAL\_SET ```python MINIMAL_SET = 'minimal_set' ``` #### N\_MEMBERS ```python N_MEMBERS = 'n_members' ``` #### NAME ```python NAME = 'name' ``` #### ORDERED\_SET ```python ORDERED_SET = 'ordered_set' ``` #### OTYPE ```python OTYPE = 'otype' ``` #### SUFFIX ```python SUFFIX = 'suffix' ``` #### UPDATED\_AT ```python UPDATED_AT = 'updated_at' ``` #### BRANCH\_ID ```python BRANCH_ID = 'branch_id' ``` #### CREATED\_BY\_ID ```python CREATED_BY_ID = 'created_by_id' ``` #### CREATED\_ON\_ID ```python CREATED_ON_ID = 'created_on_id' ``` #### RUN\_ID ```python RUN_ID = 'run_id' ``` #### SPACE\_ID ```python SPACE_ID = 'space_id' ``` #### TYPE\_ID ```python TYPE_ID = 'type_id' ``` #### BRANCH ```python BRANCH = ('branch', LaminDBRegistry.BRANCH) ``` #### CREATED\_BY ```python CREATED_BY = ('created_by', LaminDBRegistry.USER) ``` #### CREATED\_ON ```python CREATED_ON = ('created_on', LaminDBRegistry.BRANCH) ``` #### RUN ```python RUN = ('run', LaminDBRegistry.RUN) ``` #### SPACE ```python SPACE = ('space', LaminDBRegistry.SPACE) ``` #### TYPE ```python TYPE = ('type', LaminDBRegistry.SCHEMA) ``` #### ARTIFACTS ```python ARTIFACTS = ('artifacts', LaminDBRegistry.ARTIFACT) ``` #### COMPONENTS ```python COMPONENTS = ('components', LaminDBRegistry.SCHEMA) ``` #### COMPOSITES ```python COMPOSITES = ('composites', LaminDBRegistry.SCHEMA) ``` #### FEATURES ```python FEATURES = ('features', LaminDBRegistry.FEATURE) ``` #### PROJECTS ```python PROJECTS = ('projects', LaminDBRegistry.PROJECT) ``` #### RECORDS ```python RECORDS = ('records', LaminDBRegistry.RECORD) ``` #### VALIDATED\_ARTIFACTS ```python VALIDATED_ARTIFACTS = ('validated_artifacts', LaminDBRegistry.ARTIFACT) ``` #### VALIDATED\_COLLECTIONS ```python VALIDATED_COLLECTIONS = ('validated_collections', LaminDBRegistry.COLLECTION) ``` ### ProjectField Bases: `RegistryField` Fields of `core.project` (`LaminDBRegistry.PROJECT`). #### ID ```python ID = 'id' ``` #### UID ```python UID = 'uid' ``` #### ABBR ```python ABBR = 'abbr' ``` #### CREATED\_AT ```python CREATED_AT = 'created_at' ``` #### DESCRIPTION ```python DESCRIPTION = 'description' ``` #### END\_DATE ```python END_DATE = 'end_date' ``` #### IS\_LOCKED ```python IS_LOCKED = 'is_locked' ``` #### IS\_TYPE ```python IS_TYPE = 'is_type' ``` #### NAME ```python NAME = 'name' ``` #### START\_DATE ```python START_DATE = 'start_date' ``` #### UPDATED\_AT ```python UPDATED_AT = 'updated_at' ``` #### URL ```python URL = 'url' ``` #### BRANCH\_ID ```python BRANCH_ID = 'branch_id' ``` #### CREATED\_BY\_ID ```python CREATED_BY_ID = 'created_by_id' ``` #### CREATED\_ON\_ID ```python CREATED_ON_ID = 'created_on_id' ``` #### RUN\_ID ```python RUN_ID = 'run_id' ``` #### SPACE\_ID ```python SPACE_ID = 'space_id' ``` #### TYPE\_ID ```python TYPE_ID = 'type_id' ``` #### BRANCH ```python BRANCH = ('branch', LaminDBRegistry.BRANCH) ``` #### CREATED\_BY ```python CREATED_BY = ('created_by', LaminDBRegistry.USER) ``` #### CREATED\_ON ```python CREATED_ON = ('created_on', LaminDBRegistry.BRANCH) ``` #### RUN ```python RUN = ('run', LaminDBRegistry.RUN) ``` #### SPACE ```python SPACE = ('space', LaminDBRegistry.SPACE) ``` #### TYPE ```python TYPE = ('type', LaminDBRegistry.PROJECT) ``` #### ARTIFACTS ```python ARTIFACTS = ('artifacts', LaminDBRegistry.ARTIFACT) ``` #### BRANCHES ```python BRANCHES = ('branches', LaminDBRegistry.BRANCH) ``` #### CHILDREN ```python CHILDREN = ('children', LaminDBRegistry.PROJECT) ``` #### COLLECTIONS ```python COLLECTIONS = ('collections', LaminDBRegistry.COLLECTION) ``` #### FEATURES ```python FEATURES = ('features', LaminDBRegistry.FEATURE) ``` #### LINKED\_IN\_RECORDS ```python LINKED_IN_RECORDS = ('linked_in_records', LaminDBRegistry.RECORD) ``` #### PARENTS ```python PARENTS = ('parents', LaminDBRegistry.PROJECT) ``` #### PREDECESSORS ```python PREDECESSORS = ('predecessors', LaminDBRegistry.PROJECT) ``` #### RECORDS ```python RECORDS = ('records', LaminDBRegistry.RECORD) ``` #### REFERENCES ```python REFERENCES = ('references', LaminDBRegistry.REFERENCE) ``` #### RUNS ```python RUNS = ('runs', LaminDBRegistry.RUN) ``` #### SCHEMAS ```python SCHEMAS = ('schemas', LaminDBRegistry.SCHEMA) ``` #### SUCCESSORS ```python SUCCESSORS = ('successors', LaminDBRegistry.PROJECT) ``` #### TRANSFORMS ```python TRANSFORMS = ('transforms', LaminDBRegistry.TRANSFORM) ``` #### ULABELS ```python ULABELS = ('ulabels', LaminDBRegistry.ULABEL) ``` #### USERS ```python USERS = ('users', LaminDBRegistry.USER) ``` ### ReferenceField Bases: `RegistryField` Fields of `core.reference` (`LaminDBRegistry.REFERENCE`). #### ID ```python ID = 'id' ``` #### UID ```python UID = 'uid' ``` #### ABBR ```python ABBR = 'abbr' ``` #### CREATED\_AT ```python CREATED_AT = 'created_at' ``` #### DATE ```python DATE = 'date' ``` #### DESCRIPTION ```python DESCRIPTION = 'description' ``` #### DOI ```python DOI = 'doi' ``` #### IS\_LOCKED ```python IS_LOCKED = 'is_locked' ``` #### IS\_TYPE ```python IS_TYPE = 'is_type' ``` #### NAME ```python NAME = 'name' ``` #### PUBMED\_ID ```python PUBMED_ID = 'pubmed_id' ``` #### TEXT ```python TEXT = 'text' ``` #### UPDATED\_AT ```python UPDATED_AT = 'updated_at' ``` #### URL ```python URL = 'url' ``` #### BRANCH\_ID ```python BRANCH_ID = 'branch_id' ``` #### CREATED\_BY\_ID ```python CREATED_BY_ID = 'created_by_id' ``` #### CREATED\_ON\_ID ```python CREATED_ON_ID = 'created_on_id' ``` #### RUN\_ID ```python RUN_ID = 'run_id' ``` #### SPACE\_ID ```python SPACE_ID = 'space_id' ``` #### TYPE\_ID ```python TYPE_ID = 'type_id' ``` #### BRANCH ```python BRANCH = ('branch', LaminDBRegistry.BRANCH) ``` #### CREATED\_BY ```python CREATED_BY = ('created_by', LaminDBRegistry.USER) ``` #### CREATED\_ON ```python CREATED_ON = ('created_on', LaminDBRegistry.BRANCH) ``` #### RUN ```python RUN = ('run', LaminDBRegistry.RUN) ``` #### SPACE ```python SPACE = ('space', LaminDBRegistry.SPACE) ``` #### TYPE ```python TYPE = ('type', LaminDBRegistry.REFERENCE) ``` #### ARTIFACTS ```python ARTIFACTS = ('artifacts', LaminDBRegistry.ARTIFACT) ``` #### COLLECTIONS ```python COLLECTIONS = ('collections', LaminDBRegistry.COLLECTION) ``` #### LINKED\_IN\_RECORDS ```python LINKED_IN_RECORDS = ('linked_in_records', LaminDBRegistry.RECORD) ``` #### PROJECTS ```python PROJECTS = ('projects', LaminDBRegistry.PROJECT) ``` #### RECORDS ```python RECORDS = ('records', LaminDBRegistry.RECORD) ``` #### TRANSFORMS ```python TRANSFORMS = ('transforms', LaminDBRegistry.TRANSFORM) ``` ### StorageField Bases: `RegistryField` Fields of `core.storage` (`LaminDBRegistry.STORAGE`). #### ID ```python ID = 'id' ``` #### UID ```python UID = 'uid' ``` #### CREATED\_AT ```python CREATED_AT = 'created_at' ``` #### DESCRIPTION ```python DESCRIPTION = 'description' ``` #### INSTANCE\_UID ```python INSTANCE_UID = 'instance_uid' ``` #### IS\_LOCKED ```python IS_LOCKED = 'is_locked' ``` #### REGION ```python REGION = 'region' ``` #### ROOT ```python ROOT = 'root' ``` #### TYPE ```python TYPE = 'type' ``` #### UPDATED\_AT ```python UPDATED_AT = 'updated_at' ``` #### BRANCH\_ID ```python BRANCH_ID = 'branch_id' ``` #### CREATED\_BY\_ID ```python CREATED_BY_ID = 'created_by_id' ``` #### CREATED\_ON\_ID ```python CREATED_ON_ID = 'created_on_id' ``` #### RUN\_ID ```python RUN_ID = 'run_id' ``` #### SPACE\_ID ```python SPACE_ID = 'space_id' ``` #### BRANCH ```python BRANCH = ('branch', LaminDBRegistry.BRANCH) ``` #### CREATED\_BY ```python CREATED_BY = ('created_by', LaminDBRegistry.USER) ``` #### CREATED\_ON ```python CREATED_ON = ('created_on', LaminDBRegistry.BRANCH) ``` #### RUN ```python RUN = ('run', LaminDBRegistry.RUN) ``` #### SPACE ```python SPACE = ('space', LaminDBRegistry.SPACE) ``` #### ARTIFACTS ```python ARTIFACTS = ('artifacts', LaminDBRegistry.ARTIFACT) ``` ### BranchField Bases: `RegistryField` Fields of `core.branch` (`LaminDBRegistry.BRANCH`). #### ID ```python ID = 'id' ``` #### UID ```python UID = 'uid' ``` #### CREATED\_AT ```python CREATED_AT = 'created_at' ``` #### DESCRIPTION ```python DESCRIPTION = 'description' ``` #### NAME ```python NAME = 'name' ``` #### CREATED\_BY\_ID ```python CREATED_BY_ID = 'created_by_id' ``` #### SPACE\_ID ```python SPACE_ID = 'space_id' ``` #### CREATED\_BY ```python CREATED_BY = ('created_by', LaminDBRegistry.USER) ``` #### SPACE ```python SPACE = ('space', LaminDBRegistry.SPACE) ``` #### PROJECTS ```python PROJECTS = ('projects', LaminDBRegistry.PROJECT) ``` #### ULABELS ```python ULABELS = ('ulabels', LaminDBRegistry.ULABEL) ``` #### USERS ```python USERS = ('users', LaminDBRegistry.USER) ``` ### SpaceField Bases: `RegistryField` Fields of `core.space` (`LaminDBRegistry.SPACE`). #### ID ```python ID = 'id' ``` #### UID ```python UID = 'uid' ``` #### CREATED\_AT ```python CREATED_AT = 'created_at' ``` #### DESCRIPTION ```python DESCRIPTION = 'description' ``` #### NAME ```python NAME = 'name' ``` #### CREATED\_BY\_ID ```python CREATED_BY_ID = 'created_by_id' ``` #### CREATED\_BY ```python CREATED_BY = ('created_by', LaminDBRegistry.USER) ``` ### UserField Bases: `RegistryField` Fields of `core.user` (`LaminDBRegistry.USER`). #### ID ```python ID = 'id' ``` #### UID ```python UID = 'uid' ``` #### CREATED\_AT ```python CREATED_AT = 'created_at' ``` #### HANDLE ```python HANDLE = 'handle' ``` #### NAME ```python NAME = 'name' ``` #### UPDATED\_AT ```python UPDATED_AT = 'updated_at' ``` #### ARTIFACTS ```python ARTIFACTS = ('artifacts', LaminDBRegistry.ARTIFACT) ``` #### BRANCHES ```python BRANCHES = ('branches', LaminDBRegistry.BRANCH) ``` #### CREATED\_ARTIFACTS ```python CREATED_ARTIFACTS = ('created_artifacts', LaminDBRegistry.ARTIFACT) ``` #### CREATED\_RUNS ```python CREATED_RUNS = ('created_runs', LaminDBRegistry.RUN) ``` #### CREATED\_TRANSFORMS ```python CREATED_TRANSFORMS = ('created_transforms', LaminDBRegistry.TRANSFORM) ``` #### LINKED\_IN\_RECORDS ```python LINKED_IN_RECORDS = ('linked_in_records', LaminDBRegistry.RECORD) ``` #### PROJECTS ```python PROJECTS = ('projects', LaminDBRegistry.PROJECT) ``` ## airflow.providers.lamindb.exceptions ### LaminDBApiError ```python LaminDBApiError( message: str, *, http_status_code: int | None = None, detail: Any = None, transient: bool = False, ) ``` Bases: `AirflowException` Raised when the LaminHub REST API returns an error response. `transient` is true when the request may succeed if repeated later: network errors, rate limiting (429) and server errors (5xx). ### LaminDBVersionError Bases: `AirflowFailException`, `ValueError` Raised for lamindb older than the provider supports; tasks fail without retries.