Events

CSV Events

class CSVEventsInterface(file_path: Annotated[pathlib._local.Path, PathType(path_type='file')], *, timestamps_column: str | int, event_type_column: str | int | None, value_columns: list[str | int] | None = None, durations_column: str | int | None = None, time_unit: Literal['seconds', 'milliseconds', 'microseconds'] = 'seconds', metadata_key: str | None = None, read_kwargs: dict | None = None, verbose: bool = False)

Bases: BaseEventsInterface

Data Interface for converting discrete events from a single CSV file.

This is a general-purpose CSV events reader: the caller points at one CSV file and assigns each column a role. Every row is one event occurrence at timestamps_column (in time_unit, seconds by default – pass time_unit when the file records onsets in milliseconds or microseconds); the other roles are optional:

• event_type_column – the column, if any, whose value names the type of each event. Each distinct value becomes its own event type and, by default, its own pynwb.event.EventsTable. Merging several types into one table with an event_type discriminator column is opt-in by pointing their table_metadata_key at a shared key in the editable metadata.

• value_columns – columns carried along as per-event values (payload). Each becomes a value column named after its source header, carrying the raw cell values.

• durations_column – a column of per-event durations (in time_unit), making the events durative (written to the table’s duration column). A blank cell becomes NaN (a missing offset).

Columns without an assigned role are ignored.

Notes

CSV recordings carry no embedded recording-start timestamp, so get_metadata() does NOT populate NWBFile/session_start_time. The user must supply it via editable metadata.

Two source layouts are anticipated but not yet supported: a wide format that spreads one event type per timestamp column (this interface reads the long/tidy format, one timestamp column plus an event-type column), and an onset/offset duration style that names a stop-time column and derives each duration from it (use durations_column with the duration precomputed instead).

Initialize the CSVEventsInterface.

Parameters:

• file_path (FilePath) – The path to the CSV file holding the events.

• timestamps_column (str or int) – The column holding the event timestamps (in time_unit, seconds by default). A column name for a CSV with a header row, or a positional index (0-based) for a header-less CSV.

• event_type_column (str, int, or None) – The column, if any, that names the type of each event. Pass a column name or index when the file holds several event types told apart by that column: each distinct value becomes its own event type (and, by default, its own EventsTable). Pass None when the file is a single event type, in which case it is written as one table named after the file stem.

• value_columns (list of (str or int), optional) – The columns, if any, carried along as per-event values. Each becomes a value column on the event table(s), named after its source header and carrying the raw cell values. Default None ignores every column except the timestamp, event-type, and duration columns.

• durations_column (str, int, or None, optional) – The column, if any, holding per-event durations (in time_unit, seconds by default). When set, the events are durative and each duration is written to the table’s duration column; a blank cell becomes NaN. Default None writes point (timestamp-only) events.

• time_unit ({“seconds”, “milliseconds”, “microseconds”}, optional) – The unit of the timestamps_column and durations_column values, default = “seconds”. Both are divided by the corresponding factor to convert them to seconds; value_columns are left untouched (they are arbitrary payload, not time).

• metadata_key (str, optional) – The key under metadata["Events"] that namespaces this interface’s events metadata. If None (default), the file stem is used, so several CSV events interfaces in one conversion get distinct keys without any manual naming.

• read_kwargs (dict, optional) – Additional keyword arguments forwarded to pandas.read_csv, used to handle format quirks such as sep, encoding, decimal, or skiprows. Any value given here overrides the interface’s own defaults (header, float_precision, and keep_default_na=False – the latter keeps label tokens such as 'None', 'NA', or 'null' from collapsing into a single missing label). Default is None.

• verbose (bool, optional) – Whether to print status messages, default = False.

keywords: tuple[str] = ('events', 'CSV')

display_name: str | None = 'CSVEvents'

info: str | None = 'Data Interface for converting discrete events from a single CSV file.'

associated_suffixes: tuple[str] = ('csv',)

get_event_type_source_ids() → list[str]

One type per distinct label, in first-appearance order, or the file stem when the file is one type.

A CSV has no header that lists its types, so this is a pass over the label column, cached with the rest of the read. An empty single-type file yields no type, so no phantom table is seeded.

get_metadata() → DeepDict

Get metadata for the CSVEventsInterface.

NWBFile/session_start_time is intentionally left unset: CSV recordings carry no embedded recording-start timestamp, so it must be supplied by the user via editable metadata.

Returns:

