CLI reference

Every command of blazerops 0.1.1, the latest release on PyPI, generated from the CLI itself. Run blazerops <command> --help for the same information in your terminal, and pip install -U blazerops to upgrade.

The CLI talks to https://api.blazerops.ai; set BLAZEROPS_API_URL to use another environment. On CI or a headless machine, set BLAZEROPS_TOKEN (see Install and sign in).

Command	Purpose
`blazerops login`	Sign in with a device code that you approve in the app
`blazerops logout`	Sign out and remove the stored token
`blazerops whoami`	Check your sign-in with a real request and show your user, organisation and API
`blazerops meta`	Print the server's version handshake (/v1/meta)
`blazerops doctor`	Check the CLI version, server compatibility, sign-in and catalog; exits non-zero on any problem

`blazerops login`

blazerops login [-h] [--print-token]

Argument	Description
`--print-token`	Print the token once instead of storing it, to set as BLAZEROPS_TOKEN on a machine with no OS keyring (CI, headless)

`blazerops logout`

Sign out and remove the stored token.

blazerops logout [-h]

`blazerops whoami`

Check your sign-in with a real request and show your user, organisation and API.

blazerops whoami [-h]

`blazerops meta`

Print the server's version handshake (/v1/meta).

blazerops meta [-h]

`blazerops doctor`

Check the CLI version, server compatibility, sign-in and catalog; exits non-zero on any problem.

blazerops doctor [-h]

Author a pipeline

Command	Purpose
`blazerops export`	Write a stored pipeline to a local checkout you can edit and push
`blazerops compile`	Compile pipeline.toml with the server's compiler, changing nothing, and write the result
`blazerops validate`	Check the pipeline against the server's typing and policy rules (read-only)
`blazerops diff`	Compare your local pipeline with its current version on the server
`blazerops push`	Push pipeline.toml as a new version; refuses if the server moved on since your last push
`blazerops codegen`	Generate typed Python constructors for the catalog's components

`blazerops export`

Write a stored pipeline to a local checkout you can edit and push.

blazerops export [-h] [-o OUTPUT_DIR] [--version N] [--allow-drop KEY] pipeline

Argument	Description
`pipeline`	Pipeline name or id
`-o, --output-dir OUTPUT_DIR`	Parent directory; the checkout is written to <dir>/<name> (default: exported_pipelines)
`--version N`	Act on this version of the pipeline (`blazerops versions <pipeline>` lists them). Without it, a pipeline name means its current version and a pipeline id means exactly that version
`--allow-drop KEY`	Allow dropping this legacy config key (repeatable); without it, export refuses rather than lose data

`blazerops compile`

Compile pipeline.toml with the server's compiler, changing nothing, and write the result.

blazerops compile [-h] [--file FILE] [-o OUTPUT]

Argument	Description
`--file FILE`	Pipeline definition (default: pipeline.toml)
`-o, --output OUTPUT`	Where to write the compiled pipeline (default: build/pipeline.json)

`blazerops validate`

Check the pipeline against the server's typing and policy rules (read-only).

blazerops validate [-h] [--file FILE] [--coverage]

Argument	Description
`--file FILE`	Pipeline definition (default: pipeline.toml)
`--coverage`	For each rule, show how many items it checked and why it skipped the rest

`blazerops diff`

Compare your local pipeline with its current version on the server.

blazerops diff [-h] [--file FILE]

Argument	Description
`--file FILE`	Pipeline definition (default: pipeline.toml)

`blazerops push`

Push pipeline.toml as a new version; refuses if the server moved on since your last push.

blazerops push [-h] [--file FILE] [--force] [--json] [--find-kernels]

Argument	Description
`--file FILE`	Pipeline definition (default: pipeline.toml)
`--force`	Push even when the server's current version isn't the one this checkout last pushed
`--json`	Print the result as JSON (name, pipeline_id, version, server_hash, kernel_decisions)
`--find-kernels`	For each new node that only has a brief, search your organisation's kernels and offer a match to reuse or fork before anything is built

`blazerops codegen`

Generate typed Python constructors for the catalog's components.

blazerops codegen [-h] [-o OUTPUT] [--offline]

