Module: formatting

Data formatting nodes.

These nodes typically do not change the actual numeric values contained in the received data streams, but instead change the format of the data (for instance, the shape of the blocks, the properties of the chunks, possibly the number of streams in a packet). The most important use cases are to extract segments from continuous data, and to "play back" a long packet by chopping it into a series of successive streaming packets.

ApplyAxisMask

Apply an axis mask that was previously generated using Generate Axis Mask.

This can be used to filter out the same collection of entries from multiple unrelated data packets (e.g., trials from different modalities).

Version 1.0.0

Ports/Properties

  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)

  • data
    Data to process.

    • verbose name: Data
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: INOUT

  • mask
    Mask to apply

    • verbose name: Mask
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: IN

BatchInstances

Group and batch instances based on some some criterion along a new feature axis.

The data will be concatenated and padded along that axis. This can be used in cases where you want to group trials (represented as instances in Neuropype) by certain criteria in the instance.data field (typically Marker, but could be any other attribute). You specify the instance.data field holding the criteria (such as 'Marker'), and a feature axis will be created for each unique value found in that field, and the instances (trials) will be stacked along the corresponding axis based on their value (for example, all trials with marker "A" would go in one axis, all trials with marker "B" in another), etc. This allows you to segregate trials into batches for comparative analysis. (Note that if all you want is the mean of trials matching each criteria, instead of the individual trials themselves, you can used the GroupedMean node.)

Version 0.5.1

Ports/Properties

  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)

  • data
    Data to process.

    • verbose name: Data
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: INOUT

  • group_by
    Group instances that have the same value or combination of values for the given instance field(s). If given, then the grouped instances will be batched along a new axis.

    • verbose name: Stack By Field(S)
    • default value: []
    • port type: ListPort
    • value type: list (can be None)

  • verify_unique
    Ensure that the given fields (if any), are unique within each group. If this is not the case, an error will be thrown.

    • verbose name: Verify Unique Values In Field(S)
    • default value: []
    • port type: ListPort
    • value type: list (can be None)

  • pad_maxitems
    Optional max # of items for padding. If this is None, it amounts to the max items in any of the groups. If < 1, then it is taken as a quantile of the item counts (e.g., 0.9 would be 90th percentile). If given as an integer >= 1, it is taken as the max # of items.

    • verbose name: Pad Maxitems
    • default value: None
    • port type: FloatPort
    • value type: float (can be None)

  • pad_value
    Value to use for padding. This value will be inserted to fill up groups that have less than the max # of items.

    • verbose name: Pad Value
    • default value: 0.0
    • port type: FloatPort
    • value type: float (can be None)

  • handle_overlength
    How to handle groups that have more items than pad_maxitems. In the truncate-group modes, the excess items are removed from the group, either at the beginning (-pre variant), or at the end (-post variant). In the drop-group mode, the entire group is dropped from the data set.

    • verbose name: Handle Overlength
    • default value: truncate-group-pre
    • port type: EnumPort
    • value type: str (can be None)

CreateAxis

An axis indexes data along a dimension.

It can be time, space, frequency, instance, feature, statistic, named, lag, or axis (or user-defined axis classes). Each axis type has a set of built-in fields, e.g., time has array .times (in seconds) and prop .nominal_rate, while frequency has array .frequencies (in Hz). An axis can also be identified with a label. Axes are used to construct Block objects, which are comprised of a multi-dimensional array and a list of axes that characterize the array's dimensions.

Version 1.0.0

Ports/Properties

  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)

  • axis
    Output axis.

    • verbose name: Axis
    • default value: None
    • port type: DataPort
    • value type: BaseAxis (can be None)
    • data direction: OUT

  • type
    Type of axis to create.

    • time: an axis that represents time, has array .times and prop .nominal_rate
    • space: an axis that represents spatially distributed data (e.g., channels), has among others arraya .names (channel names) and .positions (3d positions), and props .naming_system and .coordinate_system
    • frequency: an axis that represents frequency, e.g., in a spectral decomposition, has array .frequencies
    • instance: an axis that represents instances, e.g., trials or segments, has arrays .times (occurrence time) and .data (nested array of per-instance data)
    • feature: an axis that indexes arbitrary features (e.g., after feature extraction), has array .names (feature names) and several others
    • statistic: an axis that indexes statistics, has array .param_types (statistical parameter types) and .labels (optionally a string label for each statistic)
    • named: an axis that indexes named items, has array .names (item names) (space and feature are specializations of a named axis)
    • lag: an axis that indexes lags (e.g., in delay-embedded data or filter kernels), has array .lags (integer lag values)
    • axis: a generic axis that has no built-in fields, only a length

    • verbose name: Axis Type
    • default value: time
    • port type: EnumPort
    • value type: str (can be None)

  • name0
    Array name 0.

    • verbose name: Array Name 0
    • default value: None
    • port type: StringPort
    • value type: str (can be None)

  • array0
    Array 0.

    • verbose name: Array0
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN

  • name1
    Array name 1.

    • verbose name: Array Name 1
    • default value: None
    • port type: StringPort
    • value type: str (can be None)

  • array1
    Array 1.

    • verbose name: Array1
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN

  • name2
    Array name 2.

    • verbose name: Array Name 2
    • default value: None
    • port type: StringPort
    • value type: str (can be None)

  • array2
    Array 2.

    • verbose name: Array2
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN

  • name3
    Array name 3.

    • verbose name: Array Name 3
    • default value: None
    • port type: StringPort
    • value type: str (can be None)

  • array3
    Array 3.

    • verbose name: Array3
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN

  • name4
    Array name 4.

    • verbose name: Array Name 4
    • default value: None
    • port type: StringPort
    • value type: str (can be None)

  • array4
    Array 4.

    • verbose name: Array4
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN

  • nameN
    Additional array names.

    • verbose name: Additional Array Names
    • default value: []
    • port type: ListPort
    • value type: list (can be None)

  • arrayN
    Additional arrays.

    • verbose name: Arrayn
    • default value: None
    • port type: DataPort
    • value type: list (can be None)
    • data direction: IN

  • props
    Properties to set on the axis.

    • verbose name: Props
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)

  • custom_label
    Optional custom label for the axis. Labels make it easier to identify an axis in the event there are multiple axes of the same type in the packet. Nodes where an axis can be specified (e.g., space, time, etc) can also accept a string in the format space.mylabel that precisely identifies the axis to be the space axis that has label mylabel.

    • verbose name: Custom Label
    • default value:
    • port type: StringPort
    • value type: str (can be None)

  • length
    Optionally the length (number of elements) of the axis. Only necessary if no arrays are given.

    • verbose name: Length
    • default value: None
    • port type: IntPort
    • value type: int (can be None)

  • verbose
    Print verbose diagnostic information.

    • verbose name: Verbose
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