The metadata dictionary for this interface.

Return type:

DeepDict

Doric Events

Interface for discrete events (digital IO) from Doric Neuroscience Studio .doric files.

class DoricEventsInterface(file_path: Annotated[pathlib._local.Path, PathType(path_type='file')], *, detection_configuration: dict | None = None, metadata_key: str | None = None, verbose: bool = False)

Bases: BaseEventsInterface

Convert discrete events (digital IO) from Doric Neuroscience Studio .doric files to NWB.

A .doric file records digital IO lines (e.g. a camera-exposure TTL, a behavior trigger) as sampled 0/1 traces. Each line is a signal, and the events derived from it are set by detection_configuration: one entry per signal holding a list of detection specs, since a signal can yield more than one event type. Each event type is written as its own pynwb.event.EventsTable into nwbfile.events. By default every line is read as a high_period (each rising edge is an event onset, its duration the span to the next falling edge). A line that never toggles still yields its event type, written as a zero-row table, since the type existed in the recording and nothing fired. session_start_time is read from the file’s Created attribute when present.

Both .doric HDF5 generations are read: the modern layout (root group DataAcquisition, digital lines in DigitalIO groups) and the legacy “EPConsole” layout (root group Traces, digital lines the DI--O-* streams under each console). The DoricStudio CSV export is handled by DoricCSVEventsInterface.

Initialize the DoricEventsInterface.

Parameters:

• file_path (FilePath) – Path to the .doric HDF5 file.

• detection_configuration (dict, optional) – Which digital lines to read and how, keyed by the line’s signal_source_id (its DigitalIO dataset key, e.g. {"Camera1": [{"signal_conditioning": {"binarize": "midpoint"}, "detection": "high_period"}]}). Each value is a list of detection specs, one per event type derived from that line, since a line can yield more than one. A spec’s detection is one of "rising" / "falling" (a point event at each edge) or "high_period" / "low_period" (a durative event, onset at one edge and duration to the next opposite edge), and it is required. signal_conditioning is required too and says how the signal becomes a line: a .doric line is already 0/1, so it takes {"binarize": "midpoint"}, whose cut falls strictly between the two levels whatever they are. An optional event_name replaces the derived identifier and pins it against later edits. If None (default), every digital line in the file is read as a high_period, lossless for an active-high line; use "low_period" for an active-low one. When given, only the named lines are read.

• metadata_key (str, optional) – The key under metadata["Events"] that namespaces this interface’s events metadata. If None (default), "doric_events" is used.

• verbose (bool, optional) – Whether to print status messages, default = False.

keywords: tuple[str] = ('events', 'Doric')

display_name: str | None = 'DoricEvents'

info: str | None = 'Data Interface for converting discrete events (digital IO) from Doric Neuroscience Studio files.'

associated_suffixes: tuple[str] = ('doric',)

get_event_type_source_ids() → list[str]

The event types the configuration resolves to, read from nothing.

get_metadata() → DeepDict

Get metadata for the DoricEventsInterface.

NWBFile/session_start_time is populated from the file’s Created attribute when present.

Returns:

The metadata dictionary for this interface.

Return type:

DeepDict

Doric CSV Events

Interface for discrete events (digital IO) from Doric Neuroscience Studio CSV exports.

class DoricCSVEventsInterface(file_path: Annotated[pathlib._local.Path, PathType(path_type='file')], *, detection_configuration: dict | None = None, metadata_key: str | None = None, verbose: bool = False)

Bases: BaseEventsInterface

Convert discrete events from a Doric Neuroscience Studio CSV export to NWB.

A DoricStudio CSV export stores its channels under a grouped two-row header: the first row names each channel’s group (e.g. Analog In. | Ch.1, Digital I/O | Ch.1) and the second row names each column (e.g. Time(s), DI/O-1). The digital IO lines (the columns whose group is Digital I/O) are sampled 0/1 traces on the shared Time(s) clock. Each such column is a signal, and the events derived from it are set by detection_configuration: one entry per signal holding a list of detection specs, since a signal can yield more than one event type. Each event type is written as its own pynwb.event.EventsTable into nwbfile.events. By default every line is read as a high_period (each rising edge is an event onset, its duration the span to the next falling edge). A line that never toggles still yields its event type, written as a zero-row table, since the type existed in the recording and nothing fired.

This reads the DoricStudio CSV export only; the .doric HDF5 layouts are handled by DoricEventsInterface. The CSV export carries no session start time, so the user must supply NWBFile/session_start_time via editable metadata.

