striqt.sensor.specs

schema for the specification of calibration and sweeps

class striqt.sensor.specs.AcquiredIQ(pre_align: Array, pre_filter: Array | None, aligned: Array | None, capture: specs.Capture | None, info: structs.AcquisitionInfo, extra_data: dict[str, Any], source_spec: structs.Source, resampler: sw.ResamplerDesign, format_path: helpers.PathFormatter | None = None, voltage_scale: sw.typing.Array | float = 1)

Bases: AcquiredIQ

extra metadata needed for downstream analysis

extra_data: dict[str, Any]

format_path: helpers.PathFormatter | None = None

info: structs.AcquisitionInfo

resampler: sw.ResamplerDesign

source_spec: structs.Source

voltage_scale: sw.typing.Array | float = 1

class striqt.sensor.specs.AcquisitionInfo(*, source_id='', sweep_index=None, capture_index=0)

Bases: Struct

information about an acquired acquisition

Parameters:

• source_id (str) – Source UUID string

• sweep_index (int | None)

• capture_index (int)

classmethod from_dict(d: dict) → _T

replace(**attrs) → _Self

returns a copy of self with changed attributes.

See also

Python standard library copy.replace

to_dict() → dict

return a dictinary representation of self

class striqt.sensor.specs.AnalysisGroup

Bases: SpecBase

base class for a defining set of Analysis specs

striqt.sensor.specs.BundledAnalysis

alias of Analysis

striqt.sensor.specs.BundledTriggers

alias of Analysis

class striqt.sensor.specs.CalibrationSweep(*, source, captures=(), loops=(), analysis=Analysis(cellular_5g_pss_sync=None, cellular_5g_pss_correlation=None, cellular_5g_ssb_spectrogram=None, cellular_5g_sss_sync=None, cellular_5g_sss_correlation=None, cellular_cyclic_autocorrelation=None, channel_power_time_series=None, channel_power_histogram=None, spectrogram=None, cellular_resource_power_histogram=None, cyclic_channel_power=None, iq_waveform=None, power_spectral_density=None, spectrogram_histogram=None, spectrogram_ratio_histogram=None), description=Description(summary=None, version='unversioned'), adjust_captures={}, extensions=Extension(sink=None, import_path=None, import_name=None), sink=Sink(path='{yaml_name}-{start_time}', log_path=None, log_level='info', store='directory', max_threads=None, batched_write_count=1, max_chunk_bytes=50000000), peripherals=Peripherals(), options=SweepOptions(reuse_iq=True, loop_only_nyquist=True, skip_warmup=True), calibration=None)

Bases: Sweep[SS, SP, SC], Generic[SS, SP, SC, SPC]

This specialized sweep is fed to the YAML file loader to specify the change in expected capture structure.

Parameters:

• source (striqt.sensor.lib.typing.SS)

• captures (tuple[striqt.sensor.lib.typing.SC, ...])

• loops (tuple[striqt.sensor.specs.Repeat | striqt.sensor.specs.List | striqt.sensor.specs.Range | striqt.sensor.specs.FrequencyBinRange, ...])

• analysis (striqt.analysis.lib.register.Analysis)

• description (striqt.sensor.specs.Description)

• adjust_captures (dict[str | one of ['defaults'], dict[str, striqt.sensor.specs.CaptureRemap | float | int | str | bool | None] | tuple[str, striqt.sensor.specs.CaptureRemap | float | int | str | bool | None]]) – Source UUID string

• extensions (striqt.sensor.specs.Extension)

• sink (striqt.sensor.specs.Sink)

• peripherals (striqt.sensor.lib.typing.SP)

• options (striqt.sensor.specs.SweepOptions)

• calibration (striqt.sensor.lib.typing.SPC | None)

Variables:

_binding (Any)

class striqt.sensor.specs.Capture(*, duration=0.1, sample_rate=15360000.0, analysis_bandwidth=inf)

Bases: SpecBase

bare minimum information about an IQ acquisition