CreateBlock

A block is a multi-dimensional array with named/typed axes.

In NeuroPype, each axis is of one of several types, such as space, time, frequency, instance, etc, and depending on the type, the axis may have specific fields, such as the array of time points or frequencies, or channel names in a space axis that characterize the dimensions of the array. The only constraint is that the number of axes matches the number of dimensions of the array, and that the n'th axis has the same length (number of elements) as the n'th dimension of the array. The node can optionally emit None if the resulting block is empty.

Version 1.0.0

Ports/Properties

  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)

  • block
    Output block.

    • verbose name: Block
    • default value: None
    • port type: DataPort
    • value type: Block (can be None)
    • data direction: OUT

  • array
    Input array.

    • verbose name: Array
    • default value: None
    • port type: DataPort
    • value type: AnyArray (can be None)
    • data direction: IN

  • axis0
    Axis 0.

    • verbose name: Axis0
    • default value: None
    • port type: DataPort
    • value type: BaseAxis (can be None)
    • data direction: IN

  • axis1
    Axis 1.

    • verbose name: Axis1
    • default value: None
    • port type: DataPort
    • value type: BaseAxis (can be None)
    • data direction: IN

  • axis2
    Axis 2.

    • verbose name: Axis2
    • default value: None
    • port type: DataPort
    • value type: BaseAxis (can be None)
    • data direction: IN

  • axis3
    Axis 3.

    • verbose name: Axis3
    • default value: None
    • port type: DataPort
    • value type: BaseAxis (can be None)
    • data direction: IN

  • axis4
    Axis 4.

    • verbose name: Axis4
    • default value: None
    • port type: DataPort
    • value type: BaseAxis (can be None)
    • data direction: IN

  • axisN
    Additional axes.. ..

    • verbose name: Axisn
    • default value: None
    • port type: DataPort
    • value type: list (can be None)
    • data direction: IN

  • axes
    Axis list.

    • verbose name: Axes
    • default value: None
    • port type: AliasPort
    • value type: list (can be None)

  • none_if_empty
    Return None if the resulting block is empty.

    • verbose name: None If Empty
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

  • verbose
    Enable verbose diagnostics output.

    • verbose name: Verbose
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

CreateChunk

A chunk is a pairing of a data block (an N-dimensional array with named/typed axes) and a dictionary of descriptive properties.

This node constructs a chunk from these two pieces of data, each of which may be empty. The node can optionally emit None if the block is empty or None.

Version 1.0.0

Ports/Properties

  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)

  • chunk
    Output chunk.

    • verbose name: Chunk
    • default value: None
    • port type: DataPort
    • value type: Chunk (can be None)
    • data direction: OUT

  • block
    Input block.

    • verbose name: Block
    • default value: None
    • port type: DataPort
    • value type: Block (can be None)
    • data direction: IN

  • props
    Chunk properties.

    • verbose name: Props
    • default value: None
    • port type: DataPort
    • value type: dict (can be None)
    • data direction: IN

  • none_if_empty
    Return None if the block is empty or None.

    • verbose name: None If Empty
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

  • verbose
    Enable verbose diagnostics output.

    • verbose name: Verbose
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

CreatePacket

Create a packet from chunks and their desired names.