Initialize the DoricCSVEventsInterface.

Parameters:

• file_path (FilePath) – Path to the DoricStudio CSV export.

• detection_configuration (dict, optional) – Which digital lines to read and how, keyed by the line’s signal_source_id (its column name, e.g. {"DI/O-1": [{"signal_conditioning": {"binarize": "midpoint"}, "detection": "high_period"}]}). Each value is a list of detection specs, one per event type derived from that line, since a line can yield more than one. A spec’s detection is one of "rising" / "falling" (a point event at each edge) or "high_period" / "low_period" (a durative event, onset at one edge and duration to the next opposite edge), and it is required. signal_conditioning is required too and says how the signal becomes a line: a DoricStudio digital column is already 0/1, so it takes {"binarize": "midpoint"}, whose cut falls strictly between the two levels whatever they are. An optional event_name replaces the derived identifier and pins it against later edits. If None (default), every digital line in the file is read as a high_period, lossless for an active-high line; use "low_period" for an active-low one. When given, only the named lines are read.

• metadata_key (str, optional) – The key under metadata["Events"] that namespaces this interface’s events metadata. If None (default), "doric_events" is used.

• verbose (bool, optional) – Whether to print status messages, default = False.

keywords: tuple[str] = ('events', 'Doric')

display_name: str | None = 'DoricCSVEvents'

info: str | None = 'Data Interface for converting discrete events (digital IO) from Doric Neuroscience Studio CSV exports.'

associated_suffixes: tuple[str] = ('csv',)

get_event_type_source_ids() → list[str]

The event types the configuration resolves to, read from nothing.

get_metadata() → DeepDict

Get metadata for the DoricCSVEventsInterface.

The DoricStudio CSV export carries no session start time, so NWBFile/session_start_time is not populated here; the user must supply it via editable metadata.

Returns:

The metadata dictionary for this interface.

Return type:

DeepDict

MedPC Events

class MedPCArrayEventsInterface(file_path: Annotated[pathlib._local.Path, PathType(path_type='file')], *, session_header: dict, event_configuration: dict, time_unit: Literal['decaseconds', 'seconds', 'deciseconds', 'centiseconds', 'milliseconds'] | float = 'seconds', relative_mode: bool = False, metadata_key: str | None = None, verbose: bool = False)

Bases: _MedPCEventsInterface

Data Interface for the discrete events of a MedPC file that holds one array per event type.

Each lettered array is one event type, holding that type’s onset times in seconds, so the array’s name is the event type’s identity. Which arrays those are is decided by the MSN program that wrote the file and stated through event_configuration. An entry naming a duration is durative and takes its per-event durations from a second array; one naming a payload carries a per-event value from each array it names as a column of the event type’s table.

Use MedPCPackedEventsInterface instead for a file whose events are all in one array as TIME.EVENTCODE values. This interface replaces MedPCInterface, which reads the same layout and writes it as ndx-events objects and IntervalSeries into the behavior processing module.

Initialize MedPCArrayEventsInterface.

Parameters:

• file_path (FilePath) – Path to the MedPC file.

• session_header (dict) – The header fields identifying which of the file’s sessions to read, keyed by the header line’s name (‘Start Date’, ‘End Date’, ‘Subject’, ‘Experiment’, ‘Group’, ‘Box’, ‘Start Time’, ‘End Time’, ‘MSN’) and valued as that session carries them. Whichever fields tell the sessions apart is a property of how the file was collected, so pass as many as it takes to name exactly one; the first session matching all of them is read. ex. {“Start Date”: “04/10/19”, “Start Time”: “12:36:13”} where one animal ran on several days and the date, or the date and the time where it ran twice in a day, is what separates them ex. {“Start Date”: “10/06/22”, “Subject”: “cohort10-M3.3”} where a cohort’s animals were pooled into one file and the subject is needed as well

• event_configuration (dict) – The event types of a per-array file, keyed by the MedPC variable holding their onset times (ex. ‘A’). That variable is the event type’s identifier, the handle get_event_times takes and the key of its metadata entry. Each value states how that array is read, or is None where the array is a plain list of onsets: an optional ‘duration’ naming the MedPC variable that holds the per-event durations, which makes the type durative rather than a point event, and an optional ‘payload’ listing MedPC variables holding one value per event, each written as a column of the same table.

  Nothing here names anything. A MedPC variable is a slot number rather than a label, so an event type arrives called ‘A’ and a payload column called ‘K’; set event_name and column_name in the editable metadata, which is also where a payload column’s raw codes are relabelled and explained through column_categories. ex. {“A”: None, “G”: {“duration”: “E”}, “S”: {“payload”: [“K”]}}

