AccordionQ2 Python Client

Python client library for the AccordionQ2 Hardware Management REST API. This is the Python counterpart of the .NET WebApiClient; both libraries expose the same API surface so switching between them feels natural.

Requirements

Installation

Install from PyPI:

pip install accordionq2

Using uv (recommended)

# Install the package
uv add accordionq2

# Or install from a local checkout with dev dependencies
uv sync --dev

pip (local checkout)

pip install -e .

Quick Start

from accordionq2 import AccordionQ2Client

with AccordionQ2Client("http://agent64.local:5000") as client:
    # Check the hardware connection
    status = client.connection.get_status()
    print("Connected:", status.is_connected)

    # Read a sensor value
    temp = client.resources.get_value("TempRegulator.CPU_TEMP")
    print("CPU temperature:", temp)

    # List all channels
    for ch in client.channels.get_all():
        print(f"  {ch.alias}: type={ch.channel_type}, unit={ch.unit}")

The client can also be used without a with block:

client = AccordionQ2Client("http://agent64.local:5000")
names = client.resources.get_names()
client.close()

Constructor

AccordionQ2Client(base_url, timeout=30.0, auth=None, verify=True, default_headers=None)

# HTTP Basic Auth
client = AccordionQ2Client("https://device.local:5001", auth=("admin", "secret"))

# Self-signed certificate — disable TLS verification
client = AccordionQ2Client("https://device.local:5001", verify=False)

# API key header
client = AccordionQ2Client("http://device.local:5000",
                           default_headers={"X-Api-Key": "my-api-key"})

API Reference

The client exposes groups, each covering one area of the hardware API; the main ones are below, and the documentation covers them all, including calibration, instruments, events and subscriptions, and the audit log. All methods are synchronous and raise AccordionQ2ApiError on HTTP errors.

client.connection — Connection Status

status = client.connection.get_status()
if not status.is_connected:
    print("Error:", status.last_error)

client.resources — Resource Values

Resources represent readable/writable hardware values such as voltages, temperatures, and firmware revisions. They are identified by a dotted name string (e.g. "TempRegulator.CPU_TEMP").

# Single read
voltage = client.resources.get_value("0.1.ESH10000158.MON_3V3")

# Batch read
values = client.resources.get_values([
    "TempRegulator.CPU_TEMP",
    "Engine.Uptime",
])
for name, val in values.items():
    print(f"{name} = {val}")

client.channels — Hardware Channels

Channels represent multi-purpose I/O pins (analog, digital, I2C, SPI, etc.).

from accordionq2.models import ChannelConfigRequest
from accordionq2.enums import ChannelTypes

# Look up by alias
ch = client.channels.get_channel(alias="0.1.ESH10000158.MON_3V3")
print(f"Type: {ch.channel_type}, Direction: {ch.direction}")

# Check flags
if ch.channel_type & ChannelTypes.ANALOG:
    print("This is an analog channel")

# Partial update (only the fields you set are changed)
client.channels.configure(ChannelConfigRequest(
    alias="0.1.ESH10000158.MON_3V3",
    description="Main 3.3 V rail monitor",
    unit="V",
))

client.modules — Module Management

system = client.modules.get_physical_system()
print(f"Host: {system.host}, MAC: {system.mac}")
for mod in system.modules:
    print(f"  Slot {mod.index}: {mod.name} ({mod.product_id})")

for m in client.modules.get_loaded():
    print(f"  {m.name} (enabled={m.enabled})")

client.application — Application Lifecycle

from accordionq2.enums import ModuleStatus

status = client.application.get_status()
if status == ModuleStatus.OK:
    print("Application is running normally")

# Configuration file round-trip
data = client.application.download_config_file("factory.cfg")
client.application.upload_config_file("factory_backup.cfg", data)

client.media — Media Files

for f in client.media.list_files():
    print(f)

# Download and save locally
content = client.media.download_file("waveform.bin")
with open("waveform.bin", "wb") as fp:
    fp.write(content)

client.comm — Raw Bus Transactions (I2C, UART, SPI, Socket)

All byte data is hex-encoded on the wire. The client handles encoding and decoding transparently — callers work with plain bytes objects. BusTransactionResponse.received is always bytes.

I2C parameters:

from accordionq2.enums import BusActions

# I2C: scan the bus for connected devices
resp = client.comm.i2c("0.ESH10000597.I2C00", address=0x00,
                       action=BusActions.SCAN)
for addr in resp.received:
    print(f"Found device at 0x{addr:02X}")

# I2C: write two bytes to address 0x50
client.comm.i2c("0.ESH10000597.I2C00", address=0x50,
                action=BusActions.SEND,
                data_to_send=bytes([0x00, 0x10]))

# I2C: read 4 bytes from address 0x50
resp = client.comm.i2c("0.ESH10000597.I2C00", address=0x50,
                       action=BusActions.RECEIVE,
                       number_of_bytes_to_receive=4)
print(resp.received.hex())  # e.g. "aabbccdd"

# UART: send a SCPI query and read the response
resp = client.comm.uart("MyUartDevice",
                        action=BusActions.SEND_RECEIVE,
                        data_to_send=b"*IDN?\n",
                        number_of_bytes_to_receive=64,
                        timeout_ms=2000)
print(resp.received.decode("ascii"))