A packet is a listing of one or more chunks, each of which is identified by a name (for more information, see the paragraph below or the NeuroPype documentation). Since a packet is not allowed to have None values for its chunks, any input chunks that are None are automatically dropped out from the resulting packet. When naming chunks, the properties name0..nameN must be assigned in a contiguous fashion, i.e., intermediate names that are unspecified (None) are not allowed. Chunks can also be automatically named based on the modality if desired using the auto_naming option. Generally if a duplicate name is given, then by convention all occurrences of that name, including the first occurrence, will have a number appended as in 'eeg-1', 'eeg-2', etc. A packet represents data from one or more named data streams (e.g., for raw time-series data, streams could be 'eeg', 'gaze', and 'markers'). In a real-time setting, a packet holds a short time slice of data from each stream (thus the name packet, in analogy with transmission packet), and for each stream it contains a brief chunk of data from that stream (which contains the actual array data and stream properties). In a batch/post-hoc analysis setting, a packet can hold the entire length of the data, and generally it is by no means restricted to time series data, but may hold arbitrary derived data (such as a time/frequency decompositions, statistics, and so forth). The names "chunk" and "stream" are often used interchangeably in NeuroPype, but the Chunk is the concrete data structure that makes up packets, and stream is often used for a less technical audience and to allude to the notion that a chunk stems from or belongs to a particular named data stream.

Version 1.0.0

Ports/Properties

  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)

  • data
    Output packet.

    • verbose name: Data
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: OUT

  • name0
    Name 0.

    • verbose name: Name0
    • default value: None
    • port type: StringPort
    • value type: str (can be None)

  • chunk0
    Chunk 0.

    • verbose name: Chunk0
    • default value: None
    • port type: DataPort
    • value type: Chunk (can be None)
    • data direction: IN

  • name1
    Name 1.

    • verbose name: Name1
    • default value: None
    • port type: StringPort
    • value type: str (can be None)

  • chunk1
    Chunk 1.

    • verbose name: Chunk1
    • default value: None
    • port type: DataPort
    • value type: Chunk (can be None)
    • data direction: IN

  • name2
    Name 2.

    • verbose name: Name2
    • default value: None
    • port type: StringPort
    • value type: str (can be None)

  • chunk2
    Chunk 2.

    • verbose name: Chunk2
    • default value: None
    • port type: DataPort
    • value type: Chunk (can be None)
    • data direction: IN

  • name3
    Name 3.

    • verbose name: Name3
    • default value: None
    • port type: StringPort
    • value type: str (can be None)

  • chunk3
    Chunk 3.

    • verbose name: Chunk3
    • default value: None
    • port type: DataPort
    • value type: Chunk (can be None)
    • data direction: IN

  • name4
    Name 4.

    • verbose name: Name4
    • default value: None
    • port type: StringPort
    • value type: str (can be None)

  • chunk4
    Chunk 4.

    • verbose name: Chunk4
    • default value: None
    • port type: DataPort
    • value type: Chunk (can be None)
    • data direction: IN

  • name5
    Name 5.

    • verbose name: Name5
    • default value: None
    • port type: StringPort
    • value type: str (can be None)

  • chunk5
    Chunk 5.

    • verbose name: Chunk5
    • default value: None
    • port type: DataPort
    • value type: Chunk (can be None)
    • data direction: IN

  • name6
    Name 6.

    • verbose name: Name6
    • default value: None
    • port type: StringPort
    • value type: str (can be None)

  • chunk6
    Chunk 6.

    • verbose name: Chunk6
    • default value: None
    • port type: DataPort
    • value type: Chunk (can be None)
    • data direction: IN

  • name7
    Name 7.

    • verbose name: Name7
    • default value: None
    • port type: StringPort
    • value type: str (can be None)

  • chunk7
    Chunk 7.

    • verbose name: Chunk7
    • default value: None
    • port type: DataPort
    • value type: Chunk (can be None)
    • data direction: IN

  • name8
    Name 8.

    • verbose name: Name8
    • default value: None
    • port type: StringPort
    • value type: str (can be None)

  • chunk8
    Chunk 8.

    • verbose name: Chunk8
    • default value: None
    • port type: DataPort
    • value type: Chunk (can be None)
    • data direction: IN

  • name9
    Name 9.

    • verbose name: Name9
    • default value: None
    • port type: StringPort
    • value type: str (can be None)

  • chunk9
    Chunk 9.

    • verbose name: Chunk9
    • default value: None
    • port type: DataPort
    • value type: Chunk (can be None)
    • data direction: IN

  • nameN
    Additional chunk names in list form.

    • verbose name: Additional Chunk Names
    • default value: None
    • port type: ListPort
    • value type: list (can be None)

  • chunkN
    Additional chunks.

    • verbose name: Chunkn
    • default value: None
    • port type: DataPort
    • value type: list (can be None)
    • data direction: IN

  • none_if_empty
    Output None if all inputs are empty.

    • verbose name: Output None If All Empty
    • default value: True
    • port type: BoolPort
    • value type: bool (can be None)

  • auto_naming
    Optionally auto-generate names for chunks instead of using manually-assigned names. If 'no', then this is disabled; names can then only be passed in if auto_naming is set to no. If set to 'auto', then if the chunk has a specified modality property, it will be named according to the modality (lowercased), else if it is an event stream it will be named 'markers', and otherwise it will be named 'chunk'.

    • verbose name: Auto Naming
    • default value: no
    • port type: EnumPort
    • value type: str (can be None)

  • verbose
    Enable verbose diagnostics output.

    • verbose name: Verbose
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

ExtractStreams

