...
```
```shell
# Delete all plugins from local disk
fiftyone plugins delete --all
```
## Configuring plugins
Certain plugins support configuration. For those plugins, you can store:
- System-wide plugin settings under the `plugins` key of your
[App config](../user_guide/config.md#configuring-fiftyone-app)
- Dataset-specific plugin settings for any subset of the above values on a
[dataset’s App config](../user_guide/using_datasets.md#dataset-app-config).
See the [configuring plugins](../user_guide/config.md#configuring-plugins) page for more
information.
## Plugin secrets
Some plugins may require sensitive information such as API tokens and login
credentials in order to function. Any secrets that a plugin requires are
documented under the `secrets` key of its `fiftyone.yml` file.
For example, the
[@voxel51/annotation](https://github.com/voxel51/fiftyone-plugins/blob/main/plugins/annotation/fiftyone.yml)
plugin declares the following secrets:
```yaml
secrets:
- FIFTYONE_CVAT_URL
- FIFTYONE_CVAT_USERNAME
- FIFTYONE_CVAT_PASSWORD
- FIFTYONE_CVAT_EMAIL
- FIFTYONE_LABELBOX_URL
- FIFTYONE_LABELBOX_API_KEY
- FIFTYONE_LABELSTUDIO_URL
- FIFTYONE_LABELSTUDIO_API_KEY
```
#### NOTE
You can use the [fiftyone plugins info](../cli/index.md#cli-fiftyone-plugins-info)
CLI command to print information about a plugin, including its required
secrets.
As the naming convention implies, any necessary secrets are provided by setting
environment variables with the appropriate names. For example, if you want to
use the CVAT backend with the
[@voxel51/annotation](https://github.com/voxel51/fiftyone-plugins/blob/main/plugins/annotation/fiftyone.yml)
plugin, you would set:
```shell
FIFTYONE_CVAT_URL=...
FIFTYONE_CVAT_USERNAME=...
FIFTYONE_CVAT_PASSWORD=...
FIFTYONE_CVAT_EMAIL=...
```
At runtime, the plugin’s execution context will automatically be hydrated with
any available secrets that are declared by the plugin. Operators access these
secrets via the `ctx.secrets` dict:
```python
def execute(self, ctx):
url = ctx.secrets["FIFTYONE_CVAT_URL"]
username = ctx.secrets["FIFTYONE_CVAT_USERNAME"]
password = ctx.secrets["FIFTYONE_CVAT_PASSWORD"]
email = ctx.secrets["FIFTYONE_CVAT_EMAIL"]
```
## Using panels
Panels are miniature full-featured data applications that you can open in
[App Spaces](../user_guide/app.md#app-spaces) and interactively manipulate to explore your
dataset and update/respond to updates from other spaces that are currently open
in the App.
FiftyOne natively includes the following Panels:
- [Samples panel](../user_guide/app.md#app-samples-panel): the media grid that loads by
default when you launch the App
- [Histograms panel](../user_guide/app.md#app-histograms-panel): a dashboard of histograms
for the fields of your dataset
- [Embeddings panel](../user_guide/app.md#app-embeddings-panel): a canvas for working with
[embeddings visualizations](../brain/index.md#brain-embeddings-visualization)
- [Map panel](../user_guide/app.md#app-map-panel): visualizes the geolocation data of
datasets that have a [`GeoLocation`](../api/fiftyone.core.labels.md#fiftyone.core.labels.GeoLocation) field
Any plugins that you’ve installed may expose additional panels too.
Click the `+` icon next to the “Samples” tab to open a new panel:
#### NOTE
Did you know? You can also programmatically configure spaces
[in Python](../user_guide/app.md#app-spaces-python).
## Using operators
Available in:
Open SourceEnterprise
Operators are a powerful feature in FiftyOne that allow plugin developers to
define custom operations that can be executed from within the App.
Some operators may expose themselves as custom buttons, icons, or menu items
throughout the App. However, the Operator Browser allows users to search
through all available (enabled) operators.
You can open the Operator Browser by clicking on the Operator Browser icon
above the sample grid or by typing backtick (```):
Operators provide dynamic input forms that collect the necessary user inputs.
The actual operation is then performed by pressing the `Execute`/`Schedule`
button at the bottom of the form.
Some Operators perform an immediate action when executed, while other Operators
[delegate](#delegated-operations) their execution to another process.
## Executing operators via SDK
Available in:
Open SourceEnterprise
Many operators are intended to be executed programmatically via the SDK rather
than (or in addition to) executing them by filling out their input form in the
App.
### Calling operators
By convention, operators that are intended to be executed programmatically
should implement `__call__()` so that users have a well-documented interface
for invoking the operator as a function.
For example, the
[@voxel51/utils/compute_metadata](https://github.com/voxel51/fiftyone-plugins/tree/main/plugins/utils)
operator can be invoked like so:
```python
import fiftyone as fo
import fiftyone.operators as foo
import fiftyone.zoo as foz
dataset = foz.load_zoo_dataset("quickstart")
compute_metadata = foo.get_operator("@voxel51/utils/compute_metadata")
# (Re)compute the dataset's metadata
compute_metadata(dataset, overwrite=True)
```
#### NOTE
Notice that [`get_operator()`](../api/fiftyone.operators.md#fiftyone.operators.get_operator) is
used to retrieve the operator by its URI.
Behind the scenes, the operator’s `__call__()` method is implemented as
follows:
```python
class ComputeMetadata(foo.Operator):
def __call__(
self,
sample_collection,
overwrite=False,
num_workers=None,
):
ctx = dict(view=sample_collection.view())
params = dict(
overwrite=overwrite,
num_workers=num_workers,
)
return foo.execute_operator(self.uri, ctx, params=params)
```
which simply packages up the provided keyword arguments into the correct format
for the operator’s `ctx.params` and then passes them to
[`execute_operator()`](../api/fiftyone.operators.md#fiftyone.operators.execute_operator), which
performs the execution.
For operators whose
[`execute()`](../api/fiftyone.operators.operator.md#fiftyone.operators.operator.Operator.execute) method returns
data, you can access it via the `result` property of the returned
[`ExecutionResult`](../api/fiftyone.operators.executor.md#fiftyone.operators.executor.ExecutionResult) object:
```python
op = foo.get_operator("@an-operator/with-results")
result = op(...)
print(result.result) # {...}
```
#### NOTE
When working in notebook contexts, executing operators returns an
`asyncio.Task` that you can `await` to retrieve the
[`ExecutionResult`](../api/fiftyone.operators.executor.md#fiftyone.operators.executor.ExecutionResult):
```python
op = foo.get_operator("@an-operator/with-results")
result = await op(...)
print(result.result) # {...}
```
#### Requesting delegation
Operators that support [delegated execution](#delegated-operations) can
support this via the `__call__()` syntax by passing the
`request_delegation=True` flag to
[`execute_operator()`](../api/fiftyone.operators.md#fiftyone.operators.execute_operator).
In fact, the
[@voxel51/utils/compute_metadata](https://github.com/voxel51/fiftyone-plugins/tree/main/plugins/utils)
operator does just that:
```python
class ComputeMetadata(foo.Operator):
return foo.OperatorConfig(
...
allow_immediate_execution=True,
allow_delegated_execution=True,
)
def __call__(
self,
sample_collection,
overwrite=False,
num_workers=None,
delegate=False,
):
ctx = dict(view=sample_collection.view())
params = dict(
overwrite=overwrite,
num_workers=num_workers,
)
return foo.execute_operator(
self.uri,
ctx,
params=params,
request_delegation=delegate,
)
```
which means that it can be invoked like so:
```python
compute_metadata = foo.get_operator("@voxel51/utils/compute_metadata")
# Schedule a delegated operation to (re)compute metadata
compute_metadata(dataset, overwrite=True, delegate=True)
```
### Direct execution
You can programmatically execute any operator by directly calling
[`execute_operator()`](../api/fiftyone.operators.md#fiftyone.operators.execute_operator):
```python
import fiftyone as fo
import fiftyone.operators as foo
import fiftyone.zoo as foz
dataset = foz.load_zoo_dataset("quickstart")
ctx = {
"view": dataset.take(10),
"params": dict(
export_type="LABELS_ONLY",
dataset_type="COCO",
labels_path=dict(absolute_path="/tmp/coco/labels.json"),
label_field="ground_truth",
)
}
foo.execute_operator("@voxel51/io/export_samples", ctx)
```
#### NOTE
In general, to use
[`execute_operator()`](../api/fiftyone.operators.md#fiftyone.operators.execute_operator) you must
inspect the operator’s
[`execute()`](../api/fiftyone.operators.operator.md#fiftyone.operators.operator.Operator.execute)
implementation to understand what parameters are required.
For operators whose
[`execute()`](../api/fiftyone.operators.operator.md#fiftyone.operators.operator.Operator.execute) method returns
data, you can access it via the `result` property of the returned
[`ExecutionResult`](../api/fiftyone.operators.executor.md#fiftyone.operators.executor.ExecutionResult) object:
```python
result = foo.execute_operator("@an-operator/with-results", ctx)
print(result.result) # {...}
```
#### NOTE
When working in notebook contexts, executing operators returns an
`asyncio.Task` that you can `await` to retrieve the
[`ExecutionResult`](../api/fiftyone.operators.executor.md#fiftyone.operators.executor.ExecutionResult):
```python
result = await foo.execute_operator("@an-operator/with-results", ctx)
print(result.result) # {...}
```
#### Requesting delegation
If an operation supports both immediate and
[delegated execution](#delegated-operations) as specified by its
[execution options](developing_plugins.md#operator-execution-options), you can request
delegated execution by passing the `request_delegation=True` flag to
[`execute_operator()`](../api/fiftyone.operators.md#fiftyone.operators.execute_operator):
```python
foo.execute_operator(operator_uri, ctx=ctx, request_delegation=True)
```
This has the same effect as choosing `Schedule` from the dropdown in the
operator’s input modal when executing it from within the App:
#### NOTE
[FiftyOne Enterprise](../enterprise/index.md#fiftyone-enterprise) users can also specify an optional
delegation target for their delegated operations:
```python
foo.execute_operator(
operator_uri,
ctx=ctx,
request_delegation=True,
delegation_target="overnight",
)
```
### Delegating function calls
Available in:
Open SourceEnterprise
The
[@voxel51/utils/delegate](https://github.com/voxel51/fiftyone-plugins/tree/main/plugins/utils)
operator provides a general purpose utility for
[delegating execution](#delegated-operations) of an arbitrary function
call that can be expressed in any of the following forms:
- Execute an arbitrary function: `fcn(*args, **kwargs)`
- Apply a function to a dataset or view:
`fcn(dataset_or_view, *args, **kwargs)`
- Call an instance method of a dataset or view:
`dataset_or_view.fcn(*args, **kwargs)`
Here’s some examples of delegating common tasks that can be expressed in the
above forms:
```python
import fiftyone as fo
import fiftyone.operators as foo
import fiftyone.zoo as foz
dataset = foz.load_zoo_dataset("quickstart")
delegate = foo.get_operator("@voxel51/utils/delegate")
# Compute metadata
delegate("compute_metadata", dataset=dataset)
# Compute visualization
delegate(
"fiftyone.brain.compute_visualization",
dataset=dataset,
brain_key="img_viz",
)
# Export a view
delegate(
"export",
view=dataset.to_patches("ground_truth"),
export_dir="/tmp/patches",
dataset_type="fiftyone.types.ImageClassificationDirectoryTree",
label_field="ground_truth",
)
# Load the exported patches into a new dataset
delegate(
"fiftyone.Dataset.from_dir",
dataset_dir="/tmp/patches",
dataset_type="fiftyone.types.ImageClassificationDirectoryTree",
label_field="ground_truth",
name="patches",
persistent=True,
)
```
## Delegated operations
Delegated operations are a powerful feature of FiftyOne’s plugin framework that
allows you to schedule potentially long-running tasks from within the App that
are executed in the background while you continue to work.
#### NOTE
[FiftyOne Enterprise](../enterprise/plugins.md#enterprise-delegated-operations) deployments
come out of the box with a connected compute cluster for executing
delegated operations at scale.
In FiftyOne Open Source, you can use delegated operations at small scale
by [running them locally](#delegated-orchestrator-open-source).
For example, have model predictions on your dataset that you want to evaluate?
The [@voxel51/evaluation](https://github.com/voxel51/fiftyone-plugins/blob/main/plugins/evaluation/README.md)
plugin makes it easy:
Need to compute embedding for your dataset so you can visualize them in the
[Embeddings panel](../user_guide/app.md#app-embeddings-panel)? Kick off the task with the
[@voxel51/brain](https://github.com/voxel51/fiftyone-plugins/blob/main/plugins/brain/README.md)
plugin and proceed with other work while the execution happens in the background:
Why is this awesome? Your AI stack needs a flexible data-centric component that
enables you to organize and compute on your data. With delegated operations,
FiftyOne becomes both a dataset management/visualization tool and a workflow
automation tool that defines how your data-centric workflows like ingestion,
curation, and evaluation are performed.
#### NOTE
Want to run delegated operations at scale?
[Contact us](https://voxel51.com/talk-to-sales) about
[FiftyOne Enterprise](../enterprise/index.md#fiftyone-enterprise), an open source-compatible
enterprise deployment of FiftyOne with multiuser collaboration features,
native cloud dataset support, and much more!
Think of FiftyOne Enterprise as the single source of truth on which you
co-develop your data and models together 📈
## Setting up an orchestrator
Available in:
Open SourceEnterprise
### FiftyOne Open Source
FiftyOne Open Source users can run delegated operations via the
[fiftyone delegated launch](../cli/index.md#cli-fiftyone-delegated-launch) CLI command:
```shell
fiftyone delegated launch
```
This command starts a service that will continuously check for any queued
delegated operations and execute them serially in its process.
You must also ensure that the
[allow_legacy_orchestrators](../user_guide/config.md#configuring-fiftyone) config flag is set
in the environment where you run the App/SDK, e.g. by setting:
```shell
export FIFTYONE_ALLOW_LEGACY_ORCHESTRATORS=true
```
### FiftyOne Enterprise
[FiftyOne Enterprise](../enterprise/plugins.md#enterprise-delegated-operations) deployments come
out of the box with a connected compute cluster for executing delegated
operations at scale. They can also be connected to your own compute solution,
such as Databricks or Anyscale.
This powerful feature allows users to install/build plugins that execute
potentially long-running tasks in the background while users continue with
other work in the App.
#### NOTE
Want to take advantage of this functionality?
[Contact us](https://voxel51.com/talk-to-sales) about
[FiftyOne Enterprise](../enterprise/index.md#fiftyone-enterprise), an open source-compatible
enterprise deployment of FiftyOne with multiuser collaboration features,
native cloud dataset support, and much more!
Think of FiftyOne Enterprise as the single source of truth on which you
co-develop your data and models together 📈
## Managing delegated operations
The [fiftyone delegated](../cli/index.md#cli-fiftyone-delegated) CLI command contains a
number of useful utilities for viewing the status of your delegated operations.
### Listing delegated operations
You can use the [fiftyone delegated list](../cli/index.md#cli-fiftyone-delegated-list)
command to list the delegated operations that you’ve run:
```shell
# List all delegated operations
fiftyone delegated list
```
```shell
# List some specific delegated operations
fiftyone delegated list \
--dataset quickstart \
--operator @voxel51/io/export_samples \
--state COMPLETED \
--sort-by COMPLETED_AT \
--limit 10
```
### Getting delegated operation info
You can use the
[fiftyone delegated info](../cli/index.md#cli-fiftyone-delegated-info) command to view
the available metadata about a delegated operation, including its inputs,
execution status, and error stack trace, if applicable.
```text
# Print information about a delegated operation
fiftyone delegated info
```
### Cleaning up delegated operations
You can use the
[fiftyone delegated cleanup](../cli/index.md#cli-fiftyone-delegated-cleanup) command to
cleanup delegated operations:
```shell
# Delete all failed operations associated with a given dataset
fiftyone delegated cleanup --dataset quickstart --state FAILED
```
```shell
# Delete all delegated operations associated with non-existent datasets
fiftyone delegated cleanup --orphan
```
```shell
# Print information about operations rather than actually deleting them
fiftyone delegated cleanup --orphan --dry-run
```