# 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/.py` — verb table, handlers, class checks, summary | one module per class | | its mapping | `configs/adapters/.json` — one fragment per class, members and per-instrument data | one fragment per class | | host-side world | `chemlab/compile/tasks/_world.py` (lab-config set-up steps), `chemlab/compile/scenes/.py` (only if the runtime needs a trusted scene, like the Flex) | per class | | lowering table | `chemlab/compile/tasks/_lowering.py` | per class | | acceptance tasks | `chemlab/compile/tasks/_tasks.py` | per class | | tests | `tests_compile/test_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/_tasks.py`, `tasks/_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 ` 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 --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 ` 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 `. 7. **Tests**: `tests_compile/test_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/.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.` with `cap`, `arg`, `args` (fixed arguments), `_cap` / `_arg` for multi-call verbs, `reads` (state slots, for read-only verbs); `slots.` (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 `.` 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 `_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/_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/_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//`. ## 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_ # mapping fits every contract, lowering, acceptance CHEMLAB_PARITY_CLASSES= $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_.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/-