• time_unit (str or float, optional) – What one stored value is worth, default = “seconds”. Either a named unit, “decaseconds”, “seconds”, “deciseconds”, “centiseconds” or “milliseconds”, or a number of seconds. MedPC stores whatever the MSN program divided by before writing and records neither that choice nor the box’s timing resolution, so it is stated rather than detected. A program that stored the raw BTIME counter takes the resolution as a number: 0.002 on a 2 ms system, 0.005 on a 5 ms one.

• relative_mode (bool, optional) – Whether the program wrote each value as the time since the previous event rather than the time since the session began, default = False. This is Med Associates’ own term, from the shipped example procedures that use it: “Relative Mode means that each event is listed by the amount of time that has passed since the last event has happened”. The values are accumulated when True, because a time written into NWB is the time since the session started.

• metadata_key (str, optional) – The key under metadata["Events"] that namespaces this interface’s events metadata. If None (default), “medpc” is used, so several MedPC interfaces in one conversion need a key each.

• verbose (bool, optional) – Whether to print verbose output, by default False.

display_name: str | None = 'MedPCArrayEvents'

info: str | None = 'Interface for the discrete events of MedPC files holding one array per event type.'

get_event_type_source_ids() → list[str]

The arrays the configuration declares as event types, in configuration order, read from nothing.

class MedPCPackedEventsInterface(file_path: Annotated[pathlib._local.Path, PathType(path_type='file')], *, session_header: dict, events_variable: str, time_unit: Literal['decaseconds', 'seconds', 'deciseconds', 'centiseconds', 'milliseconds'] | float = 'seconds', relative_mode: bool = False, metadata_key: str | None = None, verbose: bool = False)

Bases: _MedPCEventsInterface

Data Interface for the discrete events of a MedPC file that packs the event type into the time value.

One array holds every event of the session as a single TIME.EVENTCODE value, written by a line like Set A(Y) = BTIME-U + code/1000: the code rides in the fractional digits and the time is the integer part. How many digits the code occupies is fixed by the program’s DISKFORMAT, which is what prints them, so the file states its own code width and nothing has to be declared beyond the unit the integer part counts in.

Every code found becomes an event type identified by its digits, so the file names its own event types.

Use MedPCArrayEventsInterface instead for a file that holds one array per event type. A file that keeps its codes in a companion array of the same length, beside the times rather than inside them, is a layout NeuroConv does not read yet: please open an issue at catalystneuro/neuroconv#issues with the program and a sample file.

Initialize MedPCPackedEventsInterface.

Parameters:

• file_path (FilePath) – Path to the MedPC file.

• session_header (dict) – The header fields identifying which of the file’s sessions to read, keyed by the header line’s name (‘Start Date’, ‘End Date’, ‘Subject’, ‘Experiment’, ‘Group’, ‘Box’, ‘Start Time’, ‘End Time’, ‘MSN’) and valued as that session carries them. Whichever fields tell the sessions apart is a property of how the file was collected, so pass as many as it takes to name exactly one; the first session matching all of them is read. ex. {“Start Date”: “04/10/19”, “Start Time”: “12:36:13”} where one animal ran on several days and the date, or the date and the time where it ran twice in a day, is what separates them ex. {“Start Date”: “09/25/15”, “Subject”: “ML03”} where a cohort’s animals were pooled into one file

• events_variable (str) – The MedPC variable holding every event of the session (ex. ‘A’). A file has up to 26 arrays and only one of them is this; the rest hold counters, schedules, flags and session parameters, and nothing in the file’s syntax tells them apart. The MSN program picks the letter, so it is stated rather than defaulted: ‘A’ is what the readers of this convention happen to use, not something the format fixes.

• time_unit (str or float, optional) – What one stored value is worth, default = “seconds”. Either a named unit, “decaseconds”, “seconds”, “deciseconds”, “centiseconds” or “milliseconds”, or a number of seconds. MedPC stores whatever the MSN program divided by before writing and records neither that choice nor the box’s timing resolution, so it is stated rather than detected. A program that stored the raw BTIME counter takes the resolution as a number: 0.002 on a 2 ms system, 0.005 on a 5 ms one.