Extract streams which match a certain criteria, either the stream name, or certain stream properties (i.e

., modality). This will create a new packet that has only the matched streams, or returns None (not an empty Packet) if no matching streams are found.

Version 2.2.1

Ports/Properties

  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)

  • data
    Data to process.

    • verbose name: Data
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: INOUT

  • stream_names
    Names of the streams to extract. Technical comment: this corresponds to the name of the stream chunk in the data packet, which is typically the modality (e.g., 'eeg') possibly followed by some suffix (since stream names must be unique), e.g., 'eeg1'). A few nodes may also create derived streams from a stream and then append additional suffixes, e.g., 'eeg1-hr' for a heart rate stream that was derived from the 'eeg1' stream. If selection_criteria is also specified, the criteria will be evaluated first, and the stream_names will be selected from among those matching the criteria (if any).

    • verbose name: Stream Names
    • default value: []
    • port type: ListPort
    • value type: list (can be None)

  • selection_criteria
    A dictionary of criteria in the form of {'field1':'value1', 'field2':'value2'} where field is a stream property, and value is value to match. Common properties are defined in the Origin class: 'modality', 'stream_name' (the name of the origin LSL stream, not the name of the stream in the data packet), 'source_url', 'subject_id', 'session_id'. Custom properties in the "desc" property of the stream (as per the LSL and XDF specs) may also be specified by prefixing with 'desc', i.e., 'desc.cap.size'. If multiple criteria are specified, selected streams must fulfill all of them.

    • verbose name: Selection Criteria
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)

  • support_wildcards
    Support for wildcard matching. This applies to both the stream_names parameter and the selection_criteria.

    • verbose name: Support Wildcards
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

  • verbose
    Log message of extracted streams.

    • verbose name: Verbose
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

FuseStreams

Fuse the streams in the given data into a single multi-channel stream.

The time stamps of the input stream must all be on the same type of clock, for instance all coming from LSL or all stamped using UTC time. This node assumes that the samples in the inserted streams are regularly sampled. While the sampling rates need not be the same, best results will be obtained when fusing a slow-changing signal into a higher rate one. This node expects only space and time axes; all other axes must have a length of zero. This node is currently designed for streaming data only. Caveats: This node is in beta and may not work as expected under all conditions.

Version 0.9.6

Ports/Properties

  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)

  • data
    Data to process.

    • verbose name: Data
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: INOUT

  • srate
    Output sampling rate. This is the nominal sampling rate of the output stream. Note that if this is lower than the sampling rate of any of the input streams, these streams must have been low-pass filtered with a cutoff frequency of half the new sampling rate (otherwise spectral aliasing will occur).

    • verbose name: Output Sampling Rate
    • default value: 125
    • port type: IntPort
    • value type: int (can be None)

  • verbosity
    Verbosity level. 0=off, 1=essential verbosity, 2=full verbosity, 3=unreasonable verbosity.

    • verbose name: Verbosity
    • default value: 1
    • port type: IntPort
    • value type: int (can be None)

  • min_headroom
    Minimum buffer headroom. This is the minimum amount of space ahead of the most recent message that shall be reserved in the buffer. If there is less remaining headroom than that, we grow the buffer up to the desired amount of headroom.

    • verbose name: Minimum Buffer Headroom
    • default value: 2
    • port type: FloatPort
    • value type: float (can be None)

  • desired_headroom
    Desired buffer headroom. When we grow the buffer to accommodate more recent message insertions, we grow it such that we gain this much headroom. This value must be somewhat larger than the minimum headroom so that we don't have to grow the buffer with every message in the worst case.

    • verbose name: Desired Buffer Headroom
    • default value: 5
    • port type: FloatPort
    • value type: float (can be None)

  • buffer_delay
    Tolerable buffer delay. This is the delay versus the median most recent sample time (taken across clients), that we allow due to buffering of data. If this is set too low, then not all clients will have had a chance to have their data transmitted by the time the buffered data is due for flushing, and the respective channels will contain NaNs to indicate missing data. The larger this value is, the larger the percentage of clients whose data will have made it into the buffer by the time it is released (a good value is the maximum reasonable delay that a client may experience vs. the typical client).

    • verbose name: Tolerable Buffer Delay
    • default value: 2
    • port type: FloatPort
    • value type: float (can be None)

  • stream_name
    Name of the fused stream.

    • verbose name: Stream Name
    • default value: eeg
    • port type: StringPort
    • value type: str (can be None)

GetAxisMask

Identifies which slices meet criteria parameters and outputs the result as a mask packet.

Only the first chunk with the axis_type is processed; See ExtractStreams. The mask packet can then be used by ApplyAxisMask to mask out slices along the specified dimension, in a packet with one or more streams with a matching axis. These nodes can be used to slice out trials with bad data.

Version 1.0.0