# SPI: full-duplex transfer
resp = client.comm.spi("MySpiDevice",
                       action=BusActions.SEND_RECEIVE,
                       data_to_send=bytes([0xAA, 0xBB]),
                       number_of_bytes_to_receive=2)

# Socket: send a SCPI query over TCP
resp = client.comm.socket("MySocketDevice",
                          action=BusActions.SEND_RECEIVE,
                          host_name="192.168.1.10", port=5025,
                          data_to_send=b"*IDN?\n",
                          number_of_bytes_to_receive=64)

client.numeric_results — Fast Numeric Sampling

NumericResult channels perform high-speed acquisition on physical channels, computing summary statistics (mean, min, max, stdev) server-side.

Typical workflow:

# 1. Discover available NumericResult channels
channels = client.numeric_results.get_channels()
for ch in channels:
    print(f"{ch.net_name} (rate={ch.sample_rate} Hz)")

# 2. Check what a channel can sample
targets = client.numeric_results.get_targets(channels[0].net_name)
print("Available targets:", targets)

# 3. Trigger acquisition (result cached server-side)
meta = client.numeric_results.measure(
    channels[0].net_name, targets[0],
    samples=1000, reduced_set=True)
print(f"Acquired {meta.sample_count} samples in {meta.duration}")

# 4. Fetch summary statistics
mean  = client.numeric_results.get_mean(channels[0].net_name)
stdev = client.numeric_results.get_stdev(channels[0].net_name)
print(f"Mean = {mean:.6f}, StdDev = {stdev:.6f}")

# 5. For raw samples, use reduced_set=False
meta = client.numeric_results.measure(
    channels[0].net_name, targets[0],
    samples=100, reduced_set=False)
samples = client.numeric_results.get_samples(channels[0].net_name)
print(f"First 5 samples: {samples[:5]}")

client.lease — Control Lease

One client at a time may change the station, typically a test station for the length of a sequence. While another client holds the lease, this client's changes and forced reads raise AccordionQ2ApiError with status 423; reads with max_age_ms and subscriptions keep working.

with client.lease.hold("TAT station 3"):
    client.resources.set_value("0.4.ESH10000662.VSET1", "5")

client.system — Services, Reboot, Clock and boot.config

boot.config changes apply at the hardware app's next start (alias files and modules also on a reset). if_modified gives 409 instead of overwriting another edit, and the Wi-Fi password is never returned.

from accordionq2 import BootAliasFile

client.system.boot.set_startup(enabled=True,
                               alias_files=[BootAliasFile("station.csv")])
client.system.set_clock()

client.files — Station Files

Files in the station's folders (config, alias, fsms, media, extensions, and the read-only logs and webapi-logs).

data = client.files.download("alias", "station.csv")
client.files.upload("alias", "station_backup.csv", data)

client.firmware — Firmware Updates

The station installs only releases signed by E-Sharp, checked on the station whichever way the package arrives, and nothing below 6.0.0. Installing restarts the hardware app and the WebApi; install() and install_package() keep polling until the update has ended.

releases = client.firmware.get_releases()
newest = next(r for r in releases.releases if r.installable)
status = client.firmware.install(newest.version)
if status.state != "succeeded":
    print(status.state, status.message)
    print(client.firmware.get_update_log())

# A station without internet
client.firmware.install_package("C:/releases/rel-6.0.0.zip")

Models

All models live in accordionq2.models.

The lease, system, boot.config, files and firmware models (LeaseDto, ServiceStatus, ClockStatus, BootConfig, BootAliasFile, BootModule, BootAddress, BootService, BootWifi, FileRoot, FileListing, FileEntry, FirmwareState, FirmwareSource, FirmwareReleases, FirmwareRelease, FirmwareUpdateStatus) live in their groups' modules and are importable from the top-level accordionq2 package.

Response models provide a from_dict(data) class method; request models provide a to_dict() instance method.

All response models are immutable (frozen=True) — fields cannot be modified after construction. Create a new instance if you need a different value.

Enumerations

All enums live in accordionq2.enums.

IntFlag enums support bitwise operations:

from accordionq2.enums import ChannelTypes, DirectionTypes

combined = ChannelTypes.ANALOG | ChannelTypes.DIGITAL
if ch.channel_type & ChannelTypes.I2C:
    print("I2C channel")

if ch.direction & DirectionTypes.IN:
    print("Input capable")

Error Handling

All API errors raise AccordionQ2ApiError (importable from the top-level package). The exception carries the HTTP status code and the server's error message:

from accordionq2 import AccordionQ2ApiError

try:
    ch = client.channels.get_channel(alias="does.not.exist")
except AccordionQ2ApiError as e:
    print(f"HTTP {e.status_code}: {e}")

Running the Tests

The test suite uses pytest.

Using uv (recommended)

# Install dev dependencies and run all unit tests
uv sync --dev
uv run pytest tests/unit/ -v

Using pip

# Install with test dependencies
pip install -e ".[dev]"

Unit Tests (no hardware required)

pytest tests/unit/ -v

Unit tests use mocks and run entirely offline.

Integration Tests (live device required)

# Requires a live AccordionQ2 device
ACCORDIONQ2_API_URL=http://mydevice:5000 pytest tests/ -m integration -v

On Windows (PowerShell):

$env:ACCORDIONQ2_API_URL = "http://mydevice.local:5000"
pytest tests/ -m integration -v

Comparison with the .NET Client

Both clients expose the same API surface with idiomatic naming for their respective language:

License

Proprietary — see your license agreement for details.