## lamindb.Run

| class lamindb.Run(transform: Transform, name: str | None = None, description: str | None = None, entrypoint: str | None = None, params: dict | None = None, reference: str | None = None, reference_type: str | None = None, initiated_by_run: Run | None = None, plan: Artifact | None = None) |
class lamindb.Run(*db_args)

 Bases: "SQLRecord", "TracksUpdates"

 Runs of transforms such as the executions of a script.

 Parameters:
 * **transform** -- "Transform" A data transformation object.

| * **name** -- "str | None = None" A name. |

| * **params** -- "dict | None = None" A dictionary of parameters. |

| * **reference** -- "str | None = None" For instance, an external |
 ID or URL.

| * **reference_type** -- "str | None = None" For instance, |
 "redun_id", "nextflow_id" or "url".

| * **initiated_by_run** -- "Run | None = None" The "run" that |
 triggers this "run".

 See also:

 "track()"
 Globally track a script or notebook run.

 "step()"
 Track a function executionwith this decorator.

 -[ Examples ]-

 Create a run record:

 ln.Transform(key="Cell Ranger", version="7.2.0", kind="pipeline").save()
 transform = ln.Transform.get(key="Cell Ranger", version="7.2.0")
 run = ln.Run(transform)

 Track a global run of a notebook or script:

 ln.track()
 ln.context.run  # global run object

 You can pass parameters to "Run(transform, params=params)" or add
 them later:

 run.params = {
 "learning_rate": 0.01,
 "input_dir": "s3://my-bucket/mydataset",
 "downsample": True,
 "preprocess_params": {
 "normalization_type": "cool",
 "subset_highlyvariable": True,
 },
 }
 run.save()

 In contrast to ".params", features are indexed in the "Feature"
 registry and can reference relational categorical values. If you
 want to link feature values, use:

 run.features.set_values({
 "experiment": "My experiment 1",
 })

 Guide: Track parameters & features

 property status: Literal['scheduled', 'restarted', 'started', 'completed', 'errored', 'aborted']

 Run status.

 Get the status of the run:

| --- | --- | --- |
| status | code | description |
| ============= | ======= | ============================= |
| "scheduled" | -3 | run is scheduled |
| --- | --- | --- |
| "restarted" | -2 | run was restarted |
| --- | --- | --- |
| "started" | -1 | run has started |
| --- | --- | --- |
| "completed" | 0 | run completed successfully |
| --- | --- | --- |
| "errored" | 1 | run ended with an error |
| --- | --- | --- |
| "aborted" | 2 | run was aborted |
| --- | --- | --- |

 The database stores the run status as an integer code in field
 "_status_code".

 -[ Example ]-

 See the status of a run:

 run.status
 #> 'completed'

 Query by status:

 ln.Run.filter(status="completed").to_dataframe()

 property features: FeatureManager

 Manage annotations with features.

 For examples, see "Run" or "FeatureManager".

 uid: str

 Universal id, valid across DB instances.

| name: str | None |

 An optional name for this run.

| description: str | None |

 An optional description for this run.

| entrypoint: str | None |

 The entrypoint of the transform.

 This could be a function name or the entry point of a CLI or
 workflow manager.

 started_at: datetime

 The time this run started.

| finished_at: datetime | None |

 The time this run finished or aborted.

 params: dict

 Parameters (plain JSON values).

| reference: str | None |

 A reference like a URL or an external ID such as from a workflow
 manager.

| reference_type: str | None |

 The type of the "reference" such as a workflow manager execution
 ID.

| cli_args: str | None |

 CLI arguments if the run was invoked from the command line.

 created_at: datetime

 The time of creation of this run.

 transform: Transform

 The transform that is being run ← "runs".

| report: Artifact | None |

 The report of this run such as an ".html" or ".txt" file.

| environment: Artifact | None |

 The computational environment for this run.

 For instance, "Dockerfile", "docker image", "requirements.txt",
 "environment.yml", etc.

| plan: Artifact | None |

 The (agent) plan for this run.

 Also see: "initiated_by_run".

 created_by: User

 The creator of this run ← "created_runs".

| initiated_by_run: Run | None |

 The run that initiated this run ← "initiated_runs".

 json_values: RelatedManager[JsonValue]

 Feature-indexed JSON values ← "runs".

 ulabels: RelatedManager[ULabel]

 The ulabels annotating this run ← "runs".

 linked_in_records: RelatedManager[Record]

 This run is linked in these records as a value ← "linked_runs".

 artifacts: RelatedManager[Artifact]

 The artifacts annotated by this run ← "runs".

 linked_artifacts: RelatedManager[Artifact]

 The artifacts linked by this run through the run's features ←
 "artifact".

 initiated_runs: RelatedManager[Run]

 The runs that were initiated by this run.

 values_artifact

 output_artifacts: RelatedManager[Artifact]

 The artifacts created in this run ← "run".

 This does **not** include recreated artifacts, which are tracked
 via "recreated_artifacts".

 If you want to query created + recreated artifacts, use
 "query_output_artifacts()" instead.

 input_artifacts: RelatedManager[Artifact]

 The artifacts serving as input for this run ← "input_of_runs".

 recreated_artifacts: RelatedManager[Artifact]

 The output artifacts that were recreated by this run ←
 "recreating_runs".

 Artifacts are *recreated* if they trigger a hash lookup match
 for an existing artifact.

 output_collections: RelatedManager[Collection]

 The collections created in this run ← "run".

 input_collections: RelatedManager[Collection]

 The collections serving as input for this run ← "input_of_runs".

 recreated_collections: RelatedManager[Collection]

 The output collections that were recreated by this run ←
 "recreating_runs".

 Collections are *recreated* if they trigger a hash lookup match
 for an existing collection.

 output_records: RelatedManager[Record]

 The collections created in this run ← "run".

 input_records: RelatedManager[Record]

 The collections serving as input for this run ← "input_of_runs".

 records: RelatedManager[Record]

 The records annotating this run ← "runs".

 projects: RelatedManager[Project]

 The projects annotating this run ← "runs".

 ablocks: RelatedManager[RunBlock]

 Attached blocks ← "run".

 filter(**expressions)

 Query records.

 Parameters:
 * **queries** -- One or multiple "Q" objects.

 * **expressions** -- Fields and values passed as Django query
 expressions.

 Return type:
 "QuerySet"

 See also:

 * Guide: Query & search registries

 * Django documentation: Queries

 -[ Examples ]-

 >>> ln.Project(name="my label").save()
 >>> ln.Project.filter(name__startswith="my").to_dataframe()

 query_output_artifacts(include_recreated=True)

 Query output artifacts including recreated ones.

 This runs the following query under the hood:

| ln.Artifact.filter(ln.Q(run=self) | ln.Q(recreating_runs=self)).distinct() |

 Parameters:
 **include_recreated** ("bool", default: "True") -- If "True",
 return both originally created and recreated artifacts. If
 "False", return only originally created artifacts.

 Return type:
 "QuerySet"

 Returns:
 A queryset of "Artifact" objects.

 See also:

 "output_artifacts"
 "QuerySet" of originally created artifacts.

 "recreated_artifacts"
 "QuerySet" of recreated artifacts.