Parameters:

• duration (float) – Duration of the analysis waveform (Constraints: units: s)

• sample_rate (float) – Analysis sample rate (Constraints: units: S/s)

• analysis_bandwidth (float) – Analysis bandwidth (Constraints: units: Hz)

class striqt.sensor.specs.CaptureRemap(*, key, lookup, required=True, default=UNSET)

Bases: SpecBase

Parameters:

• key (str | tuple[str, ...])

• lookup (dict[tuple[Any, ...] | Any, Any])

• required (bool)

• default (Any)

class striqt.sensor.specs.Description(*, summary=None, version='unversioned')

Bases: SpecBase

Parameters:

• summary (str | None)

• version (str)

class striqt.sensor.specs.DiracDeltaCapture(*, duration=0.1, sample_rate=15360000.0, analysis_bandwidth=inf, port, lo_shift='none', host_resample=True, backend_sample_rate=None, adjust_analysis={}, time=0, power=0)

Bases: SensorCapture

Parameters:

• duration (float) – Duration of the analysis waveform (Constraints: units: s)

• sample_rate (float) – Analysis sample rate (Constraints: units: S/s)

• analysis_bandwidth (float) – Analysis bandwidth (Constraints: units: Hz)

• port (int | tuple[int, ...]) – Input port indices (Constraints: >= 0, >= 0)

• lo_shift (one of ['left', 'right', 'none']) – LO shift direction

• host_resample (bool)

• backend_sample_rate (float | None) – Source sample rate (Constraints: > 0, units: Hz)

• adjust_analysis (dict[str, Any]) – changes to apply across each analysis for any matching parameter

• time (float) – start time offset (Constraints: units: s)

• power (float) – peak power level (Constraints: units: dB)

class striqt.sensor.specs.Extension(*, sink=None, import_path=None, import_name=None)

Bases: SpecBase

Parameters:

• sink (str | one of ['striqt.sensor.sinks.CaptureAppender'] | None) – Data sink class that implements data storage

• import_path (str | None) – path to append to sys.path before extension imports

• import_name (str | None) – name of the extension module that calls bind_sensor

class striqt.sensor.specs.FileAcquisitionInfo(*, source_id='', sweep_index=None, capture_index=0, center_frequency=nan, backend_sample_rate, port=0, gain=nan)

Bases: AcquisitionInfo

Parameters:

• source_id (str) – Source UUID string

• sweep_index (int | None)

• capture_index (int)

• center_frequency (float | tuple[float, ...]) – Center frequency for each port (Constraints: units: Hz, > 0, units: Hz, > 0, units: Hz)

• backend_sample_rate (float) – Source sample rate (Constraints: > 0, units: Hz)

• port (int | tuple[int, ...]) – Input port indices (Constraints: >= 0, >= 0)

• gain (float | tuple[float, ...]) – Gain setting for each channel (Constraints: units: dB, units: dB, units: dB)

class striqt.sensor.specs.FileCapture(*, duration=0.1, sample_rate=15360000.0, analysis_bandwidth=inf, port, lo_shift='none', host_resample=True, backend_sample_rate=None, adjust_analysis={})

Bases: SensorCapture

Capture specification read from a file, with support for None sentinels

Parameters:

• duration (float) – Duration of the analysis waveform (Constraints: units: s)

• sample_rate (float) – Analysis sample rate (Constraints: units: S/s)

• analysis_bandwidth (float) – Analysis bandwidth (Constraints: units: Hz)

• port (int | tuple[int, ...]) – Input port indices (Constraints: >= 0, >= 0)

• lo_shift (one of ['left', 'right', 'none']) – LO shift direction

• host_resample (bool)

• backend_sample_rate (float | None) – Source sample rate (Constraints: > 0, units: Hz)

• adjust_analysis (dict[str, Any]) – changes to apply across each analysis for any matching parameter

class striqt.sensor.specs.FrequencyBinRange(*, field, isin='capture', start, stop, step)

Bases: LoopBase