Ports/Properties

  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)

  • data
    Data to process.

    • verbose name: Data
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: IN

  • mask
    Output mask.

    • verbose name: Mask
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: OUT

  • comparison_data
    Optionally compare input data to this packet. Any len()>1 axes must match input data exactly.

    • verbose name: Comparison Data
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: IN

  • axis_type
    The axis along which to evaluate the criteria. A specific axis can be specified using axis.mylabel syntax.

    • verbose name: Axis Type
    • default value: instance
    • port type: ComboPort
    • value type: str (can be None)

  • comparison_value
    Value to compare data to if comparison_data not provided. Default -np.inf and greater_equal will eliminate nan trials.

    • verbose name: Comparison Value
    • default value: None
    • port type: FloatPort
    • value type: float (can be None)

  • comparison_operator

    • verbose name: Comparison Operator
    • default value: greater_equal
    • port type: EnumPort
    • value type: str (can be None)

  • dimension_operator
    When input chunk is multidimensional, this operation will be applied to the result of the comparison across all other axes.

    • verbose name: Dimension Operator
    • default value: all
    • port type: EnumPort
    • value type: str (can be None)

  • invert_selection
    If set then the resulting mask will be inverted.

    • verbose name: Invert Selection
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

MergeStreams

Merge the streams in the given packets into one packet that contains all streams.

A data packet in NeuroPype can contain one or more named streams, whether they are signal streams (i.e., EEG) or marker streams (events). This node will merge the streams carried by all inputs into one packet. If a stream is encountered whose name is already in the packet, then a sequentially numbered name will be generated (as in eeg-1, eeg-2, etc.). Note that this node does not combine streams into a single stream, but rather places the streams in the same packet. To combine markers from multiple marker streams into a single stream, follow this node with FuseMarkerStreams. To combine data from multiple signal streams into a single stream, see ConcatInputs or FuseStreams (note that this is only possible under certain circumstances; see those nodes' documentation for details).

Version 1.0.0

Ports/Properties

  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)

  • data1
    Input data 1.

    • verbose name: Data1
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: IN

  • data2
    Input data 2.

    • verbose name: Data2
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: IN

  • data3
    Input data 3.

    • verbose name: Data3
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: IN

  • data4
    Input data 4.

    • verbose name: Data4
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: IN

  • data5
    Input data 5.

    • verbose name: Data5
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: IN

  • data6
    Input data 6.

    • verbose name: Data6
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: IN

  • data7
    Input data 7.

    • verbose name: Data7
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: IN

  • data8
    Input data 8.

    • verbose name: Data8
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: IN

  • data9
    Input data 9.

    • verbose name: Data9
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: IN

  • data10
    Input data 10.

    • verbose name: Data10
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: IN

  • dataN
    Additional input data.

    • verbose name: Datan
    • default value: None
    • port type: DataPort
    • value type: list (can be None)
    • data direction: IN

  • outdata
    Data to process.

    • verbose name: Outdata
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: OUT

  • replace_if_exists
    Replace streams if they already exist.

    • verbose name: Replace If Exists
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

  • sorting
    Sorting order of chunks in the packet.

    • verbose name: Sorting
    • default value: input
    • port type: EnumPort
    • value type: str (can be None)

RenameStreams

Rename streams in the given data.

This node can flexibly rename streams. Note that such renaming is rarely necessary since almost all nodes identify the streams to act on by their properties rather than name. However, in some settings, such as when multiple streams are merged using the MergeStreams node, or when data is handed off to external applications, renaming streams can be helpful.

Version 1.1.0

Ports/Properties

  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)

  • data
    Data to process.

    • verbose name: Data
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: INOUT

  • name_changes
    Name changes to apply. This is formatted as in {'myoldname1': 'mynewname1', 'myoldname2': 'mynewname2', ...}. Streams that are not mentioned in this mapping keep their name. Special case: You may use '*' for the original name if the stream name is not known, which will match the first stream found (depending on the 'wildcard stream filter'). This can be combined with other name changes.

    • verbose name: Name Changes
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)

  • wildcard_stream_filter
    If a namechange uses the '*' wildcard, you can select either the first matching stream ('any stream'), the first event stream ('event stream only'), or the first non-event stream ('non event stream only'). Alternatively you can select patternmatch and include * and ? wildcards in the name pattern.

    • verbose name: Wildcard Stream Filter
    • default value: any stream
    • port type: EnumPort
    • value type: str (can be None)

  • drop_others
    Drop all streams that are not mentioned in the name changes.

    • verbose name: Drop Other Streams
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

Segmentation

Cut fixed-length segments out of a continuous time series.

This node requires input data that has both a multi-channel time-series stream (channels by samples), and a marker stream in it. The node will then cut out a segment around each marker of interest, and return a packet that is a 3d array of extracted same-length segments. Important: Note that the markers of interest first need to be flagged as "target markers", using the Assign Target Markers node (usually segments are only extracted around a subset of marker types). A typical setup consists of the Assign Target Markers node followed by the Segmentation node. Note that the data that comes out of this node is no longer a continuous time series, but instead is now segmented. The resulting array has a new axis that indexes the segments (this is a so-called "instance" axis). This processing step is also called epoching in some other frameworks (e.g., EEGLAB). This node will work both on packets that contain an entire recording (it will then extract one segment for each target marker in the recording), as well as as on packets that are streaming. In the former case, markers that would produce segments that extend beyond data limits are ignored; see RemoveIntersectingMarkers node to remove these markers prior to Segmentation. In the latter case the node consumes chunks and emits segments as soon as all the data that is overlapped by the segment has been received ( therefore, for a given nonempty input chunk, this node may output zero, one, or more segments). There is also an optional mode that extracts a single sliding segment on each update that lies at the end of the data received by the node (see online segmentation mode parameter). The new segments receive new time stamps that are relative to the marker around which they were originally extracted (i.e., the part of the segment that lies before the marker, if any, will have negative time stamps). The absolute time of the marker is stored as well, though (so no information is lost). The instance axis data contains a rec array corresponding to a table of independent variables. Default columns include Marker, TargetValue, TrialIndex, and possibly Subject and Session if they can be determined automatically.