Argument	Description
`-o, --output OUTPUT`	File to write (default: blazerops_generated.py)
`--offline`	Use the cached catalog instead of revalidating

Run pipelines

Command	Purpose
`blazerops pipelines`	List your organisation's pipelines
`blazerops versions`	List a pipeline's versions
`blazerops runs`	List a pipeline's runs
`blazerops run`	Start a run of a pipeline
`blazerops bom`	Print a run's bill of materials
`blazerops cancel`	Stop a run that is in progress
`blazerops trigger`	Run a pipeline on a schedule

`blazerops pipelines`

List your organisation's pipelines.

blazerops pipelines [-h]

`blazerops versions`

List a pipeline's versions.

blazerops versions [-h] pipeline

Argument	Description
`pipeline`	Pipeline name or id (any version of it)

`blazerops runs`

List a pipeline's runs.

blazerops runs [-h] [--version N] pipeline

Argument	Description
`pipeline`	Pipeline name or id
`--version N`	Act on this version of the pipeline (`blazerops versions <pipeline>` lists them). Without it, a pipeline name means its current version and a pipeline id means exactly that version

`blazerops run`

Start a run of a pipeline.

blazerops run [-h] [--var NAME=VALUE] [--input NAME=VALUE] [--no-cache]
                     [--compute {auto,own,provided}] [--version N] [--watch] [--timeout SECONDS]
                     [--json]
                     pipeline

Argument	Description
`pipeline`	Pipeline name or id
`--var NAME=VALUE`	Set a run variable (repeatable)
`--input NAME=VALUE`	Supply an input the pipeline's interface declares (repeatable). A file input takes its artifact id, any other input its value; @path reads the value from a file
`--no-cache`	Rerun every node instead of reusing cached outputs
`--compute COMPUTE`	Where the run's nodes run unless a node says otherwise: auto (the platform decides), own (your compute) or provided (compute the platform provides) (one of `auto`, `own`, `provided`)
`--version N`	Act on this version of the pipeline (`blazerops versions <pipeline>` lists them). Without it, a pipeline name means its current version and a pipeline id means exactly that version
`--watch`	Follow the run until it ends (exit codes: 0 succeeded, 3 failed, 4 cancelled, 5 --timeout reached)
`--timeout SECONDS`	With --watch, stop watching after this many seconds (the run continues)
`--json`	Print the run summary as JSON on stdout; progress goes to stderr

`blazerops bom`

Print a run's bill of materials.

blazerops bom [-h] run_id

Argument	Description
`run_id`	Run id

`blazerops cancel`

Stop a run that is in progress.

blazerops cancel [-h] run_id

Argument	Description
`run_id`	Run id

`blazerops trigger`

Run a pipeline on a schedule.

blazerops trigger [-h] {list,create,update,delete} ...

Subcommand	Purpose
`blazerops trigger list`	List a pipeline's schedules
`blazerops trigger create`	Schedule a pipeline to run at a fixed interval
`blazerops trigger update`	Pause, resume, or change a schedule
`blazerops trigger delete`	Delete a schedule (runs it already started carry on)

`blazerops trigger list`

List a pipeline's schedules.

blazerops trigger list [-h] pipeline

Argument	Description
`pipeline`	Pipeline name or id

`blazerops trigger create`

Schedule a pipeline to run at a fixed interval.

blazerops trigger create [-h] --every DURATION [--var NAME=VALUE] [--use-cache] [--paused]
                                [--version N]
                                pipeline

Argument	Description
`pipeline`	Pipeline name or id
`--every DURATION`	Interval: 30m, 1h, 2d, or a number of seconds (minimum 60) (required)
`--var NAME=VALUE`	Set a run variable on every scheduled run (repeatable)
`--use-cache`	Reuse cached node outputs. Off by default: a scheduled run whose inputs haven't changed would reuse every output and do nothing. Turn it on once the pipeline's first node reads ${vars.as_of}
`--paused`	Create the schedule paused
`--version N`	Act on this version of the pipeline (`blazerops versions <pipeline>` lists them). Without it, a pipeline name means its current version and a pipeline id means exactly that version

`blazerops trigger update`

Pause, resume, or change a schedule.