Parameters:

• field (str)

• isin (one of ['capture', 'analysis']) – selects whether to loop a capture or analysis parameters

• start (float)

• stop (float)

• step (float)

get_points() → list[float]

class striqt.sensor.specs.FunctionSource(*, master_clock_rate, trigger_strobe=None, signal_trigger=None, array_backend='numpy', num_rx_ports)

Bases: Source

Parameters:

• master_clock_rate (float) – Base sample rate used inside the source (Constraints: > 0, units: Hz)

• trigger_strobe (float | None)

• signal_trigger (str | striqt.analysis.specs.AnalysisGroup | None)

• array_backend (one of ['numpy', 'cupy']) – array module to use to set compute device: numpy = cpu, cupy = gpu

• num_rx_ports (int)

Variables:

• transient_holdoff_time (float) – (Value: 0)

• stream_all_rx_ports (bool) – (Value: False)

• transport_dtype (one of ['int16', 'float32', 'complex64']) – data transfer type to use inside the source (Value: complex64)

class striqt.sensor.specs.List(*, field, isin='capture', values)

Bases: LoopBase

Parameters:

• field (str)

• isin (one of ['capture', 'analysis']) – selects whether to loop a capture or analysis parameters

• values (tuple[dict[str | one of ['defaults'], dict[str, striqt.sensor.specs.CaptureRemap | float | int | str | bool | None] | tuple[str, striqt.sensor.specs.CaptureRemap | float | int | str | bool | None]] | str | float | int | bool | None, ...]) – Source UUID string

get_points() → list

class striqt.sensor.specs.LoopBase(*, field, isin='capture')

Bases: SpecBase

Parameters:

• field (str | None)

• isin (one of ['capture', 'analysis']) – selects whether to loop a capture or analysis parameters

get_points() → list

class striqt.sensor.specs.MATSource(*, master_clock_rate, trigger_strobe=None, signal_trigger=None, array_backend='numpy', path, file_format='auto', file_metadata=None, loop=False)

Bases: Source

Parameters:

• master_clock_rate (float) – Base sample rate used inside the source (Constraints: > 0, units: Hz)

• trigger_strobe (float | None)

• signal_trigger (str | striqt.analysis.specs.AnalysisGroup | None)

• array_backend (one of ['numpy', 'cupy']) – array module to use to set compute device: numpy = cpu, cupy = gpu

• path (str) – path to the waveform data file

• file_format (one of ['auto', 'mat', 'tdms']) – data format or auto to guess by extension

• file_metadata (dict[str, Any] | None) – any capture fields not included in the file

• loop (bool) – whether to loop the file to create longer IQ waveforms

Variables:

• transient_holdoff_time (float) – (Value: 0)

• stream_all_rx_ports (bool | None) – (Value: False)

• transport_dtype (one of ['int16', 'float32', 'complex64']) – data transfer type to use inside the source (Value: complex64)

class striqt.sensor.specs.ManualYFactorPeripheral(*, enr, ambient_temperature)

Bases: Peripherals

Parameters:

• enr (float) – Excess noise ratio (Constraints: units: dB)

• ambient_temperature (float) – Ambient temperature (Constraints: units: K)

striqt.sensor.specs.Meta(standard_name: str, units: str | None = None, **kws) → Meta

annotation that is used to generate ‘standard_name’ and ‘units’ fields of xarray attrs objects

class striqt.sensor.specs.NoPeripherals

Bases: Peripherals

class striqt.sensor.specs.NoSource(*, master_clock_rate, trigger_strobe=None, signal_trigger=None, array_backend='numpy', num_rx_ports)

Bases: Source

Parameters:

• master_clock_rate (float) – Base sample rate used inside the source (Constraints: > 0, units: Hz)

• trigger_strobe (float | None)

• signal_trigger (str | striqt.analysis.specs.AnalysisGroup | None)

• array_backend (one of ['numpy', 'cupy']) – array module to use to set compute device: numpy = cpu, cupy = gpu