• relative_mode (bool, optional) – Whether the program wrote each value as the time since the previous event rather than the time since the session began, default = False. This is Med Associates’ own term, from the shipped example procedures that use it: “Relative Mode means that each event is listed by the amount of time that has passed since the last event has happened”. The values are accumulated when True, because a time written into NWB is the time since the session started.

• metadata_key (str, optional) – The key under metadata["Events"] that namespaces this interface’s events metadata. If None (default), “medpc” is used, so several MedPC interfaces in one conversion need a key each.

• verbose (bool, optional) – Whether to print verbose output, by default False.

display_name: str | None = 'MedPCPackedEvents'

info: str | None = 'Interface for the discrete events of MedPC files packing the event type into the time value.'

NPM Events

class NPMEventsInterface(file_path: Annotated[pathlib._local.Path, PathType(path_type='file')], *, time_unit: Literal['seconds', 'milliseconds', 'microseconds'] = 'seconds', metadata_key: str | None = None, verbose: bool = False)

Bases: CSVEventsInterface

Data Interface for converting discrete events from Neurophotometrics (NPM) files.

NPM stores discrete events in a raw, headerless two-column stimuli CSV: the first column holds the event onset time (in the recording’s raw time base) and the second column holds the event type label (e.g. whitenoise, pinknoise, a boolean True/False annotation, or a numeric code). This is exactly a headerless CSV with a timestamp column and an event-type column, so this interface is a thin CSVEventsInterface that fixes those two columns. Each distinct label becomes its own pynwb.event.EventsTable (onset timestamps only) in nwbfile.events.

Notes

Note that we assume the second column is the event type. Each distinct value becomes its own event type/table rather than a per-event value/payload column.

The raw onset times are scaled to seconds by time_unit (see CSVEventsInterface) but are otherwise written as-is: they remain in the recording’s raw time base. NPM recordings carry no embedded recording-start timestamp, so get_metadata() does NOT populate NWBFile/session_start_time; the user must supply it via editable metadata.

This interface targets the standalone Bonsai stimuli CSV only. NPM can also embed discrete events directly in the photometry/signal CSV, alongside the fluorescence columns: older firmware writes each digital I/O line (e.g. Stimulation, Output0/Output1, Input0/Input1) as its own 0/1-per-frame column, while newer firmware bit-packs those same lines into the Flags/LedState column. This interface’s fixed headerless two-column layout does not fit that photometry CSV; use CSVEventsInterface directly to select the relevant columns from it.

Initialize the NPMEventsInterface.

Parameters:

• file_path (FilePath) – The path to the raw NPM event/stimuli CSV file: a headerless two-column CSV whose first column is the event onset time and whose second column is the event type label.

• time_unit ({“seconds”, “milliseconds”, “microseconds”}, optional) – The unit of the raw onset-time column, default = “seconds”. Onset times are divided by the corresponding factor to convert them to seconds.

• metadata_key (str, optional) – The key under metadata["Events"] that namespaces this interface’s events metadata. If None (default), the file stem is used (inherited from CSVEventsInterface).

• verbose (bool, optional) – Whether to print status messages, default = False.

keywords: tuple[str] = ('events', 'Neurophotometrics')

display_name: str | None = 'NPMEvents'

info: str | None = 'Data Interface for converting discrete events from Neurophotometrics files.'

associated_suffixes: tuple[str] = ('csv',)

pyPhotometry Events

class PyPhotometryEventsInterface(file_path: Annotated[pathlib._local.Path, PathType(path_type='file')], *, detection_configuration: dict | None = None, metadata_key: str | None = None, verbose: bool = False)

Bases: BaseEventsInterface

Convert discrete events (digital IO) from pyPhotometry .ppd recordings to NWB.

The lines are the board’s digital inputs, named digital_1 and digital_2 the way pyPhotometry’s own reader names them. They are sampled rather than logged, so an event’s time is only as precise as the sampling rate, 7.7 ms at 130 Hz, and the two lines are not sampled at the same instant but half a sample period apart. A recording carries both lines except in 3EX_2EM_pulsed, where the board uses the second one to drive its third LED.

Which events come off a line is set by detection_configuration: one entry per line holding a list of detection specs, since a line can yield more than one event type. Each event type is written as its own pynwb.event.EventsTable into nwbfile.events. By default every line is read as a high_period (each rising edge is an event onset, its duration the span to the next falling edge). A line that never toggles still yields its event type, written as a zero-row table, since the type existed in the recording and nothing fired. session_start_time and subject_id are read from the header’s date_time and subject_ID.