blazerops trigger update [-h] [--every DURATION] [--var NAME=VALUE] [--use-cache] [--pause]
                                [--resume]
                                pipeline trigger

Argument	Description
`pipeline`	Pipeline name or id
`trigger`	Schedule id or an unambiguous prefix of it
`--every DURATION`	New interval
`--var NAME=VALUE`	Replace the schedule's run variables (repeatable)
`--use-cache`	Turn on reuse of cached node outputs
`--pause`	Stop running, keep the schedule
`--resume`	Start running again

`blazerops trigger delete`

Delete a schedule (runs it already started carry on).

blazerops trigger delete [-h] pipeline trigger

Argument	Description
`pipeline`	Pipeline name or id
`trigger`	Schedule id or an unambiguous prefix of it

Kernels and code

Command	Purpose
`blazerops kernel`	Your organisation's kernels, kernel decisions, and local testing
`blazerops code`	Edit a pipeline's kernel code locally: pull it, then push your changes

`blazerops kernel`

Your organisation's kernels, kernel decisions, and local testing.

blazerops kernel [-h] {test,list,versions,decision,pins} ...

Subcommand	Purpose
`blazerops kernel test`	Run a kernel locally through the same harness the platform runs it in
`blazerops kernel list`	List your organisation's kernels (reusable run_code code)
`blazerops kernel versions`	List a kernel's versions, newest first
`blazerops kernel decision`	Reuse-or-fork decisions about kernels that wait for a person
`blazerops kernel pins`	Show which kernel version each node of a pipeline pins

`blazerops kernel test`

Run a kernel locally through the same harness the platform runs it in.

blazerops kernel test [-h] -i INPUT [-p PARAMS] kernel_dir

Argument	Description
`kernel_dir`	The kernel's directory
`-i, --input INPUT`	A sample input file or directory (required)
`-p, --params PARAMS`	Parameters as JSON (what the kernel reads as ctx.params)

`blazerops kernel list`

List your organisation's kernels (reusable run_code code).

blazerops kernel list [-h]

`blazerops kernel versions`

List a kernel's versions, newest first.

blazerops kernel versions [-h] kernel

Argument	Description
`kernel`	Kernel name or id

`blazerops kernel decision`

Reuse-or-fork decisions about kernels that wait for a person.

blazerops kernel decision [-h] {list,show,resolve} ...

Subcommand	Purpose
`blazerops kernel decision list`	List the decisions waiting in your organisation
`blazerops kernel decision show`	Show one decision: the proposal, its candidates and its state
`blazerops kernel decision resolve`	Resolve one or more decisions yourself; no kernel is written until you do

`blazerops kernel decision list`

List the decisions waiting in your organisation.

blazerops kernel decision list [-h]

`blazerops kernel decision show`

Show one decision: the proposal, its candidates and its state.

blazerops kernel decision show [-h] decision_id

Argument	Description
`decision_id`	Decision id

`blazerops kernel decision resolve`

Resolve one or more decisions yourself; no kernel is written until you do.

blazerops kernel decision resolve [-h] --decision {reuse,adapt,widen,fork} -m RATIONALE
                                         decision_id [decision_id ...]

Argument	Description
`decision_id`	One or more decision ids
`--decision DECISION`	Your decision; it never defaults to the agent's proposal (one of `reuse`, `adapt`, `widen`, `fork`; required)
`-m, --rationale RATIONALE`	Why you decided this, recorded with the decision (must not be empty) (required)

`blazerops kernel pins`

Show which kernel version each node of a pipeline pins.

blazerops kernel pins [-h] [--version N] pipeline

Argument	Description
`pipeline`	Pipeline name or id
`--version N`	Act on this version of the pipeline (`blazerops versions <pipeline>` lists them). Without it, a pipeline name means its current version and a pipeline id means exactly that version

`blazerops code`

Edit a pipeline's kernel code locally: pull it, then push your changes.

blazerops code [-h] {pull,push} ...

Subcommand	Purpose
`blazerops code pull`	Download the kernel code a pipeline pins into kernels/<node>/ and record it in kernels.lock
`blazerops code push`	Register edited kernel code as new kernel versions and repin them in pipeline.toml