• num_rx_ports (int)

Variables:

• transient_holdoff_time (float) – (Value: 0)

• stream_all_rx_ports (bool) – (Value: False)

• transport_dtype (one of ['int16', 'float32', 'complex64']) – data transfer type to use inside the source (Value: float32)

class striqt.sensor.specs.NoiseCapture(*, duration=0.1, sample_rate=15360000.0, analysis_bandwidth=inf, port, lo_shift='none', host_resample=True, backend_sample_rate=None, adjust_analysis={}, noise_psd=1e-17)

Bases: SensorCapture

Parameters:

• duration (float) – Duration of the analysis waveform (Constraints: units: s)

• sample_rate (float) – Analysis sample rate (Constraints: units: S/s)

• analysis_bandwidth (float) – Analysis bandwidth (Constraints: units: Hz)

• port (int | tuple[int, ...]) – Input port indices (Constraints: >= 0, >= 0)

• lo_shift (one of ['left', 'right', 'none']) – LO shift direction

• host_resample (bool)

• backend_sample_rate (float | None) – Source sample rate (Constraints: > 0, units: Hz)

• adjust_analysis (dict[str, Any]) – changes to apply across each analysis for any matching parameter

• noise_psd (float) – noise total channel power (Constraints: >= 0, units: mW/Hz)

class striqt.sensor.specs.Peripherals

Bases: SpecBase

class striqt.sensor.specs.Range(*, field, isin='capture', start, stop, step)

Bases: LoopBase

Parameters:

• field (str)

• isin (one of ['capture', 'analysis']) – selects whether to loop a capture or analysis parameters

• start (float)

• stop (float)

• step (float)

get_points() → list

class striqt.sensor.specs.Repeat(*, field=None, isin='capture', count=1)

Bases: LoopBase

Parameters:

• field (None)

• isin (one of ['capture', 'analysis']) – selects whether to loop a capture or analysis parameters

• count (int)

get_points() → list[int]

class striqt.sensor.specs.SawtoothCapture(*, duration=0.1, sample_rate=15360000.0, analysis_bandwidth=inf, port, lo_shift='none', host_resample=True, backend_sample_rate=None, adjust_analysis={}, period=0.01, power=0)

Bases: SensorCapture

Parameters:

• duration (float) – Duration of the analysis waveform (Constraints: units: s)

• sample_rate (float) – Analysis sample rate (Constraints: units: S/s)

• analysis_bandwidth (float) – Analysis bandwidth (Constraints: units: Hz)

• port (int | tuple[int, ...]) – Input port indices (Constraints: >= 0, >= 0)

• lo_shift (one of ['left', 'right', 'none']) – LO shift direction

• host_resample (bool)

• backend_sample_rate (float | None) – Source sample rate (Constraints: > 0, units: Hz)

• adjust_analysis (dict[str, Any]) – changes to apply across each analysis for any matching parameter

• period (float) – waveform period (Constraints: >= 0, units: s)

• power (float) – peak power level (Constraints: units: dB)

class striqt.sensor.specs.Schema(source: 'type[SS]', capture: 'type[SC]', peripherals: 'type[SP]', init_like: 'Callable[PS, Any]', arm_like: 'Callable[PC, Any]')

Bases: Generic[SS, SP, SC, PS, PC]

arm_like: Callable[PC, Any]

capture: type[SC]

init_like: Callable[PS, Any]

peripherals: type[SP]

source: type[SS]

class striqt.sensor.specs.SensorCapture(*, duration=0.1, sample_rate=15360000.0, analysis_bandwidth=inf, port, lo_shift='none', host_resample=True, backend_sample_rate=None, adjust_analysis={})

Bases: Capture

Capture specification for a generic waveform with resampling support

Parameters:

• duration (float) – Duration of the analysis waveform (Constraints: units: s)

• sample_rate (float) – Analysis sample rate (Constraints: units: S/s)

• analysis_bandwidth (float) – Analysis bandwidth (Constraints: units: Hz)