Version 1.0.2

Ports/Properties

  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)

  • data
    Data to segment.

    • verbose name: Data
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: INOUT

  • time_bounds
    Time limits for extracted segments, relative to the position of the marker, in seconds. For each target marker, a segment will be extracted around it, and the beginning and end of the segment is given by these two values (e.g., [-1, 2] yields segments that begin one second before the marker and end two seconds after the marker). Segments may intersect the marker, or lie before it, or lie after it.

    • verbose name: Segment Time Limits
    • default value: [-1, 2]
    • port type: ListPort
    • value type: list (can be None)

  • select_markers
    (Optional) Data will be segmented around these markers only. This is a list of marker strings. If this is not provided, but target values have been assigned to markers in a previous step (typically using the AssignTargets node), then segmentation will extract segments only around those markers that have target values set. Otherwise this node will fall back to all markers in the data, except for markers that are empty strings (e.g., scrubbed using some preceding marker rewriting node).

    • verbose name: Select Markers
    • default value: None
    • port type: ListPort
    • value type: list (can be None)

  • online_epoching
    Online segment extraction mode. If this is set to marker-locked, then segments will be extracted the same way on streaming data ("online") as on non-streaming data such as imported recordings ("offline"). If this is set to sliding, then for online data, on each tick a single segment will be extracted that lies at the end of the data received by this node. This mode can be handy when the remainder of the pipeline is calibrated on data relative to markers, but during online processing the pipeline should produce outputs continuously, regardless of whether there is any marker or not.

    • verbose name: Online Segmentation Mode
    • default value: marker-locked
    • port type: EnumPort
    • value type: str (can be None)

  • sample_offset
    Optional additional shift of the segment position, in samples. This setting allows to shift all segments by this many samples relative to the marker, which can be used to match the behavior of other systems (e.g., BCILAB or EEGLAB) in a sample-exact fashion.

    • verbose name: Additional Sample Offset
    • default value: 0
    • port type: IntPort
    • value type: int (can be None)

  • max_gap_length
    Maximum length of time-stamp gaps that are allowed in segments. If a gap between successive samples is larger than this duration in seconds, then the affected segment is not extracted. Optional. Note that if your time stamps are jittered, this will generate a lot of false positives unless you use a very generous cutoff. You can use the DejitterTimestamps node early during your processing to fix that. Set to 0 or empty (None) to disable.

    • verbose name: Max Gap Length
    • default value: 0.2
    • port type: FloatPort
    • value type: float (can be None)

  • keep_marker_chunk
    Whether or not to keep the selected markers in a chunk called 'segmented-markers'.

    • verbose name: Keep Marker Chunk
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

  • verbose
    Verbose output. Can be used for debugging your pipeline.

    • verbose name: Verbose
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

SelectInstances

Select instances (trials) based on metadata contained in the instance data field.

This is used to select trials matching certain criteria, such as subject, session, group, task, conditions, etc. See SetInstanceDetails to apply metadata extracted from the file path (using PathIterator) to each trial (which can then be used by this node).

Version 1.1.1

Ports/Properties

  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)

  • data
    Data to process.

    • verbose name: Data
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: INOUT

  • condition
    Optional condition expression in Python syntax. This is a Python expression interpreted in the context of instance fields, e.g., Marker=='stimulus'. See documentation of NeuroPype's Query Grammar for differences compared to full Python syntax. If desired, additional criteria can be provided using selection and associated arguments, and will be combined using the combine_selections operator. The final result is modifiable with the invert_selection operator.

    • verbose name: Condition
    • default value:
    • port type: StringPort
    • value type: str (can be None)

  • selection
    Described the instance selection criteria. Several formats are permitted: simple string - e.g. 'Go' - This will be compared against the 'Marker' field. dictionary without 'name' field - e.g. {'Marker': 'Go', 'Result': ['Success', 'Unknown']} - The dict keys indicate the name of the instance data fields, and the dict values are used to compare to the values. dictionary with 'name' field - e.g. {'name': 'Marker', 'value': 'Go'} 'name': Name of the column in the instance axis data table (IV table). 'operator': (optional) The comparison operator. If not provided then the value in 'default_comparison_operator' will be used. Also see default_comparison_operator for the list of possible operators. 'value': (optional) The value that each IV cell in the column will be compared against. If not provided then None is assumed. A list of the aforementioned dictionaries.

    • verbose name: Selection
    • default value: None
    • port type: Port
    • value type: object (can be None)

  • default_comparison_operator
    When selection argument does not provide an operator, this operator is used. 'auto' changes depending on provided 'value'. If 'value' is None or nan, then 'auto' will behave like 'not_equal'. Otherwise ('value' is valid), 'auto' will behave like 'equal'. If 'value' is a string (or list of strings), then some comparison operators will be remapped: greater or greater_equal -> startswith; less or less_equal -> endswith; equal -> fnmatch(test, pattern) not_equal -> not isin

    • verbose name: Default Comparison Operator
    • default value: auto
    • port type: EnumPort
    • value type: str (can be None)

  • combine_selections
    Logical operator to use to combine evaluations specified in selection argument.

    • verbose name: Combine Selections
    • default value: and
    • port type: EnumPort
    • value type: str (can be None)

  • invert_selection
    If set then the resulting of the selection comparison check will be inverted before logical combination with previous IsGood values.

    • verbose name: Invert Selection
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

  • combine_previous
    Logical operator to use to combine overall selection result with previous IsGood values. Use 'override' to ignore previous values.

    • verbose name: Combine Previous
    • default value: override
    • port type: EnumPort
    • value type: str (can be None)

  • drop_immediately
    Can drop !IsGood rows immediately. Otherwise merge this output with other packets then use DropBadTrials node.

    • verbose name: Drop Immediately
    • default value: True
    • port type: BoolPort
    • value type: bool (can be None)

  • assign_target_value
    For instances matching the selection criteria, set their TargetValue field to this value. Note that when this value is not None, only the TargetValue is updated and the IsGood field is not updated. A consequence is that calling SelectInstances again on the same packet using combine_previous will give unexpected behaviour.

    • verbose name: Assign Target Value
    • default value: None
    • port type: FloatPort
    • value type: float (can be None)

