dosho 0.1.0a1__tar.gz

dosho-0.1.0a1/.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.pyc
+.venv/
+.pytest_cache/
+*.egg-info/
+dist/
+build/
+.ruff_cache/
+docs/_build/

dosho-0.1.0a1/AGENTS.md

@@ -0,0 +1,124 @@
+# dosho -- design conventions
+
+`dosho` ("a shinobi's tool bag") is the native cab repository for shinobi
+(stimela-ninja, Stimela 3.0). cult-cargo and scabha did the real work of
+cataloguing this ecosystem's tools first, and dosho's cab set leans on
+that prior art throughout -- it's a new repository, not a rejection of
+the old one. It exists because cult-cargo's YAML cab format -- built for
+Stimela 2.0/scabha -- carries assumptions shinobi deliberately doesn't
+carry forward: `dynamic_schema` (a Python function imported and
+*executed* at cab-load time to compute a real tool's schema),
+package-scoped `_include` composition, and dtype coverage gaps that
+silently degrade to `str`. A compatibility loader could paper over those,
+but maintaining one indefinitely was costing more than it was saving. See
+stimela-ninja's own `AGENTS.md` for the full design philosophy this repo
+inherits; this file only states what's specific to authoring cabs here.
+
+## Core rule
+
+**Cabs are authored directly in Python, not parsed from a YAML dialect.**
+Every tool is a `shinobi.Cab` object (or several) built in a plain Python
+module under `src/dosho/cabs/`, using shinobi's existing
+`Cab`/`Policies`/`ParamMeta`/`ParamPattern` machinery -- see
+`dosho._builder.define_cab` for the boilerplate-reduction helper. There is
+no YAML authoring path and none should be added: a YAML dialect is exactly
+the kind of "grows its own semantics" surface stimela-ninja's `AGENTS.md`
+warns against.
+
+Not every tool can be a `Cab`, though: shinobi only ever executes
+`flavour="binary"` cabs (real standalone executables, argv-built and
+shelled out to). A tool that's actually a Python-package function call --
+no standalone binary at all (CASA tasks are the running example:
+`casatasks.listobs`, `casaplotms.plotms`) -- is instead a
+`@shinobi.pystep`-decorated function (a `StepRef`, not a `Cab`), calling
+`ctx.import_func("<task>", "<package>")` *inside the running container at
+step-execution time*. That's architecturally distinct from -- and doesn't
+violate -- "never import a cab package" below: the import happens at
+execution time inside the container, on ordinary trusted Python the
+pystep author wrote directly, not shinobi interpreting untrusted cab data
+on the host at load time. Both shapes live side by side under
+`src/dosho/cabs/`, and both are first-class for `Recipe.add_step` -- a
+pipeline author (or `dosho.get(name)`) doesn't need to know or care which
+one a given tool is. See `dosho/cabs/casatasks.py` for the pattern.
+
+## Never import/execute an external Cab's own schema-generation code
+
+External cabs that generate parameters dynamically via embedded functions
+are strictly forbidden, as are cabs whose plain-text source shinobi would
+have to execute to make sense of -- see stimela-ninja's "Never
+eval()/exec() a cab's `command`". Instead:
+
+- **Per-instance dynamic parameter families** (CubiCal's `g1-solvable`,
+  QuartiCal's `K.time_interval`, one family per caller-chosen term name)
+  are expressed as a hand-authored `ParamPattern` -- transcribed once from
+  the tool's own template/docs, not generated. This is static data, not
+  code.
+- **Dynamic output paths** (wsclean's `{prefix}-MFS-image.fits`-shaped
+  outputs) are expressed as a `ParamMeta.implicit` string template,
+  resolved by shinobi's `_fill_outputs` via plain `str.format` against a
+  step's own validated inputs -- never eval, never an expression language.
+  Only the handful of outputs a real pipeline actually wires as a
+  dependency need a resolved `implicit` template; anything more exotic
+  stays validation-only via `output_patterns`.
+
+If a tool's dynamic behavior can't be expressed this way, don't invent a
+new mechanism speculatively -- leave the field/output out and come back
+when a real pipeline needs it (same "as small and boring as possible" gate
+as stimela-ninja itself).
+
+## Container images
+
+No image-building infrastructure here (no cult-cargo-style
+bundle-manifest.md + Dockerfile tree) -- cult-cargo already solves that
+problem well; it just isn't this repo's job, since dosho is a cab-schema
+repo, not an image-building one. `src/dosho/images.py` is the single place
+image references are pinned (reusing existing `quay.io/stimela2/*` images
+where they already exist); bumping a tool's version is editing one
+constant there. The repo's own git tag versions the cab set as a whole.
+
+## Repo layout
+
+```
+src/dosho/
+  __init__.py      # re-exports get(), list_cabs()
+  registry.py       # registered (real, possibly hyphenated) name ->
+                     # "dosho.cabs:<attribute>"; get()/list_cabs(),
+                     # registered under the "shinobi.cabs" entry-point group
+                     # -- for a caller that only knows the tool's name at
+                     # *runtime* (the CLI, shinobi.cabs discovery)
+  images.py         # pinned {tool: "quay.io/stimela2/<tool>:<tag>"} constants
+  _builder.py        # define_cab() helper over Cab(...) + shinobi.loaders.build_model
+  cabs/
+    __init__.py      # re-exports every tool-level object by name, so
+                      # `from dosho.cabs import wsclean` works directly --
+                      # the write-time-known counterpart to registry.py
+    <tool>.py         # single-command tool: exports one object named after
+                       # the tool itself (e.g. wsclean.py's `wsclean = ...`)
+    <family>.py         # multi-command tool: one module-level object per
+                          # sub-command (e.g. casatasks.py's `listobs`,
+                          # `mstransform`, ...; simms.py's `skysim`/
+                          # `telsim`/`simms_classic`)
+tests/
+  test_registry.py
+  test_<tool>.py     # one per ported cab: round-trips a representative param
+                      # set through build_argv and checks real CLI token shape
+```
+
+Registering a new tool touches two places: the module itself under
+`cabs/`, and both `cabs/__init__.py` (direct-import re-export) and
+`registry.py` (`_ENTRIES`, the runtime-lookup name -- which may differ
+from the Python attribute name if the tool's real name isn't a valid
+identifier, e.g. `"simms-skysim"` -> attribute `skysim`).
+
+## Before adding a cab
+
+Port from the real tool's own `--help`/docs (or, for a `@shinobi.pystep`
+wrapper, the real Python package's own function signature), cross-checked
+against the matching cult-cargo YAML (if one exists) as a useful second
+source -- but not copied from it blindly, since cult-cargo's own schema
+for the hard cases (wsclean, cubical, quartical) has the known gaps
+dosho exists to close. Every
+ported tool gets a test: for a `Cab`, round-trip a representative param
+set through `build_argv` and check the real CLI token shape; for a
+pystep, check its `inputs_model` schema shape and that it wires into a
+`Recipe` -- not just that the object constructs without error.

dosho-0.1.0a1/CONTRIBUTING.md

@@ -0,0 +1,76 @@
+# Contributing to dosho
+
+Thanks for your interest in contributing! **dosho** ("a shinobi's tool
+bag") is the native cab repository for
+[shinobi](https://github.com/SpheMakh/stimela-ninja) (stimela-ninja,
+Stimela 3.0). It's early software, so the most valuable contributions
+right now are new tool ports, bug reports, focused fixes, tests,
+documentation, and feedback on the design.
+
+## Scope and philosophy
+
+Every tool must contain a single executable, a Cab's `command`
+or a `@shinobi.pystep` function. No other tool attribute/section
+will be executed, i.e, no `exec()/eval()` executions or
+dynamic parameter creation at loadtime. Tools must be fully defined
+when they are authored. The `ParamPattern` construct should be more
+than enough for most cases, and anything beyond that should be
+configured in the Python recipe's logic. See
+**[`AGENTS.md`](https://github.com/SpheMakh/dosho/blob/main/AGENTS.md)**
+for the full design rationale and tool-authoring conventions; read it
+before porting a new tool or touching `dosho/_builder.py`/
+`dosho/registry.py`.
+
+Our core philosophy: **avoid unnecessary complexity like the plague**.
+
+## Ways to contribute
+
+- **Port a new tool** -- see `AGENTS.md`'s "Before adding a cab" section.
+  Every ported tool needs a test that checks real CLI/schema shape, not
+  just that the object constructs without error.
+- **Report bugs** and request features via
+  [issues](https://github.com/SpheMakh/dosho/issues).
+- **Improve documentation** under `docs/` or the docstrings that feed the
+  API reference.
+- **Sizable change/addition** -- if you're considering a larger change,
+  opening an issue to discuss it first is a great way to align before
+  writing code.
+
+## Development setup
+
+The project uses [uv](https://docs.astral.sh/uv/). `stimela-ninja` is
+published on PyPI, so a plain `uv sync` resolves it like any other
+dependency:
+
+```bash
+git clone https://github.com/SpheMakh/dosho.git
+cd dosho
+uv sync --group dev
+uv run pytest
+uv run ruff check .
+```
+
+If you're working against an unreleased `stimela-ninja` change, clone
+it next to this repo and layer it in for the duration of a command with
+`uv run --with-editable ../stimela-ninja -- <command>` instead.
+
+## Testing
+
+```bash
+uv run pytest -q
+```
+
+Every ported tool's test round-trips a representative param set through
+`shinobi.policies.build_argv` (for a `Cab`) or checks its
+`inputs_model`/`Recipe` wiring (for a pystep) against the real tool's
+known CLI/signature shape -- most tools here (`casatasks`, `casaplotms`,
+CASA in general) aren't installed in the test environment, so tests never
+actually dispatch/execute them.
+
+## Documentation
+
+```bash
+uv sync --group docs
+uv run sphinx-build -b html docs docs/_build/html
+open docs/_build/html/index.html
+```

dosho-0.1.0a1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sphesihle Makhathini
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dosho-0.1.0a1/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: dosho
+Version: 0.1.0a1
+Summary: A shinobi's tool bag -- the native shinobi (stimela-ninja) cab repository
+Project-URL: Homepage, https://github.com/SpheMakh/dosho
+Project-URL: Repository, https://github.com/SpheMakh/dosho
+Project-URL: Issues, https://github.com/SpheMakh/dosho/issues
+Project-URL: Documentation, https://dosho.readthedocs.io
+Author-email: Sphesihle Makhathini <sphemakh@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: stimela-ninja>=0.1.0b2
+Description-Content-Type: text/markdown
+
+# dosho
+
+*A shinobi's tool bag.*
+
+`dosho` is the native cab repository for
+[shinobi](https://github.com/SpheMakh/stimela-ninja) (stimela-ninja,
+Stimela 3.0). Every tool is authored directly in Python -- a
+`shinobi.Cab` object for a real binary, or a `@shinobi.pystep`-produced
+`StepRef` for a Python-package tool with no standalone binary (CASA
+tasks) -- instead of a YAML dialect, so there's no `dynamic_schema`-style
+Python-execution step at cab-load time and no dtype coverage gaps.
+
+See [`AGENTS.md`](./AGENTS.md) for the design rationale and
+tool-authoring conventions.
+
+## Usage
+
+Know the tool at write-time? Import it directly:
+
+```python
+from dosho.cabs import wsclean
+from dosho.cabs.casatasks import listobs
+```
+
+Only know the name at runtime? Use the string-keyed registry:
+
+```python
+import dosho
+
+wsclean = dosho.get("wsclean")
+```
+
+Or, from shinobi itself (any installed `shinobi.cabs`-entry-point
+provider, `dosho` included):
+
+```console
+$ ninja cabs list
+$ ninja cabs show wsclean
+```
+
+## Status
+
+`dosho` currently hosts 14 real-binary `Cab`s (`wsclean`, `cubical`,
+`quartical`, `aoflagger`, `tricolour`, `crystalball`, `owlcat_plotelev`,
+`shadems`, `ragavi`, `sofia2`, `mosaic-queen`, and all three of `simms`'s
+sub-commands -- `skysim`/`telsim`/classic `simms`) and 14
+`@shinobi.pystep` CASA-task wrappers (`listobs`, `mstransform`, `fixvis`,
+`clearcal`, `initweights`, `flagdata`, `setjy`, `gaincal`, `polcal`,
+`bandpass`, `applycal`, `fluxscale`, `flagmanager`, `plotms`) -- the full
+set a real pipeline ([caracal2](https://github.com/caracal-pipeline/caracal2))
+needs.

dosho-0.1.0a1/README.md

@@ -0,0 +1,51 @@
+# dosho
+
+*A shinobi's tool bag.*
+
+`dosho` is the native cab repository for
+[shinobi](https://github.com/SpheMakh/stimela-ninja) (stimela-ninja,
+Stimela 3.0). Every tool is authored directly in Python -- a
+`shinobi.Cab` object for a real binary, or a `@shinobi.pystep`-produced
+`StepRef` for a Python-package tool with no standalone binary (CASA
+tasks) -- instead of a YAML dialect, so there's no `dynamic_schema`-style
+Python-execution step at cab-load time and no dtype coverage gaps.
+
+See [`AGENTS.md`](./AGENTS.md) for the design rationale and
+tool-authoring conventions.
+
+## Usage
+
+Know the tool at write-time? Import it directly:
+
+```python
+from dosho.cabs import wsclean
+from dosho.cabs.casatasks import listobs
+```
+
+Only know the name at runtime? Use the string-keyed registry:
+
+```python
+import dosho
+
+wsclean = dosho.get("wsclean")
+```
+
+Or, from shinobi itself (any installed `shinobi.cabs`-entry-point
+provider, `dosho` included):
+
+```console
+$ ninja cabs list
+$ ninja cabs show wsclean
+```
+
+## Status
+
+`dosho` currently hosts 14 real-binary `Cab`s (`wsclean`, `cubical`,
+`quartical`, `aoflagger`, `tricolour`, `crystalball`, `owlcat_plotelev`,
+`shadems`, `ragavi`, `sofia2`, `mosaic-queen`, and all three of `simms`'s
+sub-commands -- `skysim`/`telsim`/classic `simms`) and 14
+`@shinobi.pystep` CASA-task wrappers (`listobs`, `mstransform`, `fixvis`,
+`clearcal`, `initweights`, `flagdata`, `setjy`, `gaincal`, `polcal`,
+`bandpass`, `applycal`, `fluxscale`, `flagmanager`, `plotms`) -- the full
+set a real pipeline ([caracal2](https://github.com/caracal-pipeline/caracal2))
+needs.

dosho-0.1.0a1/pyproject.toml

@@ -0,0 +1,61 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dosho"
+version = "0.1.0a1"
+description = "A shinobi's tool bag -- the native shinobi (stimela-ninja) cab repository"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "Sphesihle Makhathini", email = "sphemakh@gmail.com" },
+]
+dependencies = [
+    "stimela-ninja>=0.1.0b2",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0",
+    "ruff>=0.5",
+]
+# Documentation build (Sphinx + Furo + autodoc). `uv sync --group docs`.
+docs = [
+    "sphinx>=7.2",
+    "furo>=2024.1",
+    "sphinx-copybutton>=0.5",
+    "myst-parser>=2.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/SpheMakh/dosho"
+Repository = "https://github.com/SpheMakh/dosho"
+Issues = "https://github.com/SpheMakh/dosho/issues"
+Documentation = "https://dosho.readthedocs.io"
+
+[project.entry-points."shinobi.cabs"]
+dosho = "dosho.registry"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dosho"]
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/src/dosho",
+    "/README.md",
+    "/LICENSE",
+    "/AGENTS.md",
+    "/CONTRIBUTING.md",
+    "/pyproject.toml",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+addopts = "--import-mode=importlib"
+consider_namespace_packages = true
+
+[tool.ruff]
+line-length = 100

dosho-0.1.0a1/src/dosho/__init__.py

@@ -0,0 +1,11 @@
+"""dosho -- a shinobi's tool bag. The native shinobi (stimela-ninja) cab
+repository. See AGENTS.md for the design rationale.
+"""
+
+from dosho import images
+from dosho._builder import define_cab
+from dosho.registry import get, list_cabs
+
+__all__ = ["define_cab", "get", "images", "list_cabs"]
+
+__version__ = "0.1.0a1"

dosho-0.1.0a1/src/dosho/_builder.py

@@ -0,0 +1,84 @@
+"""Thin builder for authoring a native `dosho` cab: wraps `shinobi.Cab` +
+`shinobi.loaders.build_model` + `shinobi.loaders.sanitize_unique` to remove
+the boilerplate of hand-transcribing a real tool's parameter list, without
+inventing any new schema surface.
+
+Generalises the `cab_from_defaults` helper first proven in
+stimela-ninja's `examples/ninja_selfcal.py`. Deliberately not a
+signature-introspecting decorator (`@cab`) -- that shape was tried once in
+shinobi itself (`ba2bd48`) and removed (`605b6f8`): it can't express
+`nom_de_guerre` (hyphenated CLI names aren't valid Python parameter
+names), `input_patterns`, `Policies`, `positional`, or `implicit`. Raw
+`Cab(...)` stays fully available for anything this helper doesn't cover --
+it's sugar, not a wall.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from shinobi import Cab
+from shinobi.loaders import build_model, sanitize_unique
+from shinobi.steps.schema import ParamMeta, ParamPattern, Policies
+
+
+def define_cab(
+    name: str,
+    command: str,
+    image: str,
+    fields: dict[str, tuple[str, bool, Any]],
+    *,
+    outputs: dict[str, tuple[str, bool, Any]] | None = None,
+    field_meta: dict[str, ParamMeta] | None = None,
+    policies: Policies | None = None,
+    input_patterns: list[ParamPattern] | None = None,
+    output_patterns: list[ParamPattern] | None = None,
+    flavour: str = "binary",
+    wranglers: dict[str, list[str]] | None = None,
+    info: str | None = None,
+) -> Cab:
+    """Build a `Cab` from a flat `{raw_param_name: (dtype, required,
+    default)}` dict -- the shape a tool's own `--help`/docs naturally give
+    you (e.g. `"data-ms": ("MS", True, None)`). Hyphenated/dotted raw
+    names are sanitised to valid pydantic field names, with the original
+    kept as a `nom_de_guerre` so the built cab's `build_argv` still emits
+    the tool's real flag.
+
+    `field_meta` entries the caller passes explicitly (keyed by the
+    *sanitised* field name -- e.g. an output field's `implicit` template,
+    or a `positional`/`repeat_as_tokens` override) are merged in on top of
+    the auto-derived `nom_de_guerre`s; an explicit entry that doesn't set
+    its own `nom_de_guerre` keeps the auto-derived one rather than losing
+    it.
+    """
+    resolved_fields: dict[str, tuple[str, bool, Any]] = {}
+    resolved_meta: dict[str, ParamMeta] = {}
+    seen: dict[str, str] = {}
+    for raw_name, spec in fields.items():
+        field = sanitize_unique(raw_name, seen)
+        resolved_fields[field] = spec
+        if field != raw_name:
+            resolved_meta[field] = ParamMeta(nom_de_guerre=raw_name)
+
+    for field, meta in (field_meta or {}).items():
+        auto = resolved_meta.get(field)
+        if auto is not None and meta.nom_de_guerre is None:
+            meta = meta.model_copy(update={"nom_de_guerre": auto.nom_de_guerre})
+        resolved_meta[field] = meta
+
+    return Cab(
+        name=name,
+        command=command,
+        image=image,
+        info=info,
+        flavour=flavour,
+        inputs_model=build_model(
+            f"{name}_Inputs", resolved_fields, allow_extra=bool(input_patterns)
+        ),
+        outputs_model=build_model(f"{name}_Outputs", outputs or {}),
+        field_meta=resolved_meta,
+        policies=policies or Policies(),
+        input_patterns=input_patterns or [],
+        output_patterns=output_patterns or [],
+        wranglers=wranglers or {},
+    )

dosho-0.1.0a1/src/dosho/cabs/__init__.py

@@ -0,0 +1,84 @@
+"""Every tool dosho ports, re-exported by name at package level, so a
+pipeline author who knows what they want at write-time can do
+`from dosho.cabs import wsclean` or `from dosho.cabs.casatasks import
+listobs` directly -- no need to know or care whether a given tool is a
+`Cab` (a real binary, argv-built and shelled out to) or a `StepRef` (a
+Python-package tool with no standalone binary, run via `@shinobi.pystep`
+and `ctx.import_func` inside a container instead -- CASA tasks are the
+only example so far). Both shapes are first-class for `Recipe.add_step`.
+
+For *runtime*/string-keyed lookup (the CLI, `shinobi.cabs` entry-point
+discovery), use `dosho.get(name)`/`dosho.registry` instead -- that's a
+second, parallel interface for a caller that doesn't know the name until
+it runs, not a replacement for these direct imports.
+
+Importing this module (or any of its submodules -- Python always
+initializes a parent package first) eagerly constructs every `Cab`/
+`StepRef` below. That's a deliberate, accepted tradeoff here: each one is
+cheap (pydantic model + dict construction, no I/O), so the "don't pay for
+what you don't use" laziness `dosho.registry`'s own submodule-path table
+still gives a caller that only wants one specific tool is preserved
+there, not here.
+"""
+
+from __future__ import annotations
+
+from dosho.cabs.aoflagger import aoflagger
+from dosho.cabs.casaplotms import plotms
+from dosho.cabs.casatasks import (
+    applycal,
+    bandpass,
+    clearcal,
+    fixvis,
+    flagdata,
+    flagmanager,
+    fluxscale,
+    gaincal,
+    initweights,
+    listobs,
+    mstransform,
+    polcal,
+    setjy,
+)
+from dosho.cabs.crystalball import crystalball
+from dosho.cabs.cubical import cubical
+from dosho.cabs.mosaic_queen import mosaic_queen
+from dosho.cabs.owlcat_plotelev import owlcat_plotelev
+from dosho.cabs.quartical import quartical
+from dosho.cabs.ragavi import ragavi
+from dosho.cabs.shadems import shadems
+from dosho.cabs.simms import simms_classic, skysim, telsim
+from dosho.cabs.sofia2 import sofia2
+from dosho.cabs.tricolour import tricolour
+from dosho.cabs.wsclean import wsclean
+
+__all__ = [
+    "aoflagger",
+    "applycal",
+    "bandpass",
+    "clearcal",
+    "crystalball",
+    "cubical",
+    "fixvis",
+    "flagdata",
+    "flagmanager",
+    "fluxscale",
+    "gaincal",
+    "initweights",
+    "listobs",
+    "mosaic_queen",
+    "mstransform",
+    "owlcat_plotelev",
+    "plotms",
+    "polcal",
+    "quartical",
+    "ragavi",
+    "setjy",
+    "shadems",
+    "simms_classic",
+    "skysim",
+    "sofia2",
+    "telsim",
+    "tricolour",
+    "wsclean",
+]

dosho-0.1.0a1/src/dosho/cabs/aoflagger.py

@@ -0,0 +1,69 @@
+"""aoflagger -- automatic RFI flagger (https://aoflagger.readthedocs.io).
+
+Ported field-by-field from cult-cargo's aoflagger.yml (a flat, static
+schema -- no dynamic_schema, no package-scoped _include -- so this is a
+mechanical transcription, not a structural fix like wsclean/cubical/
+quartical).
+"""
+
+from __future__ import annotations
+
+from shinobi.steps.schema import ParamMeta, Policies
+
+from dosho import images
+from dosho._builder import define_cab
+
+_FIELDS: dict[str, tuple[str, bool, object]] = {
+    "msname": ("MS", True, None),
+    "verbose": ("bool", False, False),
+    "threads": ("int", False, None),
+    "strategy": ("File", False, None),
+    "indirect_read": ("bool", False, True),
+    "memory_read": ("bool", False, False),
+    "auto_read_mode": ("bool", False, True),
+    "uvw": ("bool", False, False),
+    "column": ("str", False, "DATA"),
+    "skip_flagged": ("bool", False, False),
+    "bands": ("int", False, None),
+    "fields": ("int", False, None),
+}
+
+_FIELD_META: dict[str, ParamMeta] = {
+    "msname": ParamMeta(info="MS name(s) to be flagged"),
+    "verbose": ParamMeta(nom_de_guerre="v", info="Produce verbose output"),
+    "threads": ParamMeta(
+        nom_de_guerre="j",
+        info="overrides the number of threads specified in the strategy (default: one thread for each CPU core)",
+    ),
+    "strategy": ParamMeta(info="specifies a possible customized strategy"),
+    "indirect_read": ParamMeta(
+        nom_de_guerre="indirect-read",
+        info="will reorder the measurement set before starting, which is normally faster but requires free disk space to reorder the data to",
+    ),
+    "memory_read": ParamMeta(
+        nom_de_guerre="memory-read",
+        info="will read the entire measurement set in memory. This is the fastest, but requires much memory.",
+    ),
+    "auto_read_mode": ParamMeta(
+        nom_de_guerre="auto-read-mode",
+        info="will select either memory or direct mode based on available memory",
+    ),
+    "uvw": ParamMeta(info="reads uvw values (some exotic strategies require these)"),
+    "column": ParamMeta(info="specify column to flag"),
+    "skip_flagged": ParamMeta(
+        nom_de_guerre="skip-flagged",
+        info="will skip an ms if it has already been processed by AOFlagger according to its HISTORY table.",
+    ),
+    "bands": ParamMeta(info="comma separated list of (zero-indexed) band ids to process"),
+    "fields": ParamMeta(info="Field ID(s). Comma separated string if more than one field"),
+}
+
+aoflagger = define_cab(
+    "aoflagger",
+    "aoflagger",
+    images.AOFLAGGER,
+    _FIELDS,
+    field_meta=_FIELD_META,
+    policies=Policies(prefix="-"),
+    info="AOFlagger automatic RFI flagger (https://aoflagger.readthedocs.io)",
+)