• port (int | tuple[int, ...]) – Input port indices (Constraints: >= 0, >= 0)

• lo_shift (one of ['left', 'right', 'none']) – LO shift direction

• host_resample (bool)

• backend_sample_rate (float | None) – Source sample rate (Constraints: > 0, units: Hz)

• adjust_analysis (dict[str, Any]) – changes to apply across each analysis for any matching parameter

class striqt.sensor.specs.SingleToneCapture(*, duration=0.1, sample_rate=15360000.0, analysis_bandwidth=inf, port, lo_shift='none', host_resample=True, backend_sample_rate=None, adjust_analysis={}, frequency_offset=0, snr=None)

Bases: SensorCapture

Parameters:

• duration (float) – Duration of the analysis waveform (Constraints: units: s)

• sample_rate (float) – Analysis sample rate (Constraints: units: S/s)

• analysis_bandwidth (float) – Analysis bandwidth (Constraints: units: Hz)

• port (int | tuple[int, ...]) – Input port indices (Constraints: >= 0, >= 0)

• lo_shift (one of ['left', 'right', 'none']) – LO shift direction

• host_resample (bool)

• backend_sample_rate (float | None) – Source sample rate (Constraints: > 0, units: Hz)

• adjust_analysis (dict[str, Any]) – changes to apply across each analysis for any matching parameter

• frequency_offset (float) – Baseband frequency offset (Constraints: units: Hz)

• snr (float | None) – Add circular white gaussian noise to achieve this SNR (Constraints: units: dB)

class striqt.sensor.specs.Sink(*, path='{yaml_name}-{start_time}', log_path=None, log_level='info', store='directory', max_threads=None, batched_write_count=1, max_chunk_bytes=50000000)

Bases: SpecBase

Parameters:

• path (str)

• log_path (str | None)

• log_level (str)

• store (one of ['zip', 'directory']) – serialization output format of the sink

• max_threads (int | None)

• batched_write_count (int)

• max_chunk_bytes (int)

class striqt.sensor.specs.SoapyAcquisitionInfo(*, source_id='', sweep_index=None, capture_index=0, sweep_start_time=None, start_time, backend_sample_rate)

Bases: AcquisitionInfo

extra coordinate information returned from an acquisition

Parameters:

• source_id (str) – Source UUID string

• sweep_index (int | None)

• capture_index (int)

• sweep_start_time (pandas.Timestamp | None) – Capture acquisition start time

• start_time (pandas.Timestamp | None) – Acquisition start time of the first capture

• backend_sample_rate (float | None) – Source sample rate (Constraints: > 0, units: Hz)

class striqt.sensor.specs.SoapyCapture(*, duration=0.1, sample_rate=15360000.0, analysis_bandwidth=inf, port, lo_shift='none', host_resample=True, backend_sample_rate=None, adjust_analysis={}, center_frequency, gain)

Bases: SensorCapture

Parameters:

• duration (float) – Duration of the analysis waveform (Constraints: units: s)

• sample_rate (float) – Analysis sample rate (Constraints: units: S/s)

• analysis_bandwidth (float) – Analysis bandwidth (Constraints: units: Hz)

• port (int | tuple[int, ...]) – Input port indices (Constraints: >= 0, >= 0)

• lo_shift (one of ['left', 'right', 'none']) – LO shift direction

• host_resample (bool)

• backend_sample_rate (float | None) – Source sample rate (Constraints: > 0, units: Hz)

• adjust_analysis (dict[str, Any]) – changes to apply across each analysis for any matching parameter

• center_frequency (float | tuple[float, ...]) – Center frequency for each port (Constraints: units: Hz, > 0, units: Hz, > 0, units: Hz)

• gain (float | tuple[float, ...]) – Gain setting for each channel (Constraints: units: dB, units: dB, units: dB)