SeparateSignalStreams

Separate the signal streams from the non-signal streams.

An incoming data packet may carry multiple data streams, and for each stream a packet will have one chunk. Some of these chunks may be specifically flagged as 'signal' streams (multi-channel time series) while other may not be (e.g., feature vectors, marker streams, predictions). Some of the filter nodes will only work on signal streams and will not apply cleanly on non-signal streams, so if a packet that has mixed content shall be filtered with such a node, the signal streams must be separated out first. This node has two outputs: one that carries the signal streams, and another one that carries all other streams. After processing, the streams may be merged again using MergeStreams.

Version 1.0.0

Ports/Properties

  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)

  • data
    Data to process.

    • verbose name: Data
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: IN

  • signals
    Data with only signal streams.

    • verbose name: Signals
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: OUT

  • nonsignals
    Data with only non-signal streams.

    • verbose name: Nonsignals
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: OUT

SetInstanceDetails

Set per-instance (e.g

., per-trial) metadata. This node adds or overrides instance.data fields in the given data's instance axis. Note that for this to happen, the data must already have an instance axis (e.g., be segmented). One of the most common uses of this node is in combination with the PathIterator node. The PathIterator can parse metadata out of the path for each file (e.g., subject id, session, group, task, and so on). It outputs this metadata in through the 'curmeta' port, in the form of a Python dictionary. That output can then be wired into SetInstanceDetails, which then adds the metadata to the instance axis of each trial extracted from the given dataset. This information is used by statistics nodes (like GroupedMean), or to select a set of trials for processing or output (like SelectInstances).

Version 0.5.1

Ports/Properties

  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)

  • data
    Data to process.

    • verbose name: Data
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: INOUT

  • details
    Details to apply to instances. A common source of details is the curmeta output of the PathIterator node.

    • verbose name: Details
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)

  • from_props
    Transfer from stream/chunk properties. If set to True, then details is formatted as {'instance-field': 'property-field', ...} and specifies what property field to take each instance field from.

    • verbose name: From Props
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

  • condition
    Apply only to instances that meet this condition. This is a Python expression interpreted in the context of instance fields, e.g., Marker=='stimulus'. See documentation of NeuroPype's Query Grammar for differences compared to full Python syntax.

    • verbose name: Condition
    • default value:
    • port type: StringPort
    • value type: str (can be None)

  • assume_categorical
    Assume that all fields provided in details are categorical variables.

    • verbose name: Assume Categorical
    • default value: True
    • port type: BoolPort
    • value type: bool (can be None)

  • auto_capitalize
    Automatically capitalize the instance-axis fields if they are not already capitalized. The on (warn) setting will capitalize the fields and issue a one-time warning if any fields were capitalized.

    • verbose name: Auto Capitalize
    • default value: on (warn)
    • port type: EnumPort
    • value type: str (can be None)

StreamData

Play back a data set in real time or at a desired rate.

This node requires as input a packet that holds the entire recording to play back, for example the output of one of the data import nodes. A common setup is an import node followed by a Stream Data node, followed by some processing, visualization, or network streaming. You can play back either based on wall-clock time, optionally modified by a speedup factor, or you can use an abstract clock that advances by a deterministic amount from one tick to the next. The latter is more useful when you are debugging your code, e.g., when you need to be able to exactly recreate a situation in which an error occurred previously. This node is also able to simulate a variety of issues that occur in real-world data sources, such as jitter in the emitted chunk sizes and empty packets -- these special features are mainly useful for testing and debugging your own nodes.

Version 1.3.0