`blazerops code pull`

Download the kernel code a pipeline pins into kernels/<node>/ and record it in kernels.lock.

blazerops code pull [-h] [-o OUTPUT_DIR] [--version N] [--allow-drop KEY] pipeline

Argument	Description
`pipeline`	Pipeline name or id
`-o, --output-dir OUTPUT_DIR`	Parent directory; the checkout is <dir>/<name>, the same one export makes (default: exported_pipelines)
`--version N`	Act on this version of the pipeline (`blazerops versions <pipeline>` lists them). Without it, a pipeline name means its current version and a pipeline id means exactly that version
`--allow-drop KEY`	Allow dropping this legacy config key (repeatable), as for export

`blazerops code push`

blazerops code push [-h] [-m MESSAGE] --hypothesis HYPOTHESIS [dir]

Argument	Description
`dir`	The checkout to push (default: the current directory)
`-m, --message MESSAGE`	A message recorded with the new versions
`--hypothesis HYPOTHESIS`	What you expect this kernel version to change (required)

Models

Command	Purpose
`blazerops model`	Trained models and the versions your nodes pin

`blazerops model`

Trained models and the versions your nodes pin.

blazerops model [-h] {list,versions,checkpoints,pins,pin} ...

Subcommand	Purpose
`blazerops model list`	List your organisation's models, grouped by the kernel that trained them
`blazerops model versions`	List a model's versions and the id a node pins
`blazerops model checkpoints`	List a model version's checkpoints
`blazerops model pins`	Show which model version each node of a pipeline pins
`blazerops model pin`	Pin a model version onto a node in pipeline.toml

`blazerops model list`

List your organisation's models, grouped by the kernel that trained them.

blazerops model list [-h]

`blazerops model versions`

List a model's versions and the id a node pins.

blazerops model versions [-h] model

Argument	Description
`model`	Model name or id

`blazerops model checkpoints`

List a model version's checkpoints.

blazerops model checkpoints [-h] model version

Argument	Description
`model`	Model name or id
`version`	Model version

`blazerops model pins`

Show which model version each node of a pipeline pins.

blazerops model pins [-h] [--version N] pipeline

Argument	Description
`pipeline`	Pipeline name or id
`--version N`	Act on this version of the pipeline (`blazerops versions <pipeline>` lists them). Without it, a pipeline name means its current version and a pipeline id means exactly that version

`blazerops model pin`

Pin a model version onto a node in pipeline.toml.

blazerops model pin [-h] [--file FILE] node model version

Argument	Description
`node`	The key of a run_code or infer_code node
`model`	Model name or id
`version`	Model version
`--file FILE`	Pipeline definition to edit (default: pipeline.toml)

Data

Command	Purpose
`blazerops data`	Move data between your machine and your organisation's storage

`blazerops data`

Move data between your machine and your organisation's storage.

blazerops data [-h] {remotes,push,pull,ls,resolve} ...

Subcommand	Purpose
`blazerops data remotes`	List the storage destinations you can push to
`blazerops data push`	Upload a file or directory and register it as an artifact (needs rclone)
`blazerops data pull`	Download from a destination
`blazerops data ls`	List one level of a destination
`blazerops data resolve`	Upload every local `path =` reference in pipeline.toml and record the artifact ids in blazerops.data.lock

`blazerops data remotes`

List the storage destinations you can push to.

blazerops data remotes [-h]

`blazerops data push`

Upload a file or directory and register it as an artifact (needs rclone).

blazerops data push [-h] [--no-shards] [--dry-run] [--print-id] [--rclone-arg ARG]
                           source destination

Argument	Description
`source`	Local file or directory
`destination`	<backend>:<path>, or a bare <path> for your primary storage
`--no-shards`	Register a directory as one input instead of one shard per member. Use it for a directory that is a single object (a zarr store, a model directory); otherwise each member can be processed by its own worker
`--dry-run`	Show what would transfer; upload and register nothing
`--print-id`	Print only the artifact id on success (for scripting)
`--rclone-arg ARG`	Pass an extra flag through to rclone (repeatable), e.g. --rclone-arg=--bwlimit=10M

`blazerops data pull`