class striqt.sensor.specs.SoapySource(*, master_clock_rate, trigger_strobe=None, signal_trigger=None, array_backend='numpy', calibration=None, time_source='host', time_sync_at='acquire', clock_source='internal', receive_retries=0, adc_overload_limit=-1, if_overload_limit=None, gapless=False)

Bases: Source

Parameters:

• master_clock_rate (float) – Base sample rate used inside the source (Constraints: > 0, units: Hz)

• trigger_strobe (float | None)

• signal_trigger (str | striqt.analysis.specs.AnalysisGroup | None)

• array_backend (one of ['numpy', 'cupy']) – array module to use to set compute device: numpy = cpu, cupy = gpu

• calibration (str | None)

• time_source (one of ['host', 'internal', 'external', 'gps']) – Hardware source for timestamps

• time_sync_at (one of ['open', 'acquire']) – when to sync the hardware clock: on connection, or before each capture

• clock_source (one of ['internal', 'external', 'gps']) – Hardware source for the frequency reference

• receive_retries (int) – number of acquisition retry attempts on stream error (Constraints: >= 0)

• adc_overload_limit (float | None) – dataset adc_overload=True when the peak ADC level exceeds this threshold (Constraints: <= 0, units: dBfs)

• if_overload_limit (float | None) – the maximum level at maximum gain before IF/baseband overload (Constraints: units: dBfs)

• gapless (bool) – whether to raise an exception on overflows between identical captures

Variables:

• transient_holdoff_time (float) – (Value: 0)

• stream_all_rx_ports (bool | None) – (Value: False)

• transport_dtype (one of ['int16', 'float32', 'complex64']) – data transfer type to use inside the source (Value: float32)

rx_enable_delay = 0.0

shared_rx_sample_clock = True

class striqt.sensor.specs.Source(*, master_clock_rate, trigger_strobe=None, signal_trigger=None, array_backend='numpy')

Bases: SpecBase

run-time characteristics of the radio that are left invariant during a sweep

Parameters:

• master_clock_rate (float) – Base sample rate used inside the source (Constraints: > 0, units: Hz)

• trigger_strobe (float | None)

• signal_trigger (str | striqt.analysis.specs.AnalysisGroup | None)

• array_backend (one of ['numpy', 'cupy']) – array module to use to set compute device: numpy = cpu, cupy = gpu

Variables:

• transient_holdoff_time (float) – (Value: 0)

• stream_all_rx_ports (bool | None) – (Value: False)

• transport_dtype (one of ['int16', 'float32', 'complex64']) – data transfer type to use inside the source (Value: float32)

calibration = None

gapless = False

class striqt.sensor.specs.SourceInfo(*, num_rx_ports, retries=None)

Bases: SpecBase

Parameters:

• num_rx_ports (int | None)

• retries (int | None)

min_port_count(tuple_size: int)

class striqt.sensor.specs.SpecBase

Bases: Struct

Base type for structures that support validated (de)serialization.

It is a msgspec.Struct class with some often-used utility methods that fix encoding and decoding hooks for extra types.

classmethod from_dict(d: dict) → _T

classmethod from_spec(other: SpecBase) → _T

replace(**attrs) → Self

returns a copy of self with changed attributes.

See also

Python standard library copy.replace

to_dict(unfreeze=False) → dict

return a dictinary representation of self

validate() → Self

class striqt.sensor.specs.Sweep(*, source, captures=(), loops=(), analysis=Analysis(cellular_5g_pss_sync=None, cellular_5g_pss_correlation=None, cellular_5g_ssb_spectrogram=None, cellular_5g_sss_sync=None, cellular_5g_sss_correlation=None, cellular_cyclic_autocorrelation=None, channel_power_time_series=None, channel_power_histogram=None, spectrogram=None, cellular_resource_power_histogram=None, cyclic_channel_power=None, iq_waveform=None, power_spectral_density=None, spectrogram_histogram=None, spectrogram_ratio_histogram=None), description=Description(summary=None, version='unversioned'), adjust_captures={}, extensions=Extension(sink=None, import_path=None, import_name=None), sink=Sink(path='{yaml_name}-{start_time}', log_path=None, log_level='info', store='directory', max_threads=None, batched_write_count=1, max_chunk_bytes=50000000), peripherals=Peripherals(), options=SweepOptions(reuse_iq=False, loop_only_nyquist=False, skip_warmup=True))