Ports/Properties

  • set_breakpoint
    Set a breakpoint on this node. If this is enabled, your debugger (if one is attached) will trigger a breakpoint.

    • verbose name: Set Breakpoint (Debug Only)
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

  • metadata
    User-definable meta-data associated with the node. Usually reserved for technical purposes.

    • verbose name: Metadata
    • default value: {}
    • port type: DictPort
    • value type: dict (can be None)

  • data
    Data to stream.

    • verbose name: Data
    • default value: None
    • port type: DataPort
    • value type: Packet (can be None)
    • data direction: INOUT

  • data_range_to_stream
    How the range of data to be streamed, based on the first and last timestamps, is determined in cases where the packet contains multiple streams. Since the first and last timestamps in all streams many not be exactly the same, one must decide which stream's timestamps to choose as the start and end times between which data from all streams will be streamed. This choice depends on your data and desired streamed output (including downstream processing). Options:

    • all-signal-data: the first and last timestamps of all signal streams (i.e., not any event streams) will be used; all data in all signal streams will be streamed, but some streams may have no data at the beginning or end; marker events outside those timestamps will not be streamed.
    • signal-data-and-markers: the first and last timestamps across all streams, including event streams, will be used; choose this option if you want to ensure that event markers at or very near the beginning and end of the data are streamed, or if you used the TrimMarkerSegment node before this one to trim the data between two markers and want to ensure those same bookending markers get streamed.
    • overlapping-signal-data-only: choose the first and last timestamps that are common to all signal data streams; this ensures that all streams have data right from the start, though some streams may be trimmed depending on whether they all started and ended at the same time; the very first and last event markers might not be streamed depending on how they are aligned with the first and last timestamps of the signal streams.
    • legacy-warn: same as overlapping-signal-data-only, but a warning is emitted to explicitly select one of the other options as this legacy option will be removed in a future release.

    • verbose name: Data Range To Stream
    • default value: legacy-warn
    • port type: EnumPort
    • value type: str (can be None)

  • timing
    Timing mode. The wallclock mode means that playback is based on actual elapsed time (i.e., this means playback speed is real time), and the deterministic mode means that an abstract clock is used that advances by a mathematically determined amount on each tick (this would generally not be real time). The first mode is what is used to simulate a live device, and the second mode can be used for debugging your code (because on each run, exactly the same sequence of data is emitted by the node, which allows you to replicate a problem exactly and drill into it), and/or to build pipelines that process data in a streaming fashion, but do so at faster-than-real-time rates.

    • verbose name: Timing Mode
    • default value: wallclock
    • port type: EnumPort
    • value type: str (can be None)

  • looping
    Looping playback. Whether to stream the data in a loop.

    • verbose name: Looping
    • default value: True
    • port type: BoolPort
    • value type: bool (can be None)

  • speedup
    Speedup factor for wallclock mode. This is the speedup, relative to the actually elapsed time, at which the data is played back (e.g., 2 means that the data is played back at 2x real time). This setting is ignored in deterministic mode.

    • verbose name: Speedup Factor (Wallclock Mode)
    • default value: 1.0
    • port type: FloatPort
    • value type: float (can be None)

  • update_interval
    Average chunk length per tick for deterministic mode, in seconds. The length of each individual chunk is drawn from a Gaussian distribution with this value as the mean and a standard deviation based on the jitter percentage. This setting is ignored in wallclock mode.

    • verbose name: Chunk Length Mean (Deterministic Mode)
    • default value: 0.04
    • port type: FloatPort
    • value type: float (can be None)

  • jitter_percent
    Pseudo-random jitter applied to the chunk length in deterministic mode, in percent. On each tick a chunk is emitted whose length is drawn pseudo-randomly from a Gaussian distribution with a mean value and a standard deviation that is a percentage of that mean. For instance, if the mean chunk length is set to 0.15 (seconds), and this value is set to 20 (percent), then the chunks are 0.15 +/- 0.03 seconds long. The purpose of this is to simulate natural variation that could occur in a real-world data source to reveal potential issues in downstream nodes.

    • verbose name: Chunk Length Std (Deterministic Mode)
    • default value: 5
    • port type: FloatPort
    • value type: float (can be None)

  • randseed
    Random seed for deterministic mode. This value allows to change the series of chunk lengths that is generated by the random number generator.

    • verbose name: Random Seed
    • default value: 34535
    • port type: IntPort
    • value type: int (can be None)

  • hitch_probability
    Probability of simulated hitches, in Percent. The node generates an empty packet with this probability. This can be used to test whether subsequent nodes are robust to empty packets.

    • verbose name: Hitch Probability
    • default value: 0.0
    • port type: FloatPort
    • value type: float (can be None)

  • timestamp_jitter
    Pseudo-random jitter applied to the time stamps. This is the standard deviation of a normal distribution, in seconds.

    • verbose name: Timestamp Jitter
    • default value: 0.0
    • port type: FloatPort
    • value type: float (can be None)

  • start_pos
    Starting position for playback. This is the time offset, in seconds from the beginning of the data, where playback should start.

    • verbose name: Start Pos
    • default value: 0.0
    • port type: FloatPort
    • value type: float (can be None)

  • log_progress
    Log the progress in percent.

    • verbose name: Log Progress
    • default value: False
    • port type: BoolPort
    • value type: bool (can be None)

  • data_dtype
    Optionally force override the output data type.

    • verbose name: Data Dtype
    • default value: float64
    • port type: EnumPort
    • value type: str (can be None)