Download from a destination.

blazerops data pull [-h] [--dry-run] [--rclone-arg ARG] source dest

Argument	Description
`source`	<backend>:<path>, or a bare <path>
`dest`	Local directory to write into
`--dry-run`	Show what would transfer; download nothing
`--rclone-arg ARG`	Pass an extra flag through to rclone (repeatable)

`blazerops data ls`

List one level of a destination.

blazerops data ls [-h] [--max-keys MAX_KEYS] [destination]

Argument	Description
`destination`	<backend>:<path>; omit for the primary backend's root
`--max-keys MAX_KEYS`	Most entries to list; a truncated listing says so (default: 1000)

`blazerops data resolve`

Upload every local path = reference in pipeline.toml and record the artifact ids in blazerops.data.lock.

blazerops data resolve [-h] [-f FILE]

Argument	Description
`-f, --file FILE`	Pipeline definition (default: pipeline.toml)

Catalog

Command	Purpose
`blazerops catalog`	Browse the component catalog

`blazerops catalog`

Browse the component catalog.

blazerops catalog [-h] [--offline] {components,templates,show,harness} ...

Argument	Description
`--offline`	Use the cached catalog without checking for updates (fails if there is no cache)

Subcommand	Purpose
`blazerops catalog components`	List every component
`blazerops catalog templates`	List the library of template run_code kernels
`blazerops catalog show`	Show the full definition of one component or recipe
`blazerops catalog harness`	Show the contract a kernel's code runs under

`blazerops catalog components`

List every component.

blazerops catalog components [-h]

`blazerops catalog templates`

List the library of template run_code kernels.

blazerops catalog templates [-h]

`blazerops catalog show`

Show the full definition of one component or recipe.

blazerops catalog show [-h] key

Argument	Description
`key`	Component or recipe key

`blazerops catalog harness`

Show the contract a kernel's code runs under.

blazerops catalog harness [-h]

Published apps

Command	Purpose
`blazerops generate`	Generate a typed client for a published app's release, pinned to its tag

`blazerops generate`

Generate a typed client for a published app's release, pinned to its tag.

blazerops generate [-h] --app SLUG [--ref REF] [--lang {ts}] --out PATH
                          [--from OPENAPI_JSON]

Argument	Description
`--app SLUG`	The app's slug (required)
`--ref REF`	A release tag or alias (e.g. stable); required unless --from
`--lang LANG`	The client's language: ts, a module over @blazerops/sdk and zod (default: ts) (one of `ts`)
`--out PATH`	The file to write (required)
`--from OPENAPI_JSON`	Generate offline from a saved openapi.json instead of reading the release with BLAZEROPS_API_KEY

Sign in and check your setup
Author a pipeline
Run pipelines
Kernels and code
Models
Data
Catalog
Published apps
- blazerops generate

Sign in and check your setup​

blazerops login​

blazerops logout​

blazerops whoami​

blazerops meta​

blazerops doctor​

Author a pipeline​

blazerops export​

blazerops compile​

blazerops validate​

blazerops diff​

blazerops push​

blazerops codegen​

Run pipelines​

blazerops pipelines​

blazerops versions​

blazerops runs​

blazerops run​

blazerops bom​

blazerops cancel​

blazerops trigger​

blazerops trigger list​

blazerops trigger create​

blazerops trigger update​

blazerops trigger delete​

Kernels and code​

blazerops kernel​

blazerops kernel test​

blazerops kernel list​

blazerops kernel versions​

blazerops kernel decision​

blazerops kernel decision list​

blazerops kernel decision show​

blazerops kernel decision resolve​

blazerops kernel pins​

blazerops code​

blazerops code pull​

blazerops code push​

Models​

blazerops model​

blazerops model list​

blazerops model versions​

blazerops model checkpoints​

blazerops model pins​

blazerops model pin​

Data​

blazerops data​

blazerops data remotes​

blazerops data push​

blazerops data pull​

blazerops data ls​

blazerops data resolve​

Catalog​

blazerops catalog​

blazerops catalog components​

blazerops catalog templates​

blazerops catalog show​

blazerops catalog harness​

Published apps​

blazerops generate​

Sign in and check your setup