Bases: SpecBase, Generic[SS, SP, SC]

Parameters:

• source (striqt.sensor.lib.typing.SS)

• captures (tuple[striqt.sensor.lib.typing.SC, ...])

• loops (tuple[striqt.sensor.specs.Repeat | striqt.sensor.specs.List | striqt.sensor.specs.Range | striqt.sensor.specs.FrequencyBinRange, ...])

• analysis (striqt.analysis.lib.register.Analysis)

• description (striqt.sensor.specs.Description)

• adjust_captures (dict[str | one of ['defaults'], dict[str, striqt.sensor.specs.CaptureRemap | float | int | str | bool | None] | tuple[str, striqt.sensor.specs.CaptureRemap | float | int | str | bool | None]]) – Source UUID string

• extensions (striqt.sensor.specs.Extension)

• sink (striqt.sensor.specs.Sink)

• peripherals (striqt.sensor.lib.typing.SP)

• options (striqt.sensor.specs.SweepOptions)

Variables:

_binding (Any)

class striqt.sensor.specs.SweepOptions(*, reuse_iq=False, loop_only_nyquist=False, skip_warmup=True)

Bases: SpecBase

Parameters:

• reuse_iq (bool)

• loop_only_nyquist (bool)

• skip_warmup (bool) – if True, suppress empty buffer runs for GPU backends

class striqt.sensor.specs.TDMSSource(*, master_clock_rate, trigger_strobe=None, signal_trigger=None, array_backend='numpy', path)

Bases: Source

Parameters:

• master_clock_rate (float) – Base sample rate used inside the source (Constraints: > 0, units: Hz)

• trigger_strobe (float | None)

• signal_trigger (str | striqt.analysis.specs.AnalysisGroup | None)

• array_backend (one of ['numpy', 'cupy']) – array module to use to set compute device: numpy = cpu, cupy = gpu

• path (str) – path to the waveform data file

Variables:

• transient_holdoff_time (float) – (Value: 0)

• stream_all_rx_ports (bool | None) – (Value: False)

• transport_dtype (one of ['int16', 'float32', 'complex64']) – data transfer type to use inside the source (Value: float32)

class striqt.sensor.specs.ZarrIQSource(*, master_clock_rate, trigger_strobe=None, signal_trigger=None, array_backend='numpy', path, center_frequency, select={})

Bases: Source

Parameters:

• master_clock_rate (float) – Base sample rate used inside the source (Constraints: > 0, units: Hz)

• trigger_strobe (float | None)

• signal_trigger (str | striqt.analysis.specs.AnalysisGroup | None)

• array_backend (one of ['numpy', 'cupy']) – array module to use to set compute device: numpy = cpu, cupy = gpu

• path (str) – path to the waveform data file

• center_frequency (float | tuple[float, ...]) – Center frequency for each port (Constraints: units: Hz, > 0, units: Hz, > 0, units: Hz)

• select (dict) – dictionary to select in the data as .sel(**select)

Variables:

• transient_holdoff_time (float) – (Value: 0)

• stream_all_rx_ports (bool | None) – (Value: False)

• transport_dtype (one of ['int16', 'float32', 'complex64']) – data transfer type to use inside the source (Value: complex64)

class striqt.sensor.specs.frozendict(*args: Any, **kwargs: Any)

Bases: Mapping[_K, _V]

An immutable dictionary that supports hashing

copy() → frozendict[_K, _V]

classmethod fromkeys(seq: Iterable[_K], value: _V | None = None) → frozendict[_K, _V]

items() → a set-like object providing a view on D's items

keys() → a set-like object providing a view on D's keys

update(other: dict[_K, _V], /)

values() → an object providing a view on D's values