With uv (recommended)

uv pip install picsellia-pipelines-cli

With Poetry:

poetry add picsellia-pipelines-cli

Check installation:

pxl-pipeline --help

This stores your:

• organization
• environment (PROD / BETA / DEV / CUSTOM)
• API token
• optional custom base URL

Other helpful commands:

pxl-pipeline whoami   # show active context
pxl-pipeline switch   # change organization/environment
pxl-pipeline logout   # clear active context

Examples:

pxl-pipeline init yolov8 --type training --template yolov8
pxl-pipeline init resize-images --type processing --template dataset_version_creation

This generates:

• a single entrypoint: pipeline.py

• config.toml (metadata + execution parameters)

• Dockerfile and .dockerignore

• a consistent folder structure:

my-pipeline/
├── pipeline.py
├── steps.py
├── utils/
│   ├── parameters.py
├── config.toml
├── Dockerfile
├── .dockerignore
├── runs/
│   └── run_config.toml   # template for test/smoke-test/launch
└── pyproject.toml

You're now ready to implement your custom logic.

Steps are Python functions decorated with @step. You can define them in steps.py and call them freely inside pipeline.py.

Example (steps.py):

from picsellia_pipeline.core import step

@step
def process(dataset_input, dataset_output):
    # your processing logic here
    dataset_output["images"] = [img.upper() for img in dataset_input["images"]]
    return dataset_output

Example pipeline (pipeline.py):

from steps import process
from picsellia_pipeline.core import pipeline, step

@pipeline
def dataset_version_creation_pipeline():
    dataset_collection = load_coco_datasets()
    dataset_collection["output"] = process(
        dataset_collection["input"], dataset_collection["output"]
    )
    upload_full_dataset(dataset_collection["output"], use_id=False)
    return dataset_collection

Define pipeline parameters in utils/parameters.py.

All parameters declared here are:

• automatically detected by the CLI

• injected at runtime

• uploaded to Picsellia during deploy or sync

Example:

from picsellia.types.schemas import LogDataType
from picsellia_cv_engine.core.parameters import Parameters

class ProcessingParameters(Parameters):
    def __init__(self, log_data: LogDataType):
        super().__init__(log_data=log_data)
        self.datalake = self.extract_parameter(["datalake"], expected_type=str, default="default")
        self.data_tag = self.extract_parameter(["data_tag"], expected_type=str, default="processed")

Each parameter requires:

• a key → used as the parameter name on the Picsellia platform

• an expected type → str, int, float, etc.

• a default value → mandatory for parameter registration

Once parameters are defined, you can reference them directly in your step logic and override their values in run_config.toml.

⚠️ Important

Even though the pipeline runs locally, all datasets, experiments, and outputs are created and updated on the Picsellia platform.

This command:

• runs the pipeline locally in the virtual env (.venv/)
• loads the configuration from your run_config.toml
• interacts with real Picsellia objects
• uploads results to the platform exactly like a real run
• guarantees your step logic and parameters behave correctly

A template run config is generated automatically at:

<pipeline_name>/runs/run_config.toml

You simply need to fill it with your dataset/model IDs, parameters, or metadata.

Example (dataset version creation processing):

override_outputs = true

[job]
type = "DATASET_VERSION_CREATION"

[input.dataset_version]
id = ""

[output.dataset_version]
name = "test_my_pipeline"

[parameters]
datalake = "default"
data_tag = "processed"

Once the file is filled:

pxl-pipeline test my-pipeline \
  --run-config-file my-pipeline/runs/run_config.toml

This command:

1. Builds the Docker image
2. Runs the pipeline inside the container (not Python locally)
3. Uses the same run_config.toml as the test command
4. Updates real objects/results on Picsellia

It is your final validation step before deployment.

A successful smoke test strongly indicates that the pipeline will run properly on Picsellia’s infrastructure.

This command:

• builds the Docker image
• pushes it to your configured registry
• versions the image
• creates or updates the Picsellia processing or training asset
• ensures the pipeline is ready to be launched from the UI

For training pipelines, define either one [model_version] or several [[model_versions]] rows — not both (the CLI will reject ambiguous configs).

Single target:

[model_version]
origin_name = "MyModel"
name = "v1"
framework = "ONNX"
inference_type = "OBJECT_DETECTION"

Multiple targets (each row must include all fields):

[[model_versions]]
origin_name = "MyModel"
name = "v1"
framework = "ONNX"
inference_type = "OBJECT_DETECTION"

[[model_versions]]
origin_name = "MyModel"
name = "v2"
framework = "ONNX"
inference_type = "OBJECT_DETECTION"

deploy propagates Docker image/tag and default parameters to every listed model version.

After deployment, the pipeline becomes usable by your team in the Picsellia interface.

Launch behaves like:

• launching a processing job on a dataset
• or launching a training experiment
• without manually creating an experiment or job in the UI

The run_config.toml defines:

• the dataset/model input
• the output dataset or experiment name
• the pipeline parameters

This is equivalent to triggering an actual job from the Picsellia UI.

For processing pipelines, this syncs:

• default parameter values
• parameter schema / types

Sync is usually unnecessary if you run:

pxl-pipeline deploy

because deploy already updates the parameter definition on the platform.

Training sync is not yet implemented.