ChemLab-Assets / chemlab /COMPILE_GUIDE.md
Ziruibest's picture
Release 1.5.0: chemlab command line for LLM agents; labware, storage and reagents
3b67020 verified
|
Raw History Blame Contribute Delete
35.2 kB
# chemlab compile layer: adding an instrument class
The compile layer gives every instrument class one set of plain commands — `set-temp 80C`, `tare`, `transfer 50uL --from
plate:A1 --to plate:B1` — and lowers each command to that instrument's own contract capabilities. It sits between the generic
service (`chemlab/generic.py`, GenericCore) and the lab backend, plugged into the adapter hook. It has 30 classes (for example
`balance`, `thermal` for temperature control and `liquid` for pipetting), a thin class and a shared layer that together cover
all 203 instruments. This guide is what you need to add or extend a class: the rules, the files, the steps and the tests.
```
agent (sandbox) ── chemlab run INST VERB ... ──> GenericCore ──> adapter of INST (compile layer) ──> LabBackend ──> runtime
│ generic commands unchanged: │ same agent principal,
│ list/describe/read/call/wait/... │ the runtime checks again
```
An adapter only ever reaches the instrument through `core.backend` with the caller's own agent principal, exactly like
`chemlab call`. Visibility rules, the output filter and the runtime's own checks stay in force. `chemlab call` stays available
for everything a class does not cover.
## 1. Files
| part | file | notes |
|---|---|---|
| framework | `chemlab/compile/{units,errors,verbs,ctx,jobs,base,fragments,shared,deck,lowering,acceptance,mapgen}.py` | shared by every class; change with care and run the full test set |
| a class | `chemlab/compile/classes/<class>.py` — verb table, handlers, class checks, summary | one module per class |
| its mapping | `configs/adapters/<class>.json` — one fragment per class, members and per-instrument data | one fragment per class |
| host-side world | `chemlab/compile/tasks/<class>_world.py` (lab-config set-up steps), `chemlab/compile/scenes/<x>.py` (only if the runtime needs a trusted scene, like the Flex) | per class |
| lowering table | `chemlab/compile/tasks/<class>_lowering.py` | per class |
| acceptance tasks | `chemlab/compile/tasks/<class>_tasks.py` | per class |
| tests | `tests_compile/test_class_<class>.py` (two lines, see §8) | per class |
| shared hooks | `chemlab/{generic,labbackend,adapters}.py` | the generic layer; a class never needs to change them |
Suites and lowering tables are found by name (`tasks/<class>_tasks.py`, `tasks/<class>_lowering.py`); fragments by directory.
There is no shared registry to edit, so two classes developed at the same time never touch the same file. Do not edit `configs/all203.json`.
## 2. Steps to add a class
1. **Read** each member's agent-visible capabilities and slots (`chemlab describe INST --json`), its contract, and the
manufacturer's documentation for the native vocabulary. Cite page references only; never copy manual text into code,
fragments or help.
2. **Probe** each member in a small lab before writing code (what the default lab state is, what a call needs, how fast things
change): `GenericLab(dir, single([...]))` and `lab.core.handle(['chemlab', 'call', ...], 'agent')`; use `class_adapters: False`
in the config to see the plain generic layer. Note what needs host world (filled bath, sample, fixture) — the default lab
does not provide it.
3. **Draft the mapping**: `python -m chemlab.compile.mapgen <class>` drafts a fragment from rules in `mapgen.RULES` (add a rule set
for a new class there), or write the fragment by hand. `python -m chemlab.compile.mapgen <class> --compare` shows how much the
rules find for an existing fragment.
4. **Write the class module** (§3) and the **fragment** (§4). Keep instrument facts in the fragment, class logic in the module.
5. **Lowering table** (§7): per member, verbs in order with the native calls each must make, written from the contracts.
`python -m chemlab.compile.lowering --class <class>` must PASS (calls equal, twin state equal after every step, one path).
6. **Acceptance tasks** (§7): 8–10 for classes with 5 or more members (4–6 for small classes), at least two recovery tasks,
gold with `chemlab run` passes in the sandbox, NoAct fails: `python -m chemlab.compile.acceptance --class <class>`.
7. **Tests**: `tests_compile/test_class_<class>.py`; then the full set (§8), including the generic parity for your members.
8. **Document** in the fragment: membership decisions with reasons (who is in, who is out and why, primary / secondary) and
verbs not supported per member with reasons. Fix runtime or contract problems in the runtime or contract, not in the class.
## 3. The class module
```python
from ..base import ClassAdapter, finite
from ..errors import invalid, refused
from ..verbs import Arg, Opt, Verb, save_to_opt
class CentrifugeAdapter(ClassAdapter):
CLASS = 'agitation' # = the fragment's "class"
TITLE = 'spin, shake, mix'
ABOUT = 'one paragraph for describe'
STANDARDS = 'SiLA 2 ..., PyLabRobot ..., ASTM / pharmacopoeia terms'
ALWAYS = ('status',) # verbs every member has without a mapping entry
UNIT_KINDS = ('rotation', 'duration')
PATH_GROUPS = (('start', 'stop', 'result'),) # one native path per group (§5.2)
CODES = {'LID_OPEN': ('LID_OPEN', 'the lid of {inst} is open.', 'close it: `chemlab run {inst} close lid`.')}
def build_verbs(self):
return {'spin': Verb('spin', 'spin at a speed for a time', self.h_spin,
positionals=[Arg('SPEED', 'e.g. 4000rpm', kind='rotation')],
options={'time': Opt('run time', kind='duration', metavar='TIME', default='5min')},
preconditions=['lid closed', 'speed within the rotor range'],
errors=['OUT_OF_RANGE (usage)', 'LID_OPEN (refused)'],
reference='manual pages ...', example='chemlab run INST spin 4000rpm --time 5min')}
def summary(self, values): # values: {slot: value} or a Ctx (use self.slot_si / self.val helpers)
return ['...one line...'], {'json': 'view'}
def h_spin(self, ctx, p):
m = self.vmap('spin') # this member's mapping for the verb
w = p.pos[0] # already SI (rad/s): verbs parse units
lo, hi = self.arg_range_si(m['cap'], m['arg']) # range from the contract, in SI
if (lo is not None and w < lo) or (hi is not None and w > hi):
ctx.fail(invalid('OUT_OF_RANGE', '...', 'give a speed from ... to ...'))
self.requirements(ctx, 'spin') # the member's "requires" entries for this verb
ctx.check(not ctx.v(self.slot('lid_open')), 'LID_OPEN', 'the lid is open.', 'close it first.')
ctx.call(m['cap'], {m['arg']: self.arg_value(m['cap'], m['arg'], w)}, 'set the speed to %.0f rpm' % (w * 9.549))
return {'text': 'ok: ...\n', 'json': {...}}
```
What the base gives every class (do not re-implement): argument and unit parsing, `--dry-run` (checks run, every native call is
listed, none is sent), destructive verbs (`destructive=True`) only preview without `--yes`, `--save-to`, unknown verbs with close
matches, unsupported verbs with reasons (exit 6), `describe` / `help INST VERB` / `run INST VERB --help` / `run INST`, `read` in
friendly units with the class view on top, error format, partial-progress reports, refusal explanation, the mapping check
against the contract, `status`.
The request context `ctx` (`ctx.py`): `ctx.v(slot)` (current value; `slot#key` for a key of an object slot via `self.slot_si`),
`ctx.call(cap, args, step, refusal=, readback=, query=)` (one native call, validated against the contract schema first, recorded,
read back), `ctx.check(ok, CODE, message, fix)` (a class precondition), `ctx.fail(err)` (raise with the steps done),
`ctx.advance(seconds, until=fn, poll_s=)` (let lab time pass; the only way a class verb may move time — only in verbs that say
they wait; the generic `chemlab wait` takes 60, 30s, 5min or 1.5h), `ctx.plan` / `ctx.notes` / `ctx.done`.
## 4. The fragment (`configs/adapters/<class>.json`)
```json
{"class": "thermal", "adapter": "chemlab.compile.classes.thermal:ThermalAdapter", "about": "...",
"membership": {"primary": [...], "secondary": {...}, "excluded": {"slug": "reason"}},
"members": {
"julabo_corio_cd200f": {
"role": "primary",
"verbs": {"set-temp": {"cap": "thermal.set_temperature", "arg": "temperature_K"},
"heat": {"cap": "circulation.set_running", "arg": "running"},
"stir": {"speed_cap": "stirring.set_speed", "speed_arg": "speed_rad_s", "on_cap": "stirring.set", "on_arg": "on"},
"safety-limit": {"cap": "safety.configure", "arg": "limit_K", "args": {"mode": "limit"}}},
"slots": {"temp": "thermal.indicated_temperature_k", "set": "setpoint.fixed#temperature_k",
"display": {"slot": "display.temperature", "unit_slot": "unit"}},
"requires": {"set-temp": [{"slot": "interface.remote", "value": true, "code": "REMOTE_OFF",
"message": "{inst} takes set points only in remote mode.", "fix": "`chemlab run {inst} remote on`."}]},
"codes": {"circulation.set_running:PRECONDITION_FAILED": {"code": "NOT_READY", "message": "...", "fix": "..."}, "UNSTABLE": {...}},
"unsupported": {"stir": "no stirrer: the bath is mixed by the circulation pump"},
"alternatives": {"stir": "what to do instead (shown as the fix)"},
"targets": {"zone": {"arg": "zone_index", "values": {"1": 0, "2": 1}}},
"locations": {"tray_01": {"position": 1}},
"path": "acquisition", "path_exceptions": ["sieving.measure"],
"params": {"tolerance_k": 0.5},
"notes": {"heat": ["shown in help INST heat"]}}}}
```
Keys a member may use: `verbs.<verb>` with `cap`, `arg`, `args` (fixed arguments), `<name>_cap` / `<name>_arg` for multi-call verbs,
`reads` (state slots, for read-only verbs); `slots.<role>` (slot id, `slot#key`, or `{"slot", "unit", "unit_slot"}`);
`requires`, `codes` (runtime code or `cap:CODE` -> class code, message, fix), `unsupported` (verb -> reason; every class verb a
member lacks needs one), `alternatives`, `hides` (shared verb -> reason, §5.3), `shared_fallthrough`, `targets`, `locations`,
`path` / `path_exceptions`, `params`, `notes` (INST is replaced by the instrument id), `role`, and `adapter` (a member-specific
subclass, rarely needed).
`requires` tests (base `requirements`; several tests in one entry must all hold; `"slot"` may be `slot#key`, or give `"key"`):
`value`, `not` (list), `in` (list), `prefix` (text or list of texts), `contains_not` (an item a list / text slot must not
contain), `min` / `max` (inclusive) / `gt` / `lt` (numbers; a missing value fails), `truthy`, `falsy`, `null`, `set` (not null); an
entry without a test asks for a truthy value. Message and fix may use `{inst}` and `{value}`.
Slot references in a mapping: `check_mapping` checks the values of keys named `slot`, `reads`, `slots_read` or ending in `_slot`
when they look like slot ids (`component.field`, optionally `#key`, or a visible slot id). Other values under such keys (a rack
slot `"A1"`, a number) are class data and are not checked. Never copy ranges, enums or units into a fragment: the adapter reads them
from the contract (`arg_range_si`, `arg_enum`, `arg_unit`). `check_mapping` verifies every capability (agent-visible and
implemented), argument name and slot against the contract at first use and in the tests.
Members are matched by asset type (`asset_type_id` without `instrument.`), so a lab may name its instruments freely ("flex",
"bal1", "bal2"). An entry that names its own `"adapter"` keeps it. The lab config switch `"class_adapters"`: `false` (none), a
directory path (other fragments), or a list of class names.
## 5. Rules
### 5.1 Units: convert to the unit each argument declares
The 203 contracts declare 145 unit strings; many arguments are not SI (°C / degC on 78 arguments, g, min, rpm, mL, mbar, nm, h,
days, %), and one unit is spelled several ways (m^3 / m3, °C / degC, 1/s / s^-1, ohm / Ω). `units.py` has the alias table
(`ALIASES`, `DECLARED` / `_DECL`: unit -> kind, factor, offset). Rules:
- Verbs parse what the agent types into SI (`Arg(kind='temperature')`, `Opt(kind='duration')`; bare numbers take the kind's default
unit: µL, °C, s, rpm, mbar, g). Kinds: volume, mass, length, wavelength, wavenumber (cm-1), duration (fs ... days), temperature,
temperature_delta, heating_rate, rotation, angle, pressure, flow, mass_flow, fraction, frequency (Hz ... GHz), frequency_offset
(signed Hz, e.g. NMR), count_rate (/s, kcps), magnetic_field (T, mT, G), power, voltage, current, force, energy, speed, area,
concentration (mol/L, mM, µM, nM, pM), density (also mass concentration: g/L, mg/L, µg/L, mg/mL, µg/m3), amount (mol, mmol, µmol,
nmol, pmol), conductivity. Flow also takes m3/h, L/h and standard flows (sccm, slpm / slm, sccs), fraction
ppm / ppb, force pN / nN / µN / mN / kN, energy eV / keV, power µW / mW / µcal/s / cal/s, duration us / µs / μs; the declared
unit `1/min` is rpm (Linari). Kinds field_rate (mT/s), force_rate (N/s), resistance (Ω, kΩ, MΩ), sheet_resistance (Ω/sq),
moment (emu, A·m²), heat_capacity (J/K) and number (plain) are framework kinds too. Add a missing unit to units.py (the shared
table), not as a local copy in a class.
- `units.fmt` never shows a non-zero value as 0: it moves to a smaller unit (1 Pa -> `1 Pa`, 5e-12 N -> `5 pN`, 2e-6 -> `2 ppm`;
durations under 0.05 s -> ms / µs; pressures below 1 mbar keep mbar with 3 significant digits, 5 Pa -> `0.05 mbar`;
kg/m³ below 100 shows as g/L, mg/L or µg/L, above as g/cm³; X-ray energies in keV / eV). `read` never shows a K slot that
holds a temperature difference (id or description says diff / delta / tdiff / 温差) in °C. Keep 15 significant digits when you round a native argument (`units.sig(x)`), never
`round(x, n)` (0.02° is 3.49e-4 rad; `round(.., 8)` breaks the runtime's grid check).
- Handlers convert SI into the argument's declared unit with `self.arg_value(cap, arg, si)` (or `units.parse_for(text, schema)`
in one step), and check ranges in SI with `self.arg_range_si(cap, arg)`. Never assume an argument is SI.
- Slots: `self.slot_si(values, spec)` gives SI for a slot in any declared unit, or a display slot whose unit is in another slot
(`{"slot": "display.temperature", "unit_slot": "unit"}` for BINDER C/F).
- A temperature difference is `temperature_delta` (0.5K == 0.5C), not a temperature. Gauge and absolute pressure are never
converted into each other: the argument name says which one it is.
- Tests on real arguments of several units are in `tests_compile/test_units.py` (`RealArguments`); add your class's odd units there
or in your class's own test file.
### 5.2 One native path per verb
Some instruments have two native paths for the same action (DMA 5002 / Abbemat `measurement.start` vs `acquisition.start`, HX204,
MP70, Selekt, Extrahera). A member's mapping picks one path, and the verbs of one group (`PATH_GROUPS`, e.g. start / stop /
result) use that path: their capabilities share one namespace (`"path"`, or the namespace of the first capability), and a result
read from slots reads slots that the start capability changes (its contract `state_effects`). Exceptions are explicit
(`"path_exceptions"`, which may also list state slots a result reads although the start capability's `state_effects` leave them
out, e.g. the 8697 `sequence.start`). Enforced statically by `check_paths` (in `check_mapping`) and dynamically by the lowering check
(`path_problems`). Prefer the acquisition core where both exist unless the manual path is the one the class
verbs mean.
### 5.3 Shared vocabulary, the shared layer and the override rule
`compile/shared.py` defines the shared verbs as factories and `SharedAdapter` (class `shared`):
| verb | lowers to (mapping key) |
|---|---|
| `power on\|off` | `power`: `{"cap": "power.set", "arg": "enabled"}` or a toggle `{"cap": "power.toggle", "toggle": true}` + `slots.power` |
| `status` | the class view (every adapter) |
| `open PART` / `close PART` | `open`: `{"parts": {"door": {"cap": "door.set", "arg": "angle_rad", "open": 1.57, "close": 0.0}, "lid": {"open_cap": "lid.open", "close_cap": "lid.close"}}}` |
| `ack` / `estop` | `{"cap": "alarm.acknowledge"}` / `{"cap": "emergency.stop"}` |
| `method KEY=VALUE ...` | `{"cap": "method.configure", "keys": {...class dictionary...}, "passthrough": true}` (§5.5) |
| `start` | `{"cap": "acquisition.start", "job": "operation" \| "state" \| "none", "state": {...}}` (§5.4) |
| `stop` / `result [--save-to F]` | `{"cap": ...}` / `{"cap": ...}` or `{"reads": [...]}` |
| `wait [--max T]` | the caller's latest job on the instrument |
`compile/shared_gen.py` generates `configs/adapters/shared.json` with `"layer": "shared"` for 198 instruments (`python -m chemlab.compile.shared_gen
--write`; never hand-edit it — `test_shared_all203` checks that the generator reproduces it): power 194, open/close 101 (138 named
parts), method 127, start 126, stop 118, result 108, ack 39, estop 21. The other five are the thin class (`configs/adapters/
thin.json`, `classes/thin.py`: oxitopi, puresolvmd, dmt152, Liberty Blue, oligosynt), reviewed by hand. If your class needs a
verb name the shared layer also has (power, open, close, ack, estop, method, start, stop, result, wait), your class verb wins on
your members; give it the same meaning. In `method`, a native argument name with a bare number takes the unit the contract
declares for it (`duration_s=60`); with a unit it is converted (`duration_s=1min`); class keys always take units. **Override rule:** an
instrument in a class fragment and in the shared fragment gets a CompositeAdapter: class fragments first (primary role before
secondary), the shared layer last; a verb belongs to the first part that supports it. So a class verb overrides the shared one,
and the shared layer still answers the verbs the class does not have (`tests_compile/test_shared.py`). **A class's "unsupported"
also wins over the shared layer:** a verb in your class table that a member marks unsupported (with its reason and
alternative) is answered by your class with exit 6 on that member, never by the shared layer — unless the member lists it in
`"shared_fallthrough": ["open"]`, which hands that verb back to the shared layer (e.g. a class that has no part table of its own
for `open`). **Hiding a shared verb:** a class that replaces a shared verb by its own (GPC `run` instead of `start`, TLC
`chromatogram` instead of `result`) declares it: class attribute `HIDES = {"start": "use `chemlab run INST run`"}` (all members) or
member `"hides": {"result": "..."}`; or name the replacing verb: class `COVERS = {"start": "measure"}` / member `"covers":
{"start": "measure"}` (reason: use `chemlab run INST measure`; it applies only on members where the covering verb is supported); the hidden verb answers exit 6 with that reason on those members, `run INST` lists it under
"not on this instrument", `help INST start` says what replaces it; `shared_fallthrough` undoes it per member.
**Ownership order on a composite instrument** (fragments.py `CompositeAdapter.owner`): (1) the first class part that supports
the verb (primary before secondary); (2) else a class part that marks it unsupported or hides it (its reason); (3) else the
shared layer. A class's "unsupported" therefore never blocks another class: on KS 4000 / Elma (agitation primary + thermal
secondary) agitation's `"unsupported": {"set-temp": ...}` leaves `set-temp` to thermal. Class modules may reuse the factories
(`self.table.update(shared.base_verbs(self))`).
**Shared `method` sends the full argument set** (most contracts require every argument of `method.configure`): the keys the
agent gives, the mapping's fixed `args`, and for every other required argument (and every argument chemlab sent last time) in
this order: what the instrument reports (a visible slot `<namespace>.<arg>` such as `method.mode`, or a key of a visible object
slot holding several arguments such as `method.current`), the last method chemlab sent on that capability (request log, any verb
or `chemlab call`), the contract's `example_arguments`. The reply names the source of every value it did not get from the agent
(`--json` `sources`); a required argument with no source is a usage error naming it; values outside the contract ranges are a
usage error (BAD_SETTING) before anything is sent. Helpers for classes: `shared.full_method_args(ad, ctx, cap, given, fixed)`,
`shared.reported_method`, `shared.last_sent`, `shared.method_sources_text`. The other generated shared verbs never need
arguments they do not supply (checked over all 198 members).
### 5.4 Jobs: three kinds of long action
| kind | when | class | status / wait / cancel |
|---|---|---|---|
| operation | an async capability returns an operation_id (most `*.start`) | `jobs.OperationJob` | poll / cancel of the session |
| run-type / state | progress only in slots (Flex protocol runs, furnace programmes, GC `run.start`, `cycle.start`) | `jobs.StateJob` (or a subclass, e.g. the liquid class's `RunJob`) | slot values; cancel = the class's stop call |
| timed state change | no run object (reach a set point, a stable reading) | `jobs.ConditionJob` | a condition on the state; cancel stops waiting (or `on_cancel`) |
A verb that starts a long action returns `job-N` (text and `--json` `job`). The agent follows it with the generic `chemlab status
job-N`, `chemlab wait job-N [--max T]`, `chemlab cancel job-N`; `chemlab status` lists the caller's jobs. Jobs belong to their
caller. In `--json` the job's `status` is the framework's (running / succeeded / failed / cancelled); the class's own word is in
`<kind>_status` (e.g. `run_status: completed`). Job states: `jobs.RUNNING` lists the known running words (incl. `injecting`,
`equilibrating`, `run`, `post`, ...), and any other text state that is not terminal (`jobs.TERMINAL`: completed, succeeded,
failed, cancelled, aborted, stopped, idle, ready, ...) also counts as running, so an unknown run phase keeps the job alive. An
operation whose poll says `succeeded` while its result names a known running phase (`phase: injecting`) is still running.
`OperationJob(..., poll_s=N)` (or the member's `"params": {"job_poll_s": N}`) sets the lab seconds between polls while waiting:
use 10-60 s where the runtime answers a poll with a whole curve. `self.wait_until(ctx, test, what, max_s, poll_s)` (with
`self.moving_done([slots])`) waits for a lid, sash, drawer or stage to stop moving; refused NOT_SETTLED when it does not. Blocking variants (`wait-temp`, `weigh --stable`, `set-temp --wait`) move lab
time with `ctx.advance` and say how long they waited.
### 5.5 Method keys per class
`method` is the hardest verb (chromatography alone has 9 method shapes). Each class defines a small dictionary of canonical keys
with units — e.g. chromatography `flow=1mL/min oven=40C..250C@10K/min inj=1uL wavelength=254nm`, spectroscopy `from=200nm to=800nm
step=1nm` — and each member maps them: `"method": {"cap": ..., "keys": {"flow": {"arg": "flow_ml_min", "kind": "flow"}}}`. Keys the
dictionary does not have pass through by native argument name (`"passthrough": true`), still parsed into the declared unit.
Document the dictionary in the class module docstring and in `help INST method`.
### 5.6 Named locations and `--zone / --channel / --cell / --head`
- A deck of labware (Flex): `deck.py` (`LABWARE:WELL`, lists, ranges in Opentrons order, trash, home), built from the lab-config
`"deck"` plus the contract's slot geometry; the trusted host's scene registers the same deck with the runtime.
- Other named places (autosampler trays, rack positions, robot ports): `self.location(ctx, name)` looks the name up in the lab
config entry's `"locations"` (task / lab specific) and then the mapping's `"locations"` (fixed by the instrument), with close
matches on a miss.
- Several identical units on one instrument: one option each, `--zone` (heating blocks, reactor pads), `--channel` (pumps, gas
lines), `--cell` (measuring cells), `--head` (measuring / dosing heads): `verbs.target_opt('zone')` in the verb and the member's
`"targets": {"zone": {"arg": NATIVE, "values": {"1": native, ...}, "required": false}}`; `self.target_args(ctx, parsed)` lowers
them. Do not invent per-class spellings (`--pad`, `--line`, ...).
### 5.7 Records: `--save-to FILE`
Verbs that return a record (results, spectra, chromatograms, images, a temperature log) take `--save-to FILE` (`save_to_opt()`):
the full reply is written as JSON into the agent's work dir (paths outside it are a usage error, nothing sent). Files the runtime
writes are already copied into the work dir by the generic layer.
### 5.8 Errors and refusals
Every error says what is wrong, how to fix it, whether the instrument changed and the steps done before it (composite verbs):
```
error[refused/UNSTABLE]: the reading of ohaus_px224e is not stable (a draft-shield door is open), so it cannot tare.
fix: close the doors (`chemlab run ohaus_px224e door close`), then retry with --wait 30s.
instrument changed: no
request: r-0001
```
Exit codes are the generic ones: 2 usage (nothing sent), 3 refused, 4 unexpected, 6 not supported on this instrument. Check what
you can before sending (class checks with `ctx.check`, member requirements in `requires`); when the runtime still refuses with a
generic code, `explain_refusal` names the reason from the member's `codes`, the class `CODES`, or the contract preconditions with
the state already read (`It checks ...; now ...`). Override `explain_refusal` only to infer a reason from the state (the balance
class turns the XPR's bare PRECONDITION_FAILED into UNSTABLE / POWER_OFF / ZERO_RANGE).
### 5.9 World set-up belongs to the host
What the lab operator does before the agent starts (fill a bath, register a sample, install a fixture, place a load) is
lab-config set-up (`"setup"` steps: capability calls as operator or `"evaluator": true`, `{"host": method, "kwargs": ...}`) or task
`world(lab)` code — never class verbs and never adapter code. Examples: `tasks/thermal_world.py` (JULABO bath model before power-on,
Elma tank fill), `tasks/balance_tasks.py` (`place`: pan.set_load as the evaluator, or the XPR cell's contact force). A runtime that
needs a trusted scene during the session (the Flex's tip confirmations) gets a scene class in the entry (`"scene":
"module:Class"`, `scenes/flex.py`).
**The default lab.** `configs/all203.json` is a ready lab: `chemlab/default_world.py` (generated by
`python -m chemlab.default_world_gen` from the class worlds: lowering `config()`s and, recorded as steps, the function worlds of
particle_surface and quant_analyzer) + `chemlab/default_world_overrides.py` (hand, with sources), merged by make_config. Its steps
carry `"default": GROUP` (utility, accessory, consumable, standard, state). A class world that needs a different start sets
`"default_world": false` on the entry (all default steps off, e.g. "_empty" variants, `W.bare`) or adds a step
`{"replace_default": [GROUP, ...]}`; a world step identical to a default step runs once. The lab's containers (bottles, standards,
consumables, cylinders) are in `configs/inventory_default.json` (`chemlab/inventory.py`; `chemlab list --inventory [ID]`). After a
class world changes: re-run the generator, then make_config, then `tests_generic/test_default_world.py`.
## 6. Pitfalls
- The default lab is a ready world (see 5.9): a task that tests a missing fixture or an empty cell must switch the default off
for that entry. Probe first; put the world in
tasks, the reason in `codes`.
- Lab time moves only with `chemlab wait` (or a verb that says it waits). Clock steps are applied lazily per instrument; a read
flushes them. A changed load or door shows up only after a clock step.
- The twin's own "stable" / "reached" flags can rise early (an older XPR twin said stable 1.5 s after a load change while 0.4 % low).
Waiting verbs add a settle check (two readings 1 s apart within 2 d) instead of trusting one flag.
- Member-specific rules hide in the contract preconditions and the runtime (JULABO only takes set points in remote mode; KS 4000
takes safety limits only with heating off; CellXpert set points in 0.1 °C steps; the SPX zero range counts from the calibration
zero). Turn each into a `requires` entry or a class check with a fix.
- Composite verbs report partial progress: do the checks that can fail before the first native call (e.g. stir checks the
fixture before setting the speed).
- Never call host methods from an adapter, never use the evaluator principal in a class, never put manual text into code or docs.
- A class module that fails to build its adapter (an exception in `__init__` / `build_verbs`) is left out of the lab and recorded
in `fragments.LOAD_ERRORS`, so other classes keep working; the class tests build adapters with `strict=True` and fail on it.
- A handler may raise the generic `usage(...)` (e.g. from `coerce`): it stays a usage error (exit 2), not INTERNAL.
- Write fragment files atomically (`fragments.write_json_atomic(path, obj)`: temp file + rename) from your generator: a lab
loading fragments while you rewrite one otherwise reads half a file (the loader retries once).
- Runtimes with no advance mode whose timed events run only in `host_update()` (Agilent 8697; DR6000 also syncs on access) get it
called after every clock step by the lab backend (`inst.clock_hook`); no scene is needed for that any more.
## 7. Lowering table and acceptance tasks
`tasks/<class>_lowering.py`:
```python
from .thermal_world import config # optional: the lab config with the class's world (else all203)
CASES = {'julabo_corio_cd200f': {'prep': None, 'steps': [
('set-temp 40C', []), # refused by a class check: no native call
('remote on', [('interface.set_remote', {'enabled': True})]),
('set-temp 40C', [('thermal.set_temperature', {'temperature_K': 313.15})]),
('#wait 2', None), # lab time passes on both labs
('wait-temp --max 30min', []),
]}}
```
Expected calls are written from the contracts (capability, arguments in the declared unit), not derived from the mapping. For
analysis steps whose arguments are measured arrays, an expected item may be `(capability, callable(arguments) -> bool)`, or the
whole expectation a `callable(calls) -> bool`; inside expected arguments the matchers `lowering.Measured()` (a finite number or
a non-empty list / object) and `lowering.Obs(n, fixed, measured)` (n observation objects: fixed fields equal, measured fields
present) stand for measured values; `None` means not checked (use it only for state-dependent calls). `('#host what', fn)` runs
`fn(backend)` on the lab and on the twin (the lab operator swaps a sample in the middle of a case) and compares their states. The
check runs each verb on a lab with adapters, compares the native calls, replays the same calls (same request ids) and clock
advances on a twin `LabBackend` without chemlab, and compares the instrument's full evaluator view after every step; it also
checks the one-path rule (on a composite instrument, each part only on the verbs it owns). Cover every verb of every member, refusals included (`[]`), a dry run, and an unsupported verb.
`tasks/<class>_tasks.py`: `TASKS = [{'id', 'kind', 'instruments', 'config' (fn(cfg) -> cfg, optional) or 'lab_config' (fn() ->
whole config), 'world' (fn(lab), optional), 'instruction', 'gold' (bash with `chemlab run`), 'check' (fn(c))}]` and
`main(only, noact)` returning `run_suite(...)`. Checkers read `c.ev(iid)` (evaluator view, truth slots included), `c.work_file()`,
`c.number_file()`; `c.near()`, `c.equal()`, `c.add()`. Gold must pass in the sandbox, NoAct must fail; include recovery tasks (the
gold triggers the error, reads `--json` `.error.code`, and recovers as the fix says). Results go to `compile_results/<class>/`.
## 8. Tests (all must pass before reporting)
```bash
cd Chemistry-Sim/chemlab/tests_compile
PY=python3 # Python 3.10+ with the runtime requirements (numpy < 2.4, scipy, pillow, ...)
$PY -m unittest test_units test_framework test_shared test_visibility # framework + visibility of every adapter output
$PY -m unittest test_class_<class> # mapping fits every contract, lowering, acceptance
CHEMLAB_PARITY_CLASSES=<class> $PY -m unittest test_generic_parity test_visibility # generic sweeps + visibility on your members
cd ../tests_generic && $PY -m unittest test_generic_core test_generic_sandbox test_mcp_shell # generic layer unchanged
cd .. && $PY -m unittest discover -s tests # the Flex pilot's gate and sandbox
```
`test_class_<class>.py` is two lines:
```python
from helpers import class_suite
ThermalClass = class_suite('thermal')
```
`test_generic_parity` runs `sweep.equivalence` and `sweep.ready` (with the visibility scan of describe / read output, now with
class sections) on the members of the class fragments — `CHEMLAB_PARITY_CLASSES=a,b` limits it to your classes — each run in its
own directory `build/compile_parity/<pid>-<time>/` (generic_results/ untouched), so runs at the same time never collide.
`test_visibility` takes the same filter. Lowering runs go to `build/lowering_runs/<class>/<instrument>/`. A mapping that does not
fit its contract never breaks the generic commands of that instrument (they fall back to the generic path; `chemlab run` answers
MAPPING_ERROR), but `test_class_<class>` fails on it.
## 9. Coverage and examples
All 203 instruments have `chemlab run` verbs: 198 have a primary class (3 of them also a secondary class), 5 are in the thin
class (shared verbs only, reviewed by hand) and the shared layer adds the common verbs wherever a contract has them. The 30
classes are agitation, balance, bioassay, chromatography, coating, digestion, dosing, electrical, electrochem, enclosure,
evaporation, extraction, formulation, gas_fluid, imaging, labware_automation, liquid, mechanical, particle_surface,
property_meter, quant_analyzer, reactor, sample_intro, solid_prep, spectroscopy, structure, thermal, thermal_analysis,
titration and wash_sterilize (one fragment each in `configs/adapters/`).
Small classes to read first: `balance` (3 members: power, zero, tare, weigh [--stable], unit, door, status) and `thermal`
(set-temp [--wait], heat, temp, wait-temp, stir, safety-limit, remote, power, status). A member may bring its own adapter class
(`"adapter"` in its fragment entry), as the NE-1000 syringe pump does inside `liquid` (`classes/syringe_pump.py`).
Twins refuse to stop or change another caller's run (ACCESS_DENIED): the classes say NOT_YOURS, and their BUSY fix says to
wait instead of stop when the run is not the caller's job.