The fluorescence in the same recording is a separate interface, PyPhotometryFiberPhotometryInterface; put both in a converter of your own to write a recording whole.

Initialize the PyPhotometryEventsInterface.

Parameters:

• file_path (FilePath) – Path to the .ppd file.

• detection_configuration (dict, optional) – Which digital lines to read and how, keyed by the line’s signal_source_id ("digital_1" or "digital_2", e.g. {"digital_1": [{"signal_conditioning": {"binarize": "midpoint"}, "detection": "high_period"}]}). Each value is a list of detection specs, one per event type derived from that line, since a line can yield more than one. A spec’s detection is one of "rising" / "falling" (a point event at each edge) or "high_period" / "low_period" (a durative event, onset at one edge and duration to the next opposite edge), and it is required. signal_conditioning is required too and says how the signal becomes a line: the reader has already pulled the bit out of the word, so a .ppd line arrives 0/1 and takes {"binarize": "midpoint"}, whose cut falls strictly between the two levels whatever they are. An optional event_name replaces the derived identifier and pins it against later edits. If None (default), every digital line the file carries is read as a high_period, lossless for an active-high line; use "low_period" for an active-low one. When given, only the named lines are read.

• metadata_key (str, optional) – The key under metadata["Events"] that namespaces this interface’s events metadata. If None (default), "pyphotometry_events" is used.

• verbose (bool, optional) – Whether to print status messages, default = False.

keywords: tuple[str] = ('events', 'pyPhotometry')

display_name: str | None = 'pyPhotometry Events'

info: str | None = 'Data Interface for converting discrete events (digital IO) from pyPhotometry recordings.'

associated_suffixes: tuple[str] = ('.ppd',)

get_event_type_source_ids() → list[str]

The event types the configuration resolves to, read from nothing.

get_metadata() → DeepDict

Get metadata for the PyPhotometryEventsInterface.

NWBFile/session_start_time is populated from the header’s date_time and Subject/subject_id from its subject_ID, both of which every header generation carries.

Returns:

The metadata dictionary for this interface.

Return type:

DeepDict

TDT Events

class TDTEventsInterface(folder_path: Annotated[pathlib._local.Path, PathType(path_type='dir')], *, exclude_events: list[str] | None = None, metadata_key: str | None = None, verbose: bool = False)

Bases: TDTLoadMixin, BaseEventsInterface

Data Interface for converting discrete events (epocs) from a TDT output folder.

The TDT tank stores discrete events as epocs (e.g. camera TTL pulses, port entries, nose pokes). This interface reads those epocs via tdt.read_block and writes each selected epoc as one pynwb.event.EventsTable inside nwbfile.events.

Most epoc stores are onset-type epocs whose data array is a meaningless incrementing counter, so only the onsets are written (a timestamp-only table). A store whose data carries real strobe codes (e.g. the PAB_ store’s [16, 2064, 0] cycle) additionally gets a categorical strobe column, with the codes as per-event labels. The offset array of an onset-type epoc is derived from the onsets (offset[i] == onset[i + 1], last value inf) and is not written. Epocs that carry real offset (STROFF) durations are written as durative events, with each event’s duration (offset minus onset) in the table’s duration column.

Initialize the TDTEventsInterface.

Parameters:

• folder_path (DirectoryPath) – The path to the folder containing the TDT data.

• exclude_events (list[str], optional) – The names of the TDT epocs to skip. If None (default), every epoc in the tank is stored.

• metadata_key (str, optional) – The key under metadata["Events"] that namespaces this interface’s events metadata. If None (default), "tdt_events" is used.

• verbose (bool, optional) – Whether to print status messages, default = False.

keywords: tuple[str] = ('events', 'TDT')

display_name: str | None = 'TDTEvents'

info: str | None = 'Data Interface for converting discrete events (epocs) from TDT files.'

associated_suffixes: tuple[str] = ('Tbk', 'Tdx', 'tev', 'tin', 'tsq')

get_event_type_source_ids() → list[str]

The epoc stores the tank holds, less the excluded ones and those with no events, from the epoc headers.

get_metadata() → DeepDict

Get metadata for the TDTEventsInterface.

Returns:

The metadata dictionary for this interface.

Return type:

DeepDict