NWB Core

2.6.9

class datetime(year, month, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]])

The year, month and day arguments are required. tzinfo may be None, or an instance of a tzinfo subclass. The remaining arguments may be ints.

hour

minute

second

microsecond

tzinfo

fold

fromtimestamp()

timestamp[, tz] -> tz’s local time from POSIX timestamp.

utcfromtimestamp()

Construct a naive UTC datetime from a POSIX timestamp.

now()

Returns new datetime object representing current time local to tz.

tz

Timezone object.

If no tz is specified, uses local timezone.

utcnow()

Return a new datetime representing UTC day and time.

combine()

date, time -> datetime with same date and time fields

fromisoformat()

string -> datetime from a string in most ISO 8601 formats

timetuple()

Return time tuple, compatible with time.localtime().

timestamp()

Return POSIX timestamp as float.

utctimetuple()

Return UTC time tuple, compatible with time.localtime().

date()

Return date object with same year, month and day.

time()

Return time object with same time but with tzinfo=None.

timetz()

Return time object with same time and tzinfo.

replace()

Return datetime with new specified fields.

astimezone()

tz -> convert to local time in new timezone tz

ctime()

Return ctime() style string.

isoformat()

[sep] -> string in ISO 8601 format, YYYY-MM-DDT[HH[:MM[:SS[.mmm[uuu]]]]][+HH:MM]. sep is used to separate the year from the time, and defaults to ‘T’. The optional argument timespec specifies the number of additional terms of the time to include. Valid options are ‘auto’, ‘hours’, ‘minutes’, ‘seconds’, ‘milliseconds’ and ‘microseconds’.

strptime()

string, format -> new datetime parsed from a string (like time.strptime()).

utcoffset()

Return self.tzinfo.utcoffset(self).

tzname()

Return self.tzinfo.tzname(self).

dst()

Return self.tzinfo.dst(self).

max = datetime.datetime(9999, 12, 31, 23, 59, 59, 999999)

min = datetime.datetime(1, 1, 1, 0, 0)

resolution = datetime.timedelta(microseconds=1)

class date

date(year, month, day) –> date object

fromtimestamp()

Create a date from a POSIX timestamp.

The timestamp is a number, e.g. created via time.time(), that is interpreted as local time.

today()

Current date or datetime: same as self.__class__.fromtimestamp(time.time()).

fromordinal()

int -> date corresponding to a proleptic Gregorian ordinal.

fromisoformat()

str -> Construct a date from a string in ISO 8601 format.

fromisocalendar()

int, int, int -> Construct a date from the ISO year, week number and weekday.

This is the inverse of the date.isocalendar() function

ctime()

Return ctime() style string.

strftime()

format -> strftime() style string.

isoformat()

Return string in ISO 8601 format, YYYY-MM-DD.

year

month

day

timetuple()

Return time tuple, compatible with time.localtime().

toordinal()

Return proleptic Gregorian ordinal. January 1 of year 1 is day 1.

replace()

Return date with new specified fields.

weekday()

Return the day of the week represented by the date. Monday == 0 … Sunday == 6

isoweekday()

Return the day of the week represented by the date. Monday == 1 … Sunday == 7

isocalendar()

Return a named tuple containing ISO year, week number, and weekday.

max = datetime.date(9999, 12, 31)

min = datetime.date(1, 1, 1)

resolution = datetime.timedelta(days=1)

class Enum(value, names=None, *, module=None, qualname=None, type=None, start=1, boundary=None)

Create a collection of name/value pairs.

Example enumeration:

>>> class Color(Enum):
...     RED = 1
...     BLUE = 2
...     GREEN = 3

Access them by:

• attribute access:

>>> Color.RED
<Color.RED: 1>

• value lookup:

>>> Color(1)
<Color.RED: 1>

• name lookup:

>>> Color['RED']
<Color.RED: 1>

Enumerations can be iterated over, and know how many members they have:

>>> len(Color)
3

>>> list(Color)
[<Color.RED: 1>, <Color.BLUE: 2>, <Color.GREEN: 3>]

Methods can be added to enumerations, and members can have their own attributes – see the documentation for details.

name

The name of the Enum member.

value

The value of the Enum member.

class Any(*args, **kwargs)

Special type indicating an unconstrained type.

• Any is compatible with every type.

• Any assumed to have all methods.

• All values assumed to be instances of Any.

Note that all the above statements are true from the point of view of static type checkers. At runtime, Any should not be used with instance checks.

pydantic model BaseModel

Usage docs: https://docs.pydantic.dev/2.4/concepts/models/

A base class for creating Pydantic models.

__class_vars__

The names of classvars defined on the model.

__private_attributes__

Metadata about the private attributes of the model.

__signature__

The signature for instantiating the model.

__pydantic_complete__

Whether model building is completed, or if there are still undefined fields.

__pydantic_core_schema__

The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.

__pydantic_custom_init__

Whether the model has a custom __init__ function.

__pydantic_decorators__

Metadata containing the decorators defined on the model. This replaces Model.__validators__ and Model.__root_validators__ from Pydantic V1.

__pydantic_generic_metadata__

Metadata for generic models; contains data used for a similar purpose to __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.

__pydantic_parent_namespace__

Parent namespace of the model, used for automatic rebuilding of models.

__pydantic_post_init__

The name of the post-init method for the model, if defined.

__pydantic_root_model__

Whether the model is a RootModel.

__pydantic_serializer__

The pydantic-core SchemaSerializer used to dump instances of the model.

__pydantic_validator__

The pydantic-core SchemaValidator used to validate instances of the model.

__pydantic_extra__

An instance attribute with the values of extra fields from validation when model_config[‘extra’] == ‘allow’.

__pydantic_fields_set__

An instance attribute with the names of fields explicitly specified during validation.

__pydantic_private__

Instance attribute with the values of private attributes set on the model instance.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

classmethod construct(_fields_set: set[str] | None = None, **values: Any) → Model

copy(*, include: AbstractSetIntStr | MappingIntStrAny | None = None, exclude: AbstractSetIntStr | MappingIntStrAny | None = None, update: Dict[str, Any] | None = None, deep: bool = False) → Model

Returns a copy of the model.

!!! warning “Deprecated”

This method is now deprecated; use model_copy instead.

If you need include or exclude, use:

`py data = self.model_dump(include=include, exclude=exclude, round_trip=True) data = {**data, **(update or {})} copied = self.model_validate(data) `

Parameters:

• include – Optional set or mapping specifying which fields to include in the copied model.

• exclude – Optional set or mapping specifying which fields to exclude in the copied model.

• update – Optional dictionary of field-value pairs to override field values in the copied model.

• deep – If True, the values of fields that are Pydantic models will be deep copied.

Returns:

A copy of the model with included, excluded and updated fields as specified.

dict(*, include: IncEx = None, exclude: IncEx = None, by_alias: bool = False, exclude_unset: bool = False, exclude_defaults: bool = False, exclude_none: bool = False) → Dict[str, Any]

classmethod from_orm(obj: Any) → Model

json(*, include: IncEx = None, exclude: IncEx = None, by_alias: bool = False, exclude_unset: bool = False, exclude_defaults: bool = False, exclude_none: bool = False, encoder: Callable[[Any], Any] | None = PydanticUndefined, models_as_dict: bool = PydanticUndefined, **dumps_kwargs: Any) → str

classmethod model_construct(_fields_set: set[str] | None = None, **values: Any) → Model

Creates a new instance of the Model class with validated data.

Creates a new model setting __dict__ and __pydantic_fields_set__ from trusted or pre-validated data. Default values are respected, but no other validation is performed. Behaves as if Config.extra = ‘allow’ was set since it adds all passed values

Parameters:

• _fields_set – The set of field names accepted for the Model instance.

• values – Trusted or pre-validated data dictionary.

Returns:

A new instance of the Model class with validated data.

model_copy(*, update: dict[str, Any] | None = None, deep: bool = False) → Model

Usage docs: https://docs.pydantic.dev/2.4/concepts/serialization/#model_copy

Returns a copy of the model.

Parameters:

• update – Values to change/add in the new model. Note: the data is not validated before creating the new model. You should trust this data.

• deep – Set to True to make a deep copy of the model.

Returns:

New model instance.

model_dump(*, mode: Literal['json', 'python'] | str = 'python', include: IncEx = None, exclude: IncEx = None, by_alias: bool = False, exclude_unset: bool = False, exclude_defaults: bool = False, exclude_none: bool = False, round_trip: bool = False, warnings: bool = True) → dict[str, Any]

Usage docs: https://docs.pydantic.dev/2.4/concepts/serialization/#modelmodel_dump

Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.

Parameters:

• mode – The mode in which to_python should run. If mode is ‘json’, the dictionary will only contain JSON serializable types. If mode is ‘python’, the dictionary may contain any Python objects.

• include – A list of fields to include in the output.

• exclude – A list of fields to exclude from the output.

• by_alias – Whether to use the field’s alias in the dictionary key if defined.

• exclude_unset – Whether to exclude fields that are unset or None from the output.

• exclude_defaults – Whether to exclude fields that are set to their default value from the output.

• exclude_none – Whether to exclude fields that have a value of None from the output.

• round_trip – Whether to enable serialization and deserialization round-trip support.

• warnings – Whether to log warnings when invalid fields are encountered.

Returns:

A dictionary representation of the model.

model_dump_json(*, indent: int | None = None, include: IncEx = None, exclude: IncEx = None, by_alias: bool = False, exclude_unset: bool = False, exclude_defaults: bool = False, exclude_none: bool = False, round_trip: bool = False, warnings: bool = True) → str

Usage docs: https://docs.pydantic.dev/2.4/concepts/serialization/#modelmodel_dump_json

Generates a JSON representation of the model using Pydantic’s to_json method.

Parameters:

• indent – Indentation to use in the JSON output. If None is passed, the output will be compact.

• include – Field(s) to include in the JSON output. Can take either a string or set of strings.

• exclude – Field(s) to exclude from the JSON output. Can take either a string or set of strings.

• by_alias – Whether to serialize using field aliases.

• exclude_unset – Whether to exclude fields that have not been explicitly set.

• exclude_defaults – Whether to exclude fields that have the default value.

• exclude_none – Whether to exclude fields that have a value of None.

• round_trip – Whether to use serialization/deserialization between JSON and class instance.

• warnings – Whether to show any warnings that occurred during serialization.

Returns:

A JSON string representation of the model.

classmethod model_json_schema(by_alias: bool = True, ref_template: str = '#/$defs/{model}', schema_generator: type[~pydantic.json_schema.GenerateJsonSchema] = <class 'pydantic.json_schema.GenerateJsonSchema'>, mode: ~typing.Literal['validation', 'serialization'] = 'validation') → dict[str, Any]

Generates a JSON schema for a model class.

Parameters:

• by_alias – Whether to use attribute aliases or not.

• ref_template – The reference template.

• schema_generator – To override the logic used to generate the JSON schema, as a subclass of GenerateJsonSchema with your desired modifications

• mode – The mode in which to generate the schema.

Returns:

The JSON schema for the given model class.

classmethod model_parametrized_name(params: tuple[type[Any], ...]) → str

Compute the class name for parametrizations of generic classes.

This method can be overridden to achieve a custom naming scheme for generic BaseModels.

Parameters:

params – Tuple of types of the class. Given a generic class Model with 2 type variables and a concrete model Model[str, int], the value (str, int) would be passed to params.

Returns:

String representing the new class where params are passed to cls as type variables.

Raises:

TypeError – Raised when trying to generate concrete names for non-generic models.

model_post_init(_BaseModel__context: Any) → None

Override this method to perform additional initialization after __init__ and model_construct. This is useful if you want to do some validation that requires the entire model to be initialized.

classmethod model_rebuild(*, force: bool = False, raise_errors: bool = True, _parent_namespace_depth: int = 2, _types_namespace: dict[str, Any] | None = None) → bool | None

Try to rebuild the pydantic-core schema for the model.

This may be necessary when one of the annotations is a ForwardRef which could not be resolved during the initial attempt to build the schema, and automatic rebuilding fails.

Parameters:

• force – Whether to force the rebuilding of the model schema, defaults to False.

• raise_errors – Whether to raise errors, defaults to True.

• _parent_namespace_depth – The depth level of the parent namespace, defaults to 2.

• _types_namespace – The types namespace, defaults to None.

Returns:

Returns None if the schema is already “complete” and rebuilding was not required. If rebuilding _was_ required, returns True if rebuilding was successful, otherwise False.

classmethod model_validate(obj: Any, *, strict: bool | None = None, from_attributes: bool | None = None, context: dict[str, Any] | None = None) → Model

Validate a pydantic model instance.

Parameters:

• obj – The object to validate.

• strict – Whether to raise an exception on invalid fields.

• from_attributes – Whether to extract data from object attributes.

• context – Additional context to pass to the validator.

Raises:

ValidationError – If the object could not be validated.

Returns:

The validated model instance.

classmethod model_validate_json(json_data: str | bytes | bytearray, *, strict: bool | None = None, context: dict[str, Any] | None = None) → Model

Validate the given JSON data against the Pydantic model.

Parameters:

• json_data – The JSON data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

Returns:

The validated Pydantic model.

Raises:

ValueError – If json_data is not a JSON string.

classmethod model_validate_strings(obj: Any, *, strict: bool | None = None, context: dict[str, Any] | None = None) → Model

Validate the given object contains string data against the Pydantic model.

Parameters:

• obj – The object contains string data to validate.

• strict – Whether to enforce types strictly.

• context – Extra variables to pass to the validator.

Returns:

The validated Pydantic model.

classmethod parse_file(path: str | Path, *, content_type: str | None = None, encoding: str = 'utf8', proto: DeprecatedParseProtocol | None = None, allow_pickle: bool = False) → Model

classmethod parse_obj(obj: Any) → Model

classmethod parse_raw(b: str | bytes, *, content_type: str | None = None, encoding: str = 'utf8', proto: DeprecatedParseProtocol | None = None, allow_pickle: bool = False) → Model

classmethod schema(by_alias: bool = True, ref_template: str = '#/$defs/{model}') → Dict[str, Any]

classmethod schema_json(*, by_alias: bool = True, ref_template: str = '#/$defs/{model}', **dumps_kwargs: Any) → str

classmethod update_forward_refs(**localns: Any) → None

classmethod validate(value: Any) → Model

property model_computed_fields: dict[str, ComputedFieldInfo]

Get the computed fields of this model instance.

Returns:

A dictionary of computed field names and their corresponding ComputedFieldInfo objects.

property model_extra: dict[str, Any] | None

Get extra fields set during validation.

Returns:

A dictionary of extra fields, or None if config.extra is not set to “allow”.

property model_fields_set: set[str]

Returns the set of fields that have been set on this model instance.

Returns:

A set of strings representing the fields that have been set,

i.e. that were not filled from defaults.

Field(default: Any = PydanticUndefined, *, default_factory: Callable[[], Any] | None = PydanticUndefined, alias: str | None = PydanticUndefined, alias_priority: int | None = PydanticUndefined, validation_alias: str | AliasPath | AliasChoices | None = PydanticUndefined, serialization_alias: str | None = PydanticUndefined, title: str | None = PydanticUndefined, description: str | None = PydanticUndefined, examples: list[Any] | None = PydanticUndefined, exclude: bool | None = PydanticUndefined, discriminator: str | None = PydanticUndefined, json_schema_extra: dict[str, Any] | Callable[[dict[str, Any]], None] | None = PydanticUndefined, frozen: bool | None = PydanticUndefined, validate_default: bool | None = PydanticUndefined, repr: bool = PydanticUndefined, init_var: bool | None = PydanticUndefined, kw_only: bool | None = PydanticUndefined, pattern: str | None = PydanticUndefined, strict: bool | None = PydanticUndefined, gt: float | None = PydanticUndefined, ge: float | None = PydanticUndefined, lt: float | None = PydanticUndefined, le: float | None = PydanticUndefined, multiple_of: float | None = PydanticUndefined, allow_inf_nan: bool | None = PydanticUndefined, max_digits: int | None = PydanticUndefined, decimal_places: int | None = PydanticUndefined, min_length: int | None = PydanticUndefined, max_length: int | None = PydanticUndefined, union_mode: Literal['smart', 'left_to_right'] = PydanticUndefined, **extra: Unpack) → Any

Usage docs: https://docs.pydantic.dev/2.4/concepts/fields

Create a field for objects that can be configured.

Used to provide extra information about a field, either for the model schema or complex validation. Some arguments apply only to number fields (int, float, Decimal) and some apply only to str.

Note

• Any _Unset objects will be replaced by the corresponding value defined in the _DefaultValues dictionary. If a key for the _Unset object is not found in the _DefaultValues dictionary, it will default to None

Parameters:

• default – Default value if the field is not set.

• default_factory – A callable to generate the default value, such as utcnow().

• alias – An alternative name for the attribute.

• alias_priority – Priority of the alias. This affects whether an alias generator is used.

• validation_alias – ‘Whitelist’ validation step. The field will be the single one allowed by the alias or set of aliases defined.

• serialization_alias – ‘Blacklist’ validation step. The vanilla field will be the single one of the alias’ or set of aliases’ fields and all the other fields will be ignored at serialization time.

• title – Human-readable title.

• description – Human-readable description.

• examples – Example values for this field.

• exclude – Whether to exclude the field from the model serialization.

• discriminator – Field name for discriminating the type in a tagged union.

• json_schema_extra – Any additional JSON schema data for the schema property.

• frozen – Whether the field is frozen.

• validate_default – Run validation that isn’t only checking existence of defaults. This can be set to True or False. If not set, it defaults to None.

• repr – A boolean indicating whether to include the field in the __repr__ output.

• init_var – Whether the field should be included in the constructor of the dataclass.

• kw_only – Whether the field should be a keyword-only argument in the constructor of the dataclass.

• strict – If True, strict validation is applied to the field. See [Strict Mode](../concepts/strict_mode.md) for details.

• gt – Greater than. If set, value must be greater than this. Only applicable to numbers.

• ge – Greater than or equal. If set, value must be greater than or equal to this. Only applicable to numbers.

• lt – Less than. If set, value must be less than this. Only applicable to numbers.

• le – Less than or equal. If set, value must be less than or equal to this. Only applicable to numbers.

• multiple_of – Value must be a multiple of this. Only applicable to numbers.

• min_length – Minimum length for strings.

• max_length – Maximum length for strings.

• pattern – Pattern for strings.

• allow_inf_nan – Allow inf, -inf, nan. Only applicable to numbers.

• max_digits – Maximum number of allow digits for strings.

• decimal_places – Maximum number of decimal places allowed for numbers.

• union_mode – The strategy to apply when validating a union. Can be smart (the default), or left_to_right. See [Union Mode](standard_library_types.md#union-mode) for details.

• extra –

  Include extra fields used by the JSON schema.

  !!! warning Deprecated

  The extra kwargs is deprecated. Use json_schema_extra instead.

Returns:

A new [FieldInfo][pydantic.fields.FieldInfo], the return annotation is Any so Field can be used on

type annotated fields without causing a typing error.

Float

alias of float64

Float32

alias of float32

Double

alias of float64

Float64

alias of float64

LongLong

alias of longlong

Int64

alias of int64

Int

alias of integer

Int32

alias of int32

Int16

alias of int16

Short

alias of int16

Int8

alias of int8

UInt

alias of uint64

UInt32

alias of uint32

UInt16

alias of uint16

UInt8

alias of uint8

UInt64

alias of uint64

Number

alias of number

Unicode

alias of str_

String

alias of bytes_

Bool

alias of bool_

Datetime64

alias of datetime64

pydantic model ExternalResources

A set of four tables for tracking external resource references in a file. NOTE: this data type is in beta testing and is subject to change in a later version.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• entities (List[Any])

• hdf5_path (Optional[str])

• keys (List[Any])

• name (str)

• object_keys (List[Any])

• objects (List[Any])

• resources (List[Any])

field entities: List[Any] [Optional]

A table for mapping user terms (i.e., keys) to resource entities.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field keys: List[Any] [Optional]

A table for storing user terms that are used to refer to external resources.

field name: str [Required]

field object_keys: List[Any] [Optional]

A table for identifying which objects use which keys.

field objects: List[Any] [Optional]

A table for identifying which objects in a file contain references to external resources.

field resources: List[Any] [Optional]

A table for mapping user terms (i.e., keys) to resource entities.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model CSRMatrix

A compressed sparse row matrix. Data are stored in the standard CSR format, where column indices for row i are stored in indices[indptr[i]:indptr[i+1]] and their corresponding values are stored in data[indptr[i]:indptr[i+1]].

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• data (List[Any])

• hdf5_path (Optional[str])

• indices (List[int])

• indptr (List[int])

• name (str)

• shape (Optional[int])

field data: List[Any] [Optional]

The non-zero values in the matrix.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field indices: List[int] [Optional]

The column indices.

field indptr: List[int] [Optional]

The row index pointer.

field name: str [Required]

field shape: int | None = None

The shape (number of rows, number of columns) of this sparse matrix.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model Data

An abstract data type for a dataset.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• hdf5_path (Optional[str])

• name (str)

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model Container

An abstract data type for a group storing collections of data and metadata. Base type for all data and metadata containers.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• hdf5_path (Optional[str])

• name (str)

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model SimpleMultiContainer

A simple Container for holding onto multiple containers.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• children (Optional[Dict[str, Container]])

• hdf5_path (Optional[str])

• name (str)

field children: Dict[str, Container] | None [Optional]

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model VectorData

An n-dimensional dataset representing a column of a DynamicTable. If used without an accompanying VectorIndex, first dimension is along the rows of the DynamicTable and each step along the first dimension is a cell of the larger table. VectorData can also be used to represent a ragged array if paired with a VectorIndex. This allows for storing arrays of varying length in a single cell of the DynamicTable by indexing into this VectorData. The first vector is at VectorData[0:VectorIndex[0]]. The second vector is at VectorData[VectorIndex[0]:VectorIndex[1]], and so on.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• array (Optional[Union[NDArray[Shape['* dim0'], Any], NDArray[Shape['* dim0, * dim1'], Any], NDArray[Shape['* dim0, * dim1, * dim2'], Any], NDArray[Shape['* dim0, * dim1, * dim2, * dim3'], Any]]])

• description (Optional[str])

• hdf5_path (Optional[str])

• name (str)

field array: NDArray[Shape['* dim0'], Any] | NDArray[Shape['* dim0, * dim1'], Any] | NDArray[Shape['* dim0, * dim1, * dim2'], Any] | NDArray[Shape['* dim0, * dim1, * dim2, * dim3'], Any] | None = None

field description: str | None = None

Description of what these vectors represent.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model VectorIndex

Used with VectorData to encode a ragged array. An array of indices into the first dimension of the target VectorData, and forming a map between the rows of a DynamicTable and the indices of the VectorData. The name of the VectorIndex is expected to be the name of the target VectorData object followed by “_index”.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• array (Optional[Union[NDArray[Shape['* dim0'], Any], NDArray[Shape['* dim0, * dim1'], Any], NDArray[Shape['* dim0, * dim1, * dim2'], Any], NDArray[Shape['* dim0, * dim1, * dim2, * dim3'], Any]]])

• description (Optional[str])

• hdf5_path (Optional[str])

• name (str)

• target (Optional[VectorData])

field array: NDArray[Shape['* dim0'], Any] | NDArray[Shape['* dim0, * dim1'], Any] | NDArray[Shape['* dim0, * dim1, * dim2'], Any] | NDArray[Shape['* dim0, * dim1, * dim2, * dim3'], Any] | None = None

field description: str | None = None

Description of what these vectors represent.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field target: VectorData | None = None

Reference to the target dataset that this index applies to.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model ElementIdentifiers

A list of unique identifiers for values within a dataset, e.g. rows of a DynamicTable.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• array (Optional[NDArray[Shape['* num_elements'], Int]])

• hdf5_path (Optional[str])

• name (str)

field array: NDArray[Shape['* num_elements'], Int] | None = None

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model DynamicTableRegion

DynamicTableRegion provides a link from one table to an index or region of another. The table attribute is a link to another DynamicTable, indicating which table is referenced, and the data is int(s) indicating the row(s) (0-indexed) of the target array. DynamicTableRegion`s can be used to associate rows with repeated meta-data without data duplication. They can also be used to create hierarchical relationships between multiple `DynamicTable`s. `DynamicTableRegion objects may be paired with a VectorIndex object to create ragged references, so a single cell of a DynamicTable can reference many rows of another DynamicTable.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• array (Optional[Union[NDArray[Shape['* dim0'], Any], NDArray[Shape['* dim0, * dim1'], Any], NDArray[Shape['* dim0, * dim1, * dim2'], Any], NDArray[Shape['* dim0, * dim1, * dim2, * dim3'], Any]]])

• description (Optional[str])

• hdf5_path (Optional[str])

• name (str)

• table (Optional[DynamicTable])

field array: NDArray[Shape['* dim0'], Any] | NDArray[Shape['* dim0, * dim1'], Any] | NDArray[Shape['* dim0, * dim1, * dim2'], Any] | NDArray[Shape['* dim0, * dim1, * dim2, * dim3'], Any] | None = None

field description: str | None = None

Description of what this table region points to.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field table: DynamicTable | None = None

Reference to the DynamicTable object that this region applies to.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model DynamicTable

A group containing multiple datasets that are aligned on the first dimension (Currently, this requirement if left up to APIs to check and enforce). These datasets represent different columns in the table. Apart from a column that contains unique identifiers for each row, there are no other required datasets. Users are free to add any number of custom VectorData objects (columns) here. DynamicTable also supports ragged array columns, where each element can be of a different size. To add a ragged array column, use a VectorIndex type to index the corresponding VectorData type. See documentation for VectorData and VectorIndex for more details. Unlike a compound data type, which is analogous to storing an array-of-structs, a DynamicTable can be thought of as a struct-of-arrays. This provides an alternative structure to choose from when optimizing storage for anticipated access patterns. Additionally, this type provides a way of creating a table without having to define a compound type up front. Although this convenience may be attractive, users should think carefully about how data will be accessed. DynamicTable is more appropriate for column-centric access, whereas a dataset with a compound type would be more appropriate for row-centric access. Finally, data size should also be taken into account. For small tables, performance loss may be an acceptable trade-off for the flexibility of a DynamicTable.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• colnames (Optional[str])

• description (Optional[str])

• hdf5_path (Optional[str])

• id (List[int])

• name (str)

• vector_data (Optional[List[VectorData]])

field colnames: str | None = None

The names of the columns in this table. This should be used to specify an order to the columns.

field description: str | None = None

Description of what is in this dynamic table.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field id: List[int] [Optional]

Array of unique identifiers for the rows of this dynamic table.

field name: str [Required]

field vector_data: List[VectorData] | None [Optional]

Vector columns, including index columns, of this dynamic table.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model AlignedDynamicTable

DynamicTable container that supports storing a collection of sub-tables. Each sub-table is a DynamicTable itself that is aligned with the main table by row index. I.e., all DynamicTables stored in this group MUST have the same number of rows. This type effectively defines a 2-level table in which the main data is stored in the main table implemented by this type and additional columns of the table are grouped into categories, with each category being represented by a separate DynamicTable stored within the group.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• children (Optional[Dict[str, DynamicTable]])

• colnames (Optional[str])

• description (Optional[str])

• hdf5_path (Optional[str])

• id (List[int])

• name (str)

• vector_data (Optional[List[VectorData]])

field children: Dict[str, DynamicTable] | None [Optional]

field colnames: str | None = None

The names of the columns in this table. This should be used to specify an order to the columns.

field description: str | None = None

Description of what is in this dynamic table.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field id: List[int] [Optional]

Array of unique identifiers for the rows of this dynamic table.

field name: str [Required]

field vector_data: List[VectorData] | None [Optional]

Vector columns, including index columns, of this dynamic table.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model EnumData

Data that come from a fixed set of values. A data value of i corresponds to the i-th value in the VectorData referenced by the ‘elements’ attribute.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• array (Optional[Union[NDArray[Shape['* dim0'], Any], NDArray[Shape['* dim0, * dim1'], Any], NDArray[Shape['* dim0, * dim1, * dim2'], Any], NDArray[Shape['* dim0, * dim1, * dim2, * dim3'], Any]]])

• description (Optional[str])

• elements (Optional[VectorData])

• hdf5_path (Optional[str])

• name (str)

field array: NDArray[Shape['* dim0'], Any] | NDArray[Shape['* dim0, * dim1'], Any] | NDArray[Shape['* dim0, * dim1, * dim2'], Any] | NDArray[Shape['* dim0, * dim1, * dim2, * dim3'], Any] | None = None

field description: str | None = None

Description of what these vectors represent.

field elements: VectorData | None = None

Reference to the VectorData object that contains the enumerable elements

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model ImagingRetinotopy

Intrinsic signal optical imaging or widefield imaging for measuring retinotopy. Stores orthogonal maps (e.g., altitude/azimuth; radius/theta) of responses to specific stimuli and a combined polarity map from which to identify visual areas. This group does not store the raw responses imaged during retinotopic mapping or the stimuli presented, but rather the resulting phase and power maps after applying a Fourier transform on the averaged responses. Note: for data consistency, all images and arrays are stored in the format [row][column] and [row, col], which equates to [y][x]. Field of view and dimension arrays may appear backward (i.e., y before x).

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• axis_1_phase_map (ImagingRetinotopyAxis1PhaseMap)

• axis_1_power_map (Optional[ImagingRetinotopyAxis1PowerMap])

• axis_2_phase_map (ImagingRetinotopyAxis2PhaseMap)

• axis_2_power_map (Optional[ImagingRetinotopyAxis2PowerMap])

• axis_descriptions (List[str])

• focal_depth_image (Optional[ImagingRetinotopyFocalDepthImage])

• hdf5_path (Optional[str])

• name (str)

• sign_map (Optional[ImagingRetinotopySignMap])

• vasculature_image (ImagingRetinotopyVasculatureImage)

field axis_1_phase_map: ImagingRetinotopyAxis1PhaseMap [Required]

Phase response to stimulus on the first measured axis.

field axis_1_power_map: ImagingRetinotopyAxis1PowerMap | None = None

Power response on the first measured axis. Response is scaled so 0.0 is no power in the response and 1.0 is maximum relative power.

field axis_2_phase_map: ImagingRetinotopyAxis2PhaseMap [Required]

Phase response to stimulus on the second measured axis.

field axis_2_power_map: ImagingRetinotopyAxis2PowerMap | None = None

Power response on the second measured axis. Response is scaled so 0.0 is no power in the response and 1.0 is maximum relative power.

field axis_descriptions: List[str] [Optional]

Two-element array describing the contents of the two response axis fields. Description should be something like [‘altitude’, ‘azimuth’] or ‘[‘radius’, ‘theta’].

field focal_depth_image: ImagingRetinotopyFocalDepthImage | None = None

Gray-scale image taken with same settings/parameters (e.g., focal depth, wavelength) as data collection. Array format: [rows][columns].

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field sign_map: ImagingRetinotopySignMap | None = None

Sine of the angle between the direction of the gradient in axis_1 and axis_2.

field vasculature_image: ImagingRetinotopyVasculatureImage [Required]

Gray-scale anatomical image of cortical surface. Array structure: [rows][columns]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model NWBData

An abstract data type for a dataset.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• hdf5_path (Optional[str])

• name (str)

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model TimeSeriesReferenceVectorData

Column storing references to a TimeSeries (rows). For each TimeSeries this VectorData column stores the start_index and count to indicate the range in time to be selected as well as an object reference to the TimeSeries.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• array (Optional[Union[NDArray[Shape['* dim0'], Any], NDArray[Shape['* dim0, * dim1'], Any], NDArray[Shape['* dim0, * dim1, * dim2'], Any], NDArray[Shape['* dim0, * dim1, * dim2, * dim3'], Any]]])

• description (Optional[str])

• hdf5_path (Optional[str])

• name (str)

field array: NDArray[Shape['* dim0'], Any] | NDArray[Shape['* dim0, * dim1'], Any] | NDArray[Shape['* dim0, * dim1, * dim2'], Any] | NDArray[Shape['* dim0, * dim1, * dim2, * dim3'], Any] | None = None

field description: str | None = None

Description of what these vectors represent.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model Image

An abstract data type for an image. Shape can be 2-D (x, y), or 3-D where the third dimension can have three or four elements, e.g. (x, y, (r, g, b)) or (x, y, (r, g, b, a)).

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• array (Optional[Union[NDArray[Shape['* x, * y'], Number], NDArray[Shape['* x, * y, 3 r_g_b'], Number], NDArray[Shape['* x, * y, 3 r_g_b, 4 r_g_b_a'], Number]]])

• description (Optional[str])

• hdf5_path (Optional[str])

• name (str)

• resolution (Optional[float])

field array: NDArray[Shape['* x, * y'], Number] | NDArray[Shape['* x, * y, 3 r_g_b'], Number] | NDArray[Shape['* x, * y, 3 r_g_b, 4 r_g_b_a'], Number] | None = None

field description: str | None = None

Description of the image.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field resolution: float | None = None

Pixel resolution of the image, in pixels per centimeter.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model ImageReferences

Ordered dataset of references to Image objects.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• array (Optional[List[Image] | Image])

• hdf5_path (Optional[str])

• name (str)

field array: List[Image] | Image | None = None

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model NWBContainer

An abstract data type for a generic container storing collections of data and metadata. Base type for all data and metadata containers.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• hdf5_path (Optional[str])

• name (str)

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model NWBDataInterface

An abstract data type for a generic container storing collections of data, as opposed to metadata.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• hdf5_path (Optional[str])

• name (str)

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model TimeSeries

General purpose time series.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• comments (Optional[str])

• control (Optional[List[int]])

• control_description (Optional[List[str]])

• data (TimeSeriesData)

• description (Optional[str])

• hdf5_path (Optional[str])

• name (str)

• starting_time (Optional[TimeSeriesStartingTime])

• sync (Optional[TimeSeriesSync])

• timestamps (Optional[List[float]])

field comments: str | None = None

Human-readable comments about the TimeSeries. This second descriptive field can be used to store additional information, or descriptive information if the primary description field is populated with a computer-readable string.

field control: List[int] | None [Optional]

Numerical labels that apply to each time point in data for the purpose of querying and slicing data by these values. If present, the length of this array should be the same size as the first dimension of data.

field control_description: List[str] | None [Optional]

Description of each control value. Must be present if control is present. If present, control_description[0] should describe time points where control == 0.

field data: TimeSeriesData [Required]

Data values. Data can be in 1-D, 2-D, 3-D, or 4-D. The first dimension should always represent time. This can also be used to store binary data (e.g., image frames). This can also be a link to data stored in an external file.

field description: str | None = None

Description of the time series.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field starting_time: TimeSeriesStartingTime | None = None

Timestamp of the first sample in seconds. When timestamps are uniformly spaced, the timestamp of the first sample can be specified and all subsequent ones calculated from the sampling rate attribute.

field sync: TimeSeriesSync | None = None

Lab-specific time and sync information as provided directly from hardware devices and that is necessary for aligning all acquired time information to a common timebase. The timestamp array stores time in the common timebase. This group will usually only be populated in TimeSeries that are stored external to the NWB file, in files storing raw data. Once timestamp data is calculated, the contents of ‘sync’ are mostly for archival purposes.

field timestamps: List[float] | None [Optional]

Timestamps for samples stored in data, in seconds, relative to the common experiment master-clock stored in NWBFile.timestamps_reference_time.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model ProcessingModule

A collection of processed data.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• children (Optional[Dict[str, Union[DynamicTable, NWBDataInterface]]])

• hdf5_path (Optional[str])

• name (str)

field children: Dict[str, DynamicTable | NWBDataInterface] | None [Optional]

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model Images

A collection of images with an optional way to specify the order of the images using the “order_of_images” dataset. An order must be specified if the images are referenced by index, e.g., from an IndexSeries.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• description (Optional[str])

• hdf5_path (Optional[str])

• image (List[Image])

• name (str)

• order_of_images (Optional[ImagesOrderOfImages])

field description: str | None = None

Description of this collection of images.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field image: List[Image] [Optional]

Images stored in this collection.

field name: str [Required]

field order_of_images: ImagesOrderOfImages | None = None

Ordered dataset of references to Image objects stored in the parent group. Each Image object in the Images group should be stored once and only once, so the dataset should have the same length as the number of images.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model OnePhotonSeries

Image stack recorded over time from 1-photon microscope.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• binning (Optional[int])

• comments (Optional[str])

• control (Optional[List[int]])

• control_description (Optional[List[str]])

• data (ImageSeriesData)

• description (Optional[str])

• dimension (Optional[List[int]])

• exposure_time (Optional[float])

• external_file (Optional[List[str]])

• format (Optional[str])

• hdf5_path (Optional[str])

• intensity (Optional[float])

• name (str)

• pmt_gain (Optional[float])

• power (Optional[float])

• scan_line_rate (Optional[float])

• starting_time (Optional[TimeSeriesStartingTime])

• sync (Optional[TimeSeriesSync])

• timestamps (Optional[List[float]])

field binning: int | None = None

Amount of pixels combined into ‘bins’; could be 1, 2, 4, 8, etc.

field comments: str | None = None

Human-readable comments about the TimeSeries. This second descriptive field can be used to store additional information, or descriptive information if the primary description field is populated with a computer-readable string.

field control: List[int] | None [Optional]

Numerical labels that apply to each time point in data for the purpose of querying and slicing data by these values. If present, the length of this array should be the same size as the first dimension of data.

field control_description: List[str] | None [Optional]

Description of each control value. Must be present if control is present. If present, control_description[0] should describe time points where control == 0.

field data: ImageSeriesData [Required]

Binary data representing images across frames. If data are stored in an external file, this should be an empty 3D array.

field description: str | None = None

Description of the time series.

field dimension: List[int] | None [Optional]

Number of pixels on x, y, (and z) axes.

field exposure_time: float | None = None

Exposure time of the sample; often the inverse of the frequency.

field external_file: List[str] | None [Optional]

Paths to one or more external file(s). The field is only present if format=’external’. This is only relevant if the image series is stored in the file system as one or more image file(s). This field should NOT be used if the image is stored in another NWB file and that file is linked to this file.

field format: str | None = None

Format of image. If this is ‘external’, then the attribute ‘external_file’ contains the path information to the image files. If this is ‘raw’, then the raw (single-channel) binary data is stored in the ‘data’ dataset. If this attribute is not present, then the default format=’raw’ case is assumed.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field intensity: float | None = None

Intensity of the excitation in mW/mm^2, if known.

field name: str [Required]

field pmt_gain: float | None = None

Photomultiplier gain.

field power: float | None = None

Power of the excitation in mW, if known.

field scan_line_rate: float | None = None

Lines imaged per second. This is also stored in /general/optophysiology but is kept here as it is useful information for analysis, and so good to be stored w/ the actual data.

field starting_time: TimeSeriesStartingTime | None = None

Timestamp of the first sample in seconds. When timestamps are uniformly spaced, the timestamp of the first sample can be specified and all subsequent ones calculated from the sampling rate attribute.

field sync: TimeSeriesSync | None = None

Lab-specific time and sync information as provided directly from hardware devices and that is necessary for aligning all acquired time information to a common timebase. The timestamp array stores time in the common timebase. This group will usually only be populated in TimeSeries that are stored external to the NWB file, in files storing raw data. Once timestamp data is calculated, the contents of ‘sync’ are mostly for archival purposes.

field timestamps: List[float] | None [Optional]

Timestamps for samples stored in data, in seconds, relative to the common experiment master-clock stored in NWBFile.timestamps_reference_time.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model TwoPhotonSeries

Image stack recorded over time from 2-photon microscope.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• comments (Optional[str])

• control (Optional[List[int]])

• control_description (Optional[List[str]])

• data (ImageSeriesData)

• description (Optional[str])

• dimension (Optional[List[int]])

• external_file (Optional[List[str]])

• field_of_view (Optional[TwoPhotonSeriesFieldOfView])

• format (Optional[str])

• hdf5_path (Optional[str])

• name (str)

• pmt_gain (Optional[float])

• scan_line_rate (Optional[float])

• starting_time (Optional[TimeSeriesStartingTime])

• sync (Optional[TimeSeriesSync])

• timestamps (Optional[List[float]])

field comments: str | None = None

Human-readable comments about the TimeSeries. This second descriptive field can be used to store additional information, or descriptive information if the primary description field is populated with a computer-readable string.

field control: List[int] | None [Optional]

Numerical labels that apply to each time point in data for the purpose of querying and slicing data by these values. If present, the length of this array should be the same size as the first dimension of data.

field control_description: List[str] | None [Optional]

Description of each control value. Must be present if control is present. If present, control_description[0] should describe time points where control == 0.

field data: ImageSeriesData [Required]

Binary data representing images across frames. If data are stored in an external file, this should be an empty 3D array.

field description: str | None = None

Description of the time series.

field dimension: List[int] | None [Optional]

Number of pixels on x, y, (and z) axes.

field external_file: List[str] | None [Optional]

Paths to one or more external file(s). The field is only present if format=’external’. This is only relevant if the image series is stored in the file system as one or more image file(s). This field should NOT be used if the image is stored in another NWB file and that file is linked to this file.

field field_of_view: TwoPhotonSeriesFieldOfView | None = None

Width, height and depth of image, or imaged area, in meters.

field format: str | None = None

Format of image. If this is ‘external’, then the attribute ‘external_file’ contains the path information to the image files. If this is ‘raw’, then the raw (single-channel) binary data is stored in the ‘data’ dataset. If this attribute is not present, then the default format=’raw’ case is assumed.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field pmt_gain: float | None = None

Photomultiplier gain.

field scan_line_rate: float | None = None

Lines imaged per second. This is also stored in /general/optophysiology but is kept here as it is useful information for analysis, and so good to be stored w/ the actual data.

field starting_time: TimeSeriesStartingTime | None = None

Timestamp of the first sample in seconds. When timestamps are uniformly spaced, the timestamp of the first sample can be specified and all subsequent ones calculated from the sampling rate attribute.

field sync: TimeSeriesSync | None = None

Lab-specific time and sync information as provided directly from hardware devices and that is necessary for aligning all acquired time information to a common timebase. The timestamp array stores time in the common timebase. This group will usually only be populated in TimeSeries that are stored external to the NWB file, in files storing raw data. Once timestamp data is calculated, the contents of ‘sync’ are mostly for archival purposes.

field timestamps: List[float] | None [Optional]

Timestamps for samples stored in data, in seconds, relative to the common experiment master-clock stored in NWBFile.timestamps_reference_time.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model RoiResponseSeries

ROI responses over an imaging plane. The first dimension represents time. The second dimension, if present, represents ROIs.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• comments (Optional[str])

• control (Optional[List[int]])

• control_description (Optional[List[str]])

• data (RoiResponseSeriesData)

• description (Optional[str])

• hdf5_path (Optional[str])

• name (str)

• rois (RoiResponseSeriesRois)

• starting_time (Optional[TimeSeriesStartingTime])

• sync (Optional[TimeSeriesSync])

• timestamps (Optional[List[float]])

field comments: str | None = None

Human-readable comments about the TimeSeries. This second descriptive field can be used to store additional information, or descriptive information if the primary description field is populated with a computer-readable string.

field control: List[int] | None [Optional]

Numerical labels that apply to each time point in data for the purpose of querying and slicing data by these values. If present, the length of this array should be the same size as the first dimension of data.

field control_description: List[str] | None [Optional]

Description of each control value. Must be present if control is present. If present, control_description[0] should describe time points where control == 0.

field data: RoiResponseSeriesData [Required]

Signals from ROIs.

field description: str | None = None

Description of the time series.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field rois: RoiResponseSeriesRois [Required]

DynamicTableRegion referencing into an ROITable containing information on the ROIs stored in this timeseries.

field starting_time: TimeSeriesStartingTime | None = None

Timestamp of the first sample in seconds. When timestamps are uniformly spaced, the timestamp of the first sample can be specified and all subsequent ones calculated from the sampling rate attribute.

field sync: TimeSeriesSync | None = None

Lab-specific time and sync information as provided directly from hardware devices and that is necessary for aligning all acquired time information to a common timebase. The timestamp array stores time in the common timebase. This group will usually only be populated in TimeSeries that are stored external to the NWB file, in files storing raw data. Once timestamp data is calculated, the contents of ‘sync’ are mostly for archival purposes.

field timestamps: List[float] | None [Optional]

Timestamps for samples stored in data, in seconds, relative to the common experiment master-clock stored in NWBFile.timestamps_reference_time.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model DfOverF

dF/F information about a region of interest (ROI). Storage hierarchy of dF/F should be the same as for segmentation (i.e., same names for ROIs and for image planes).

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• children (Optional[Dict[str, RoiResponseSeries]])

• hdf5_path (Optional[str])

• name (str)

field children: Dict[str, RoiResponseSeries] | None [Optional]

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model Fluorescence

Fluorescence information about a region of interest (ROI). Storage hierarchy of fluorescence should be the same as for segmentation (ie, same names for ROIs and for image planes).

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• children (Optional[Dict[str, RoiResponseSeries]])

• hdf5_path (Optional[str])

• name (str)

field children: Dict[str, RoiResponseSeries] | None [Optional]

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model ImageSegmentation

Stores pixels in an image that represent different regions of interest (ROIs) or masks. All segmentation for a given imaging plane is stored together, with storage for multiple imaging planes (masks) supported. Each ROI is stored in its own subgroup, with the ROI group containing both a 2D mask and a list of pixels that make up this mask. Segments can also be used for masking neuropil. If segmentation is allowed to change with time, a new imaging plane (or module) is required and ROI names should remain consistent between them.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• children (Optional[Dict[str, PlaneSegmentation]])

• hdf5_path (Optional[str])

• name (str)

field children: Dict[str, PlaneSegmentation] | None [Optional]

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model PlaneSegmentation

Results from image segmentation of a specific imaging plane.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• colnames (Optional[str])

• description (Optional[str])

• hdf5_path (Optional[str])

• id (List[int])

• image_mask (Optional[PlaneSegmentationImageMask])

• name (str)

• pixel_mask (Optional[List[Any]])

• pixel_mask_index (Optional[PlaneSegmentationPixelMaskIndex])

• reference_images (Optional[Dict[str, ImageSeries]])

• vector_data (Optional[List[VectorData]])

• voxel_mask (Optional[List[Any]])

• voxel_mask_index (Optional[PlaneSegmentationVoxelMaskIndex])

field colnames: str | None = None

The names of the columns in this table. This should be used to specify an order to the columns.

field description: str | None = None

Description of what is in this dynamic table.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field id: List[int] [Optional]

Array of unique identifiers for the rows of this dynamic table.

field image_mask: PlaneSegmentationImageMask | None = None

ROI masks for each ROI. Each image mask is the size of the original imaging plane (or volume) and members of the ROI are finite non-zero.

field name: str [Required]

field pixel_mask: List[Any] | None [Optional]

Pixel masks for each ROI: a list of indices and weights for the ROI. Pixel masks are concatenated and parsing of this dataset is maintained by the PlaneSegmentation

field pixel_mask_index: PlaneSegmentationPixelMaskIndex | None = None

Index into pixel_mask.

field reference_images: Dict[str, ImageSeries] | None [Optional]

Image stacks that the segmentation masks apply to.

field vector_data: List[VectorData] | None [Optional]

Vector columns, including index columns, of this dynamic table.

field voxel_mask: List[Any] | None [Optional]

Voxel masks for each ROI: a list of indices and weights for the ROI. Voxel masks are concatenated and parsing of this dataset is maintained by the PlaneSegmentation

field voxel_mask_index: PlaneSegmentationVoxelMaskIndex | None = None

Index into voxel_mask.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model ImagingPlane

An imaging plane and its metadata.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• children (Optional[Dict[str, OpticalChannel]])

• hdf5_path (Optional[str])

• name (str)

field children: Dict[str, OpticalChannel] | None [Optional]

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model OpticalChannel

An optical channel used to record from an imaging plane.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• description (str)

• emission_lambda (float)

• hdf5_path (Optional[str])

• name (str)

field description: str [Required]

Description or other notes about the channel.

field emission_lambda: float [Required]

Emission wavelength for channel, in nm.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model MotionCorrection

An image stack where all frames are shifted (registered) to a common coordinate system, to account for movement and drift between frames. Note: each frame at each point in time is assumed to be 2-D (has only x & y dimensions).

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• children (Optional[Dict[str, CorrectedImageStack]])

• hdf5_path (Optional[str])

• name (str)

field children: Dict[str, CorrectedImageStack] | None [Optional]

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model CorrectedImageStack

Reuslts from motion correction of an image stack.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• corrected (ImageSeries)

• hdf5_path (Optional[str])

• name (str)

• xy_translation (TimeSeries)

field corrected: ImageSeries [Required]

Image stack with frames shifted to the common coordinates.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field xy_translation: TimeSeries [Required]

Stores the x,y delta necessary to align each frame to the common coordinates, for example, to align each frame to a reference image.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model Device

Metadata about a data acquisition device, e.g., recording system, electrode, microscope.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• description (Optional[str])

• hdf5_path (Optional[str])

• manufacturer (Optional[str])

• name (str)

field description: str | None = None

Description of the device (e.g., model, firmware version, processing software version, etc.) as free-form text.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field manufacturer: str | None = None

The name of the manufacturer of the device.

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model GrayscaleImage

A grayscale image.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• array (Optional[NDArray[Shape['* x, * y'], Number]])

• description (Optional[str])

• hdf5_path (Optional[str])

• name (str)

• resolution (Optional[float])

field array: NDArray[Shape['* x, * y'], Number] | None = None

field description: str | None = None

Description of the image.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field resolution: float | None = None

Pixel resolution of the image, in pixels per centimeter.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model RGBImage

A color image.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• array (Optional[NDArray[Shape['* x, * y, 3 r_g_b'], Number]])

• description (Optional[str])

• hdf5_path (Optional[str])

• name (str)

• resolution (Optional[float])

field array: NDArray[Shape['* x, * y, 3 r_g_b'], Number] | None = None

field description: str | None = None

Description of the image.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field resolution: float | None = None

Pixel resolution of the image, in pixels per centimeter.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model RGBAImage

A color image with transparency.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• array (Optional[NDArray[Shape['* x, * y, 4 r_g_b_a'], Number]])

• description (Optional[str])

• hdf5_path (Optional[str])

• name (str)

• resolution (Optional[float])

field array: NDArray[Shape['* x, * y, 4 r_g_b_a'], Number] | None = None

field description: str | None = None

Description of the image.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field resolution: float | None = None

Pixel resolution of the image, in pixels per centimeter.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model ImageSeries

General image data that is common between acquisition and stimulus time series. Sometimes the image data is stored in the file in a raw format while other times it will be stored as a series of external image files in the host file system. The data field will either be binary data, if the data is stored in the NWB file, or empty, if the data is stored in an external image stack. [frame][x][y] or [frame][x][y][z].

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• comments (Optional[str])

• control (Optional[List[int]])

• control_description (Optional[List[str]])

• data (ImageSeriesData)

• description (Optional[str])

• dimension (Optional[List[int]])

• external_file (Optional[List[str]])

• format (Optional[str])

• hdf5_path (Optional[str])

• name (str)

• starting_time (Optional[TimeSeriesStartingTime])

• sync (Optional[TimeSeriesSync])

• timestamps (Optional[List[float]])

field comments: str | None = None

Human-readable comments about the TimeSeries. This second descriptive field can be used to store additional information, or descriptive information if the primary description field is populated with a computer-readable string.

field control: List[int] | None [Optional]

Numerical labels that apply to each time point in data for the purpose of querying and slicing data by these values. If present, the length of this array should be the same size as the first dimension of data.

field control_description: List[str] | None [Optional]

Description of each control value. Must be present if control is present. If present, control_description[0] should describe time points where control == 0.

field data: ImageSeriesData [Required]

Binary data representing images across frames. If data are stored in an external file, this should be an empty 3D array.

field description: str | None = None

Description of the time series.

field dimension: List[int] | None [Optional]

Number of pixels on x, y, (and z) axes.

field external_file: List[str] | None [Optional]

Paths to one or more external file(s). The field is only present if format=’external’. This is only relevant if the image series is stored in the file system as one or more image file(s). This field should NOT be used if the image is stored in another NWB file and that file is linked to this file.

field format: str | None = None

Format of image. If this is ‘external’, then the attribute ‘external_file’ contains the path information to the image files. If this is ‘raw’, then the raw (single-channel) binary data is stored in the ‘data’ dataset. If this attribute is not present, then the default format=’raw’ case is assumed.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field starting_time: TimeSeriesStartingTime | None = None

Timestamp of the first sample in seconds. When timestamps are uniformly spaced, the timestamp of the first sample can be specified and all subsequent ones calculated from the sampling rate attribute.

field sync: TimeSeriesSync | None = None

Lab-specific time and sync information as provided directly from hardware devices and that is necessary for aligning all acquired time information to a common timebase. The timestamp array stores time in the common timebase. This group will usually only be populated in TimeSeries that are stored external to the NWB file, in files storing raw data. Once timestamp data is calculated, the contents of ‘sync’ are mostly for archival purposes.

field timestamps: List[float] | None [Optional]

Timestamps for samples stored in data, in seconds, relative to the common experiment master-clock stored in NWBFile.timestamps_reference_time.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model ImageMaskSeries

An alpha mask that is applied to a presented visual stimulus. The ‘data’ array contains an array of mask values that are applied to the displayed image. Mask values are stored as RGBA. Mask can vary with time. The timestamps array indicates the starting time of a mask, and that mask pattern continues until it’s explicitly changed.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• comments (Optional[str])

• control (Optional[List[int]])

• control_description (Optional[List[str]])

• data (ImageSeriesData)

• description (Optional[str])

• dimension (Optional[List[int]])

• external_file (Optional[List[str]])

• format (Optional[str])

• hdf5_path (Optional[str])

• name (str)

• starting_time (Optional[TimeSeriesStartingTime])

• sync (Optional[TimeSeriesSync])

• timestamps (Optional[List[float]])

field comments: str | None = None

Human-readable comments about the TimeSeries. This second descriptive field can be used to store additional information, or descriptive information if the primary description field is populated with a computer-readable string.

field control: List[int] | None [Optional]

Numerical labels that apply to each time point in data for the purpose of querying and slicing data by these values. If present, the length of this array should be the same size as the first dimension of data.

field control_description: List[str] | None [Optional]

Description of each control value. Must be present if control is present. If present, control_description[0] should describe time points where control == 0.

field data: ImageSeriesData [Required]

Binary data representing images across frames. If data are stored in an external file, this should be an empty 3D array.

field description: str | None = None

Description of the time series.

field dimension: List[int] | None [Optional]

Number of pixels on x, y, (and z) axes.

field external_file: List[str] | None [Optional]

Paths to one or more external file(s). The field is only present if format=’external’. This is only relevant if the image series is stored in the file system as one or more image file(s). This field should NOT be used if the image is stored in another NWB file and that file is linked to this file.

field format: str | None = None

Format of image. If this is ‘external’, then the attribute ‘external_file’ contains the path information to the image files. If this is ‘raw’, then the raw (single-channel) binary data is stored in the ‘data’ dataset. If this attribute is not present, then the default format=’raw’ case is assumed.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field starting_time: TimeSeriesStartingTime | None = None

Timestamp of the first sample in seconds. When timestamps are uniformly spaced, the timestamp of the first sample can be specified and all subsequent ones calculated from the sampling rate attribute.

field sync: TimeSeriesSync | None = None

Lab-specific time and sync information as provided directly from hardware devices and that is necessary for aligning all acquired time information to a common timebase. The timestamp array stores time in the common timebase. This group will usually only be populated in TimeSeries that are stored external to the NWB file, in files storing raw data. Once timestamp data is calculated, the contents of ‘sync’ are mostly for archival purposes.

field timestamps: List[float] | None [Optional]

Timestamps for samples stored in data, in seconds, relative to the common experiment master-clock stored in NWBFile.timestamps_reference_time.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model OpticalSeries

Image data that is presented or recorded. A stimulus template movie will be stored only as an image. When the image is presented as stimulus, additional data is required, such as field of view (e.g., how much of the visual field the image covers, or how what is the area of the target being imaged). If the OpticalSeries represents acquired imaging data, orientation is also important.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• comments (Optional[str])

• control (Optional[List[int]])

• control_description (Optional[List[str]])

• data (OpticalSeriesData)

• description (Optional[str])

• dimension (Optional[List[int]])

• distance (Optional[float])

• external_file (Optional[List[str]])

• field_of_view (Optional[OpticalSeriesFieldOfView])

• format (Optional[str])

• hdf5_path (Optional[str])

• name (str)

• orientation (Optional[str])

• starting_time (Optional[TimeSeriesStartingTime])

• sync (Optional[TimeSeriesSync])

• timestamps (Optional[List[float]])

field comments: str | None = None

Human-readable comments about the TimeSeries. This second descriptive field can be used to store additional information, or descriptive information if the primary description field is populated with a computer-readable string.

field control: List[int] | None [Optional]

Numerical labels that apply to each time point in data for the purpose of querying and slicing data by these values. If present, the length of this array should be the same size as the first dimension of data.

field control_description: List[str] | None [Optional]

Description of each control value. Must be present if control is present. If present, control_description[0] should describe time points where control == 0.

field data: OpticalSeriesData [Required]

Images presented to subject, either grayscale or RGB

field description: str | None = None

Description of the time series.

field dimension: List[int] | None [Optional]

Number of pixels on x, y, (and z) axes.

field distance: float | None = None

Distance from camera/monitor to target/eye.

field external_file: List[str] | None [Optional]

Paths to one or more external file(s). The field is only present if format=’external’. This is only relevant if the image series is stored in the file system as one or more image file(s). This field should NOT be used if the image is stored in another NWB file and that file is linked to this file.

field field_of_view: OpticalSeriesFieldOfView | None = None

Width, height and depth of image, or imaged area, in meters.

field format: str | None = None

Format of image. If this is ‘external’, then the attribute ‘external_file’ contains the path information to the image files. If this is ‘raw’, then the raw (single-channel) binary data is stored in the ‘data’ dataset. If this attribute is not present, then the default format=’raw’ case is assumed.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field orientation: str | None = None

Description of image relative to some reference frame (e.g., which way is up). Must also specify frame of reference.

field starting_time: TimeSeriesStartingTime | None = None

Timestamp of the first sample in seconds. When timestamps are uniformly spaced, the timestamp of the first sample can be specified and all subsequent ones calculated from the sampling rate attribute.

field sync: TimeSeriesSync | None = None

Lab-specific time and sync information as provided directly from hardware devices and that is necessary for aligning all acquired time information to a common timebase. The timestamp array stores time in the common timebase. This group will usually only be populated in TimeSeries that are stored external to the NWB file, in files storing raw data. Once timestamp data is calculated, the contents of ‘sync’ are mostly for archival purposes.

field timestamps: List[float] | None [Optional]

Timestamps for samples stored in data, in seconds, relative to the common experiment master-clock stored in NWBFile.timestamps_reference_time.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model IndexSeries

Stores indices to image frames stored in an ImageSeries. The purpose of the IndexSeries is to allow a static image stack to be stored in an Images object, and the images in the stack to be referenced out-of-order. This can be for the display of individual images, or of movie segments (as a movie is simply a series of images). The data field stores the index of the frame in the referenced Images object, and the timestamps array indicates when that image was displayed.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• comments (Optional[str])

• control (Optional[List[int]])

• control_description (Optional[List[str]])

• data (List[int])

• description (Optional[str])

• hdf5_path (Optional[str])

• name (str)

• starting_time (Optional[TimeSeriesStartingTime])

• sync (Optional[TimeSeriesSync])

• timestamps (Optional[List[float]])

field comments: str | None = None

Human-readable comments about the TimeSeries. This second descriptive field can be used to store additional information, or descriptive information if the primary description field is populated with a computer-readable string.

field control: List[int] | None [Optional]

Numerical labels that apply to each time point in data for the purpose of querying and slicing data by these values. If present, the length of this array should be the same size as the first dimension of data.

field control_description: List[str] | None [Optional]

Description of each control value. Must be present if control is present. If present, control_description[0] should describe time points where control == 0.

field data: List[int] [Optional]

Index of the image (using zero-indexing) in the linked Images object.

field description: str | None = None

Description of the time series.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field starting_time: TimeSeriesStartingTime | None = None

Timestamp of the first sample in seconds. When timestamps are uniformly spaced, the timestamp of the first sample can be specified and all subsequent ones calculated from the sampling rate attribute.

field sync: TimeSeriesSync | None = None

Lab-specific time and sync information as provided directly from hardware devices and that is necessary for aligning all acquired time information to a common timebase. The timestamp array stores time in the common timebase. This group will usually only be populated in TimeSeries that are stored external to the NWB file, in files storing raw data. Once timestamp data is calculated, the contents of ‘sync’ are mostly for archival purposes.

field timestamps: List[float] | None [Optional]

Timestamps for samples stored in data, in seconds, relative to the common experiment master-clock stored in NWBFile.timestamps_reference_time.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model OptogeneticSeries

An optogenetic stimulus.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• comments (Optional[str])

• control (Optional[List[int]])

• control_description (Optional[List[str]])

• data (List[float])

• description (Optional[str])

• hdf5_path (Optional[str])

• name (str)

• starting_time (Optional[TimeSeriesStartingTime])

• sync (Optional[TimeSeriesSync])

• timestamps (Optional[List[float]])

field comments: str | None = None

Human-readable comments about the TimeSeries. This second descriptive field can be used to store additional information, or descriptive information if the primary description field is populated with a computer-readable string.

field control: List[int] | None [Optional]

Numerical labels that apply to each time point in data for the purpose of querying and slicing data by these values. If present, the length of this array should be the same size as the first dimension of data.

field control_description: List[str] | None [Optional]

Description of each control value. Must be present if control is present. If present, control_description[0] should describe time points where control == 0.

field data: List[float] [Optional]

Applied power for optogenetic stimulus, in watts.

field description: str | None = None

Description of the time series.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field starting_time: TimeSeriesStartingTime | None = None

Timestamp of the first sample in seconds. When timestamps are uniformly spaced, the timestamp of the first sample can be specified and all subsequent ones calculated from the sampling rate attribute.

field sync: TimeSeriesSync | None = None

Lab-specific time and sync information as provided directly from hardware devices and that is necessary for aligning all acquired time information to a common timebase. The timestamp array stores time in the common timebase. This group will usually only be populated in TimeSeries that are stored external to the NWB file, in files storing raw data. Once timestamp data is calculated, the contents of ‘sync’ are mostly for archival purposes.

field timestamps: List[float] | None [Optional]

Timestamps for samples stored in data, in seconds, relative to the common experiment master-clock stored in NWBFile.timestamps_reference_time.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model OptogeneticStimulusSite

A site of optogenetic stimulation.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• description (str)

• excitation_lambda (float)

• hdf5_path (Optional[str])

• location (str)

• name (str)

field description: str [Required]

Description of stimulation site.

field excitation_lambda: float [Required]

Excitation wavelength, in nm.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field location: str [Required]

Location of the stimulation site. Specify the area, layer, comments on estimation of area/layer, stereotaxic coordinates if in vivo, etc. Use standard atlas names for anatomical regions when possible.

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model PatchClampSeries

An abstract base class for patch-clamp data - stimulus or response, current or voltage.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• comments (Optional[str])

• control (Optional[List[int]])

• control_description (Optional[List[str]])

• data (List[float])

• description (Optional[str])

• gain (Optional[float])

• hdf5_path (Optional[str])

• name (str)

• starting_time (Optional[TimeSeriesStartingTime])

• stimulus_description (Optional[str])

• sweep_number (Optional[int])

• sync (Optional[TimeSeriesSync])

• timestamps (Optional[List[float]])

field comments: str | None = None

Human-readable comments about the TimeSeries. This second descriptive field can be used to store additional information, or descriptive information if the primary description field is populated with a computer-readable string.

field control: List[int] | None [Optional]

Numerical labels that apply to each time point in data for the purpose of querying and slicing data by these values. If present, the length of this array should be the same size as the first dimension of data.

field control_description: List[str] | None [Optional]

Description of each control value. Must be present if control is present. If present, control_description[0] should describe time points where control == 0.

field data: List[float] [Optional]

Recorded voltage or current.

field description: str | None = None

Description of the time series.

field gain: float | None = None

Gain of the recording, in units Volt/Amp (v-clamp) or Volt/Volt (c-clamp).

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field starting_time: TimeSeriesStartingTime | None = None

Timestamp of the first sample in seconds. When timestamps are uniformly spaced, the timestamp of the first sample can be specified and all subsequent ones calculated from the sampling rate attribute.

field stimulus_description: str | None = None

Protocol/stimulus name for this patch-clamp dataset.

field sweep_number: int | None = None

Sweep number, allows to group different PatchClampSeries together.

field sync: TimeSeriesSync | None = None

Lab-specific time and sync information as provided directly from hardware devices and that is necessary for aligning all acquired time information to a common timebase. The timestamp array stores time in the common timebase. This group will usually only be populated in TimeSeries that are stored external to the NWB file, in files storing raw data. Once timestamp data is calculated, the contents of ‘sync’ are mostly for archival purposes.

field timestamps: List[float] | None [Optional]

Timestamps for samples stored in data, in seconds, relative to the common experiment master-clock stored in NWBFile.timestamps_reference_time.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model CurrentClampSeries

Voltage data from an intracellular current-clamp recording. A corresponding CurrentClampStimulusSeries (stored separately as a stimulus) is used to store the current injected.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• bias_current (Optional[float])

• bridge_balance (Optional[float])

• capacitance_compensation (Optional[float])

• comments (Optional[str])

• control (Optional[List[int]])

• control_description (Optional[List[str]])

• data (CurrentClampSeriesData)

• description (Optional[str])

• gain (Optional[float])

• hdf5_path (Optional[str])

• name (str)

• starting_time (Optional[TimeSeriesStartingTime])

• stimulus_description (Optional[str])

• sweep_number (Optional[int])

• sync (Optional[TimeSeriesSync])

• timestamps (Optional[List[float]])

field bias_current: float | None = None

Bias current, in amps.

field bridge_balance: float | None = None

Bridge balance, in ohms.

field capacitance_compensation: float | None = None

Capacitance compensation, in farads.

field comments: str | None = None

Human-readable comments about the TimeSeries. This second descriptive field can be used to store additional information, or descriptive information if the primary description field is populated with a computer-readable string.

field control: List[int] | None [Optional]

Numerical labels that apply to each time point in data for the purpose of querying and slicing data by these values. If present, the length of this array should be the same size as the first dimension of data.

field control_description: List[str] | None [Optional]

Description of each control value. Must be present if control is present. If present, control_description[0] should describe time points where control == 0.

field data: CurrentClampSeriesData [Required]

Recorded voltage.

field description: str | None = None

Description of the time series.

field gain: float | None = None

Gain of the recording, in units Volt/Amp (v-clamp) or Volt/Volt (c-clamp).

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field starting_time: TimeSeriesStartingTime | None = None

Timestamp of the first sample in seconds. When timestamps are uniformly spaced, the timestamp of the first sample can be specified and all subsequent ones calculated from the sampling rate attribute.

field stimulus_description: str | None = None

Protocol/stimulus name for this patch-clamp dataset.

field sweep_number: int | None = None

Sweep number, allows to group different PatchClampSeries together.

field sync: TimeSeriesSync | None = None

Lab-specific time and sync information as provided directly from hardware devices and that is necessary for aligning all acquired time information to a common timebase. The timestamp array stores time in the common timebase. This group will usually only be populated in TimeSeries that are stored external to the NWB file, in files storing raw data. Once timestamp data is calculated, the contents of ‘sync’ are mostly for archival purposes.

field timestamps: List[float] | None [Optional]

Timestamps for samples stored in data, in seconds, relative to the common experiment master-clock stored in NWBFile.timestamps_reference_time.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model IZeroClampSeries

Voltage data from an intracellular recording when all current and amplifier settings are off (i.e., CurrentClampSeries fields will be zero). There is no CurrentClampStimulusSeries associated with an IZero series because the amplifier is disconnected and no stimulus can reach the cell.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• bias_current (float)

• bridge_balance (float)

• capacitance_compensation (float)

• comments (Optional[str])

• control (Optional[List[int]])

• control_description (Optional[List[str]])

• data (CurrentClampSeriesData)

• description (Optional[str])

• gain (Optional[float])

• hdf5_path (Optional[str])

• name (str)

• starting_time (Optional[TimeSeriesStartingTime])

• stimulus_description (Optional[str])

• sweep_number (Optional[int])

• sync (Optional[TimeSeriesSync])

• timestamps (Optional[List[float]])

field bias_current: float [Required]

Bias current, in amps, fixed to 0.0.

field bridge_balance: float [Required]

Bridge balance, in ohms, fixed to 0.0.

field capacitance_compensation: float [Required]

Capacitance compensation, in farads, fixed to 0.0.

field comments: str | None = None

Human-readable comments about the TimeSeries. This second descriptive field can be used to store additional information, or descriptive information if the primary description field is populated with a computer-readable string.

field control: List[int] | None [Optional]

Numerical labels that apply to each time point in data for the purpose of querying and slicing data by these values. If present, the length of this array should be the same size as the first dimension of data.

field control_description: List[str] | None [Optional]

Description of each control value. Must be present if control is present. If present, control_description[0] should describe time points where control == 0.

field data: CurrentClampSeriesData [Required]

Recorded voltage.

field description: str | None = None

Description of the time series.

field gain: float | None = None

Gain of the recording, in units Volt/Amp (v-clamp) or Volt/Volt (c-clamp).

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field starting_time: TimeSeriesStartingTime | None = None

Timestamp of the first sample in seconds. When timestamps are uniformly spaced, the timestamp of the first sample can be specified and all subsequent ones calculated from the sampling rate attribute.

field stimulus_description: str | None = None

An IZeroClampSeries has no stimulus, so this attribute is automatically set to “N/A”

field sweep_number: int | None = None

Sweep number, allows to group different PatchClampSeries together.

field sync: TimeSeriesSync | None = None

Lab-specific time and sync information as provided directly from hardware devices and that is necessary for aligning all acquired time information to a common timebase. The timestamp array stores time in the common timebase. This group will usually only be populated in TimeSeries that are stored external to the NWB file, in files storing raw data. Once timestamp data is calculated, the contents of ‘sync’ are mostly for archival purposes.

field timestamps: List[float] | None [Optional]

Timestamps for samples stored in data, in seconds, relative to the common experiment master-clock stored in NWBFile.timestamps_reference_time.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model CurrentClampStimulusSeries

Stimulus current applied during current clamp recording.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• comments (Optional[str])

• control (Optional[List[int]])

• control_description (Optional[List[str]])

• data (CurrentClampStimulusSeriesData)

• description (Optional[str])

• gain (Optional[float])

• hdf5_path (Optional[str])

• name (str)

• starting_time (Optional[TimeSeriesStartingTime])

• stimulus_description (Optional[str])

• sweep_number (Optional[int])

• sync (Optional[TimeSeriesSync])

• timestamps (Optional[List[float]])

field comments: str | None = None

Human-readable comments about the TimeSeries. This second descriptive field can be used to store additional information, or descriptive information if the primary description field is populated with a computer-readable string.

field control: List[int] | None [Optional]

Numerical labels that apply to each time point in data for the purpose of querying and slicing data by these values. If present, the length of this array should be the same size as the first dimension of data.

field control_description: List[str] | None [Optional]

Description of each control value. Must be present if control is present. If present, control_description[0] should describe time points where control == 0.

field data: CurrentClampStimulusSeriesData [Required]

Stimulus current applied.

field description: str | None = None

Description of the time series.

field gain: float | None = None

Gain of the recording, in units Volt/Amp (v-clamp) or Volt/Volt (c-clamp).

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field starting_time: TimeSeriesStartingTime | None = None

Timestamp of the first sample in seconds. When timestamps are uniformly spaced, the timestamp of the first sample can be specified and all subsequent ones calculated from the sampling rate attribute.

field stimulus_description: str | None = None

Protocol/stimulus name for this patch-clamp dataset.

field sweep_number: int | None = None

Sweep number, allows to group different PatchClampSeries together.

field sync: TimeSeriesSync | None = None

Lab-specific time and sync information as provided directly from hardware devices and that is necessary for aligning all acquired time information to a common timebase. The timestamp array stores time in the common timebase. This group will usually only be populated in TimeSeries that are stored external to the NWB file, in files storing raw data. Once timestamp data is calculated, the contents of ‘sync’ are mostly for archival purposes.

field timestamps: List[float] | None [Optional]

Timestamps for samples stored in data, in seconds, relative to the common experiment master-clock stored in NWBFile.timestamps_reference_time.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model VoltageClampSeries

Current data from an intracellular voltage-clamp recording. A corresponding VoltageClampStimulusSeries (stored separately as a stimulus) is used to store the voltage injected.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• capacitance_fast (Optional[VoltageClampSeriesCapacitanceFast])

• capacitance_slow (Optional[VoltageClampSeriesCapacitanceSlow])

• comments (Optional[str])

• control (Optional[List[int]])

• control_description (Optional[List[str]])

• data (VoltageClampSeriesData)

• description (Optional[str])

• gain (Optional[float])

• hdf5_path (Optional[str])

• name (str)

• resistance_comp_bandwidth (Optional[VoltageClampSeriesResistanceCompBandwidth])

• resistance_comp_correction (Optional[VoltageClampSeriesResistanceCompCorrection])

• resistance_comp_prediction (Optional[VoltageClampSeriesResistanceCompPrediction])

• starting_time (Optional[TimeSeriesStartingTime])

• stimulus_description (Optional[str])

• sweep_number (Optional[int])

• sync (Optional[TimeSeriesSync])

• timestamps (Optional[List[float]])

• whole_cell_capacitance_comp (Optional[VoltageClampSeriesWholeCellCapacitanceComp])

• whole_cell_series_resistance_comp (Optional[VoltageClampSeriesWholeCellSeriesResistanceComp])

field capacitance_fast: VoltageClampSeriesCapacitanceFast | None = None

Fast capacitance, in farads.

field capacitance_slow: VoltageClampSeriesCapacitanceSlow | None = None

Slow capacitance, in farads.

field comments: str | None = None

Human-readable comments about the TimeSeries. This second descriptive field can be used to store additional information, or descriptive information if the primary description field is populated with a computer-readable string.

field control: List[int] | None [Optional]

Numerical labels that apply to each time point in data for the purpose of querying and slicing data by these values. If present, the length of this array should be the same size as the first dimension of data.

field control_description: List[str] | None [Optional]

Description of each control value. Must be present if control is present. If present, control_description[0] should describe time points where control == 0.

field data: VoltageClampSeriesData [Required]

Recorded current.

field description: str | None = None

Description of the time series.

field gain: float | None = None

Gain of the recording, in units Volt/Amp (v-clamp) or Volt/Volt (c-clamp).

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field resistance_comp_bandwidth: VoltageClampSeriesResistanceCompBandwidth | None = None

Resistance compensation bandwidth, in hertz.

field resistance_comp_correction: VoltageClampSeriesResistanceCompCorrection | None = None

Resistance compensation correction, in percent.

field resistance_comp_prediction: VoltageClampSeriesResistanceCompPrediction | None = None

Resistance compensation prediction, in percent.

field starting_time: TimeSeriesStartingTime | None = None

Timestamp of the first sample in seconds. When timestamps are uniformly spaced, the timestamp of the first sample can be specified and all subsequent ones calculated from the sampling rate attribute.

field stimulus_description: str | None = None

Protocol/stimulus name for this patch-clamp dataset.

field sweep_number: int | None = None

Sweep number, allows to group different PatchClampSeries together.

field sync: TimeSeriesSync | None = None

Lab-specific time and sync information as provided directly from hardware devices and that is necessary for aligning all acquired time information to a common timebase. The timestamp array stores time in the common timebase. This group will usually only be populated in TimeSeries that are stored external to the NWB file, in files storing raw data. Once timestamp data is calculated, the contents of ‘sync’ are mostly for archival purposes.

field timestamps: List[float] | None [Optional]

Timestamps for samples stored in data, in seconds, relative to the common experiment master-clock stored in NWBFile.timestamps_reference_time.

field whole_cell_capacitance_comp: VoltageClampSeriesWholeCellCapacitanceComp | None = None

Whole cell capacitance compensation, in farads.

field whole_cell_series_resistance_comp: VoltageClampSeriesWholeCellSeriesResistanceComp | None = None

Whole cell series resistance compensation, in ohms.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model VoltageClampStimulusSeries

Stimulus voltage applied during a voltage clamp recording.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• comments (Optional[str])

• control (Optional[List[int]])

• control_description (Optional[List[str]])

• data (VoltageClampStimulusSeriesData)

• description (Optional[str])

• gain (Optional[float])

• hdf5_path (Optional[str])

• name (str)

• starting_time (Optional[TimeSeriesStartingTime])

• stimulus_description (Optional[str])

• sweep_number (Optional[int])

• sync (Optional[TimeSeriesSync])

• timestamps (Optional[List[float]])

field comments: str | None = None

Human-readable comments about the TimeSeries. This second descriptive field can be used to store additional information, or descriptive information if the primary description field is populated with a computer-readable string.

field control: List[int] | None [Optional]

Numerical labels that apply to each time point in data for the purpose of querying and slicing data by these values. If present, the length of this array should be the same size as the first dimension of data.

field control_description: List[str] | None [Optional]

Description of each control value. Must be present if control is present. If present, control_description[0] should describe time points where control == 0.

field data: VoltageClampStimulusSeriesData [Required]

Stimulus voltage applied.

field description: str | None = None

Description of the time series.

field gain: float | None = None

Gain of the recording, in units Volt/Amp (v-clamp) or Volt/Volt (c-clamp).

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field starting_time: TimeSeriesStartingTime | None = None

Timestamp of the first sample in seconds. When timestamps are uniformly spaced, the timestamp of the first sample can be specified and all subsequent ones calculated from the sampling rate attribute.

field stimulus_description: str | None = None

Protocol/stimulus name for this patch-clamp dataset.

field sweep_number: int | None = None

Sweep number, allows to group different PatchClampSeries together.

field sync: TimeSeriesSync | None = None

Lab-specific time and sync information as provided directly from hardware devices and that is necessary for aligning all acquired time information to a common timebase. The timestamp array stores time in the common timebase. This group will usually only be populated in TimeSeries that are stored external to the NWB file, in files storing raw data. Once timestamp data is calculated, the contents of ‘sync’ are mostly for archival purposes.

field timestamps: List[float] | None [Optional]

Timestamps for samples stored in data, in seconds, relative to the common experiment master-clock stored in NWBFile.timestamps_reference_time.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model IntracellularElectrode

An intracellular electrode and its metadata.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• cell_id (Optional[str])

• description (str)

• filtering (Optional[str])

• hdf5_path (Optional[str])

• initial_access_resistance (Optional[str])

• location (Optional[str])

• name (str)

• resistance (Optional[str])

• seal (Optional[str])

• slice (Optional[str])

field cell_id: str | None = None

unique ID of the cell

field description: str [Required]

Description of electrode (e.g., whole-cell, sharp, etc.).

field filtering: str | None = None

Electrode specific filtering.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field initial_access_resistance: str | None = None

Initial access resistance.

field location: str | None = None

Location of the electrode. Specify the area, layer, comments on estimation of area/layer, stereotaxic coordinates if in vivo, etc. Use standard atlas names for anatomical regions when possible.

field name: str [Required]

field resistance: str | None = None

Electrode resistance, in ohms.

field seal: str | None = None

Information about seal used for recording.

field slice: str | None = None

Information about slice used for recording.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model SweepTable

[DEPRECATED] Table used to group different PatchClampSeries. SweepTable is being replaced by IntracellularRecordingsTable and SimultaneousRecordingsTable tables. Additional SequentialRecordingsTable, RepetitionsTable, and ExperimentalConditions tables provide enhanced support for experiment metadata.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• colnames (Optional[str])

• description (Optional[str])

• hdf5_path (Optional[str])

• id (List[int])

• name (str)

• series (Optional[List[PatchClampSeries]])

• series_index (SweepTableSeriesIndex)

• sweep_number (Optional[List[int]])

• vector_data (Optional[List[VectorData]])

field colnames: str | None = None

The names of the columns in this table. This should be used to specify an order to the columns.

field description: str | None = None

Description of what is in this dynamic table.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field id: List[int] [Optional]

Array of unique identifiers for the rows of this dynamic table.

field name: str [Required]

field series: List[PatchClampSeries] | None [Optional]

The PatchClampSeries with the sweep number in that row.

field series_index: SweepTableSeriesIndex [Required]

Index for series.

field sweep_number: List[int] | None [Optional]

Sweep number of the PatchClampSeries in that row.

field vector_data: List[VectorData] | None [Optional]

Vector columns, including index columns, of this dynamic table.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model IntracellularElectrodesTable

Table for storing intracellular electrode related metadata.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• colnames (Optional[str])

• description (Optional[str])

• electrode (Optional[List[IntracellularElectrode]])

• hdf5_path (Optional[str])

• id (List[int])

• name (str)

• vector_data (Optional[List[VectorData]])

field colnames: str | None = None

The names of the columns in this table. This should be used to specify an order to the columns.

field description: str | None = None

Description of what is in this dynamic table.

field electrode: List[IntracellularElectrode] | None [Optional]

Column for storing the reference to the intracellular electrode.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field id: List[int] [Optional]

Array of unique identifiers for the rows of this dynamic table.

field name: str [Required]

field vector_data: List[VectorData] | None [Optional]

Vector columns, including index columns, of this dynamic table.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model IntracellularStimuliTable

Table for storing intracellular stimulus related metadata.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• colnames (Optional[str])

• description (Optional[str])

• hdf5_path (Optional[str])

• id (List[int])

• name (str)

• stimulus (IntracellularStimuliTableStimulus)

• vector_data (Optional[List[VectorData]])

field colnames: str | None = None

The names of the columns in this table. This should be used to specify an order to the columns.

field description: str | None = None

Description of what is in this dynamic table.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field id: List[int] [Optional]

Array of unique identifiers for the rows of this dynamic table.

field name: str [Required]

field stimulus: IntracellularStimuliTableStimulus [Required]

Column storing the reference to the recorded stimulus for the recording (rows).

field vector_data: List[VectorData] | None [Optional]

Vector columns, including index columns, of this dynamic table.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model IntracellularResponsesTable

Table for storing intracellular response related metadata.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• colnames (Optional[str])

• description (Optional[str])

• hdf5_path (Optional[str])

• id (List[int])

• name (str)

• response (IntracellularResponsesTableResponse)

• vector_data (Optional[List[VectorData]])

field colnames: str | None = None

The names of the columns in this table. This should be used to specify an order to the columns.

field description: str | None = None

Description of what is in this dynamic table.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field id: List[int] [Optional]

Array of unique identifiers for the rows of this dynamic table.

field name: str [Required]

field response: IntracellularResponsesTableResponse [Required]

Column storing the reference to the recorded response for the recording (rows)

field vector_data: List[VectorData] | None [Optional]

Vector columns, including index columns, of this dynamic table.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model IntracellularRecordingsTable

A table to group together a stimulus and response from a single electrode and a single simultaneous recording. Each row in the table represents a single recording consisting typically of a stimulus and a corresponding response. In some cases, however, only a stimulus or a response is recorded as part of an experiment. In this case, both the stimulus and response will point to the same TimeSeries while the idx_start and count of the invalid column will be set to -1, thus, indicating that no values have been recorded for the stimulus or response, respectively. Note, a recording MUST contain at least a stimulus or a response. Typically the stimulus and response are PatchClampSeries. However, the use of AD/DA channels that are not associated to an electrode is also common in intracellular electrophysiology, in which case other TimeSeries may be used.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• children (Optional[Dict[str, DynamicTable]])

• colnames (Optional[str])

• description (Optional[str])

• electrodes (IntracellularElectrodesTable)

• hdf5_path (Optional[str])

• id (List[int])

• name (Literal['intracellular_recordings'])

• responses (IntracellularResponsesTable)

• stimuli (IntracellularStimuliTable)

• vector_data (Optional[List[VectorData]])

field children: Dict[str, DynamicTable] | None [Optional]

field colnames: str | None = None

The names of the columns in this table. This should be used to specify an order to the columns.

field description: str | None = None

Description of the contents of this table. Inherited from AlignedDynamicTable and overwritten here to fix the value of the attribute.

field electrodes: IntracellularElectrodesTable [Required]

Table for storing intracellular electrode related metadata.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field id: List[int] [Optional]

Array of unique identifiers for the rows of this dynamic table.

field name: Literal['intracellular_recordings'] = 'intracellular_recordings'

field responses: IntracellularResponsesTable [Required]

Table for storing intracellular response related metadata.

field stimuli: IntracellularStimuliTable [Required]

Table for storing intracellular stimulus related metadata.

field vector_data: List[VectorData] | None [Optional]

Vector columns, including index columns, of this dynamic table.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model SimultaneousRecordingsTable

A table for grouping different intracellular recordings from the IntracellularRecordingsTable table together that were recorded simultaneously from different electrodes.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• colnames (Optional[str])

• description (Optional[str])

• hdf5_path (Optional[str])

• id (List[int])

• name (Literal['simultaneous_recordings'])

• recordings (SimultaneousRecordingsTableRecordings)

• recordings_index (SimultaneousRecordingsTableRecordingsIndex)

• vector_data (Optional[List[VectorData]])

field colnames: str | None = None

The names of the columns in this table. This should be used to specify an order to the columns.

field description: str | None = None

Description of what is in this dynamic table.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field id: List[int] [Optional]

Array of unique identifiers for the rows of this dynamic table.

field name: Literal['simultaneous_recordings'] = 'simultaneous_recordings'

field recordings: SimultaneousRecordingsTableRecordings [Required]

A reference to one or more rows in the IntracellularRecordingsTable table.

field recordings_index: SimultaneousRecordingsTableRecordingsIndex [Required]

Index dataset for the recordings column.

field vector_data: List[VectorData] | None [Optional]

Vector columns, including index columns, of this dynamic table.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model SequentialRecordingsTable

A table for grouping different sequential recordings from the SimultaneousRecordingsTable table together. This is typically used to group together sequential recordings where a sequence of stimuli of the same type with varying parameters have been presented in a sequence.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• colnames (Optional[str])

• description (Optional[str])

• hdf5_path (Optional[str])

• id (List[int])

• name (Literal['sequential_recordings'])

• simultaneous_recordings (SequentialRecordingsTableSimultaneousRecordings)

• simultaneous_recordings_index (SequentialRecordingsTableSimultaneousRecordingsIndex)

• stimulus_type (Optional[List[str]])

• vector_data (Optional[List[VectorData]])

field colnames: str | None = None

The names of the columns in this table. This should be used to specify an order to the columns.

field description: str | None = None

Description of what is in this dynamic table.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field id: List[int] [Optional]

Array of unique identifiers for the rows of this dynamic table.

field name: Literal['sequential_recordings'] = 'sequential_recordings'

field simultaneous_recordings: SequentialRecordingsTableSimultaneousRecordings [Required]

A reference to one or more rows in the SimultaneousRecordingsTable table.

field simultaneous_recordings_index: SequentialRecordingsTableSimultaneousRecordingsIndex [Required]

Index dataset for the simultaneous_recordings column.

field stimulus_type: List[str] | None [Optional]

The type of stimulus used for the sequential recording.

field vector_data: List[VectorData] | None [Optional]

Vector columns, including index columns, of this dynamic table.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model RepetitionsTable

A table for grouping different sequential intracellular recordings together. With each SequentialRecording typically representing a particular type of stimulus, the RepetitionsTable table is typically used to group sets of stimuli applied in sequence.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• colnames (Optional[str])

• description (Optional[str])

• hdf5_path (Optional[str])

• id (List[int])

• name (Literal['repetitions'])

• sequential_recordings (RepetitionsTableSequentialRecordings)

• sequential_recordings_index (RepetitionsTableSequentialRecordingsIndex)

• vector_data (Optional[List[VectorData]])

field colnames: str | None = None

The names of the columns in this table. This should be used to specify an order to the columns.

field description: str | None = None

Description of what is in this dynamic table.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field id: List[int] [Optional]

Array of unique identifiers for the rows of this dynamic table.

field name: Literal['repetitions'] = 'repetitions'

field sequential_recordings: RepetitionsTableSequentialRecordings [Required]

A reference to one or more rows in the SequentialRecordingsTable table.

field sequential_recordings_index: RepetitionsTableSequentialRecordingsIndex [Required]

Index dataset for the sequential_recordings column.

field vector_data: List[VectorData] | None [Optional]

Vector columns, including index columns, of this dynamic table.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model ExperimentalConditionsTable

A table for grouping different intracellular recording repetitions together that belong to the same experimental condition.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• colnames (Optional[str])

• description (Optional[str])

• hdf5_path (Optional[str])

• id (List[int])

• name (Literal['experimental_conditions'])

• repetitions (ExperimentalConditionsTableRepetitions)

• repetitions_index (ExperimentalConditionsTableRepetitionsIndex)

• vector_data (Optional[List[VectorData]])

field colnames: str | None = None

The names of the columns in this table. This should be used to specify an order to the columns.

field description: str | None = None

Description of what is in this dynamic table.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field id: List[int] [Optional]

Array of unique identifiers for the rows of this dynamic table.

field name: Literal['experimental_conditions'] = 'experimental_conditions'

field repetitions: ExperimentalConditionsTableRepetitions [Required]

A reference to one or more rows in the RepetitionsTable table.

field repetitions_index: ExperimentalConditionsTableRepetitionsIndex [Required]

Index dataset for the repetitions column.

field vector_data: List[VectorData] | None [Optional]

Vector columns, including index columns, of this dynamic table.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model ElectricalSeries

A time series of acquired voltage data from extracellular recordings. The data field is an int or float array storing data in volts. The first dimension should always represent time. The second dimension, if present, should represent channels.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• channel_conversion (Optional[List[float]])

• comments (Optional[str])

• control (Optional[List[int]])

• control_description (Optional[List[str]])

• data (ElectricalSeriesData)

• description (Optional[str])

• electrodes (ElectricalSeriesElectrodes)

• filtering (Optional[str])

• hdf5_path (Optional[str])

• name (str)

• starting_time (Optional[TimeSeriesStartingTime])

• sync (Optional[TimeSeriesSync])

• timestamps (Optional[List[float]])

field channel_conversion: List[float] | None [Optional]

Channel-specific conversion factor. Multiply the data in the ‘data’ dataset by these values along the channel axis (as indicated by axis attribute) AND by the global conversion factor in the ‘conversion’ attribute of ‘data’ to get the data values in Volts, i.e, data in Volts = data * data.conversion * channel_conversion. This approach allows for both global and per-channel data conversion factors needed to support the storage of electrical recordings as native values generated by data acquisition systems. If this dataset is not present, then there is no channel-specific conversion factor, i.e. it is 1 for all channels.

field comments: str | None = None

Human-readable comments about the TimeSeries. This second descriptive field can be used to store additional information, or descriptive information if the primary description field is populated with a computer-readable string.

field control: List[int] | None [Optional]

Numerical labels that apply to each time point in data for the purpose of querying and slicing data by these values. If present, the length of this array should be the same size as the first dimension of data.

field control_description: List[str] | None [Optional]

Description of each control value. Must be present if control is present. If present, control_description[0] should describe time points where control == 0.

field data: ElectricalSeriesData [Required]

Recorded voltage data.

field description: str | None = None

Description of the time series.

field electrodes: ElectricalSeriesElectrodes [Required]

DynamicTableRegion pointer to the electrodes that this time series was generated from.

field filtering: str | None = None

Filtering applied to all channels of the data. For example, if this ElectricalSeries represents high-pass-filtered data (also known as AP Band), then this value could be “High-pass 4-pole Bessel filter at 500 Hz”. If this ElectricalSeries represents low-pass-filtered LFP data and the type of filter is unknown, then this value could be “Low-pass filter at 300 Hz”. If a non-standard filter type is used, provide as much detail about the filter properties as possible.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field starting_time: TimeSeriesStartingTime | None = None

Timestamp of the first sample in seconds. When timestamps are uniformly spaced, the timestamp of the first sample can be specified and all subsequent ones calculated from the sampling rate attribute.

field sync: TimeSeriesSync | None = None

Lab-specific time and sync information as provided directly from hardware devices and that is necessary for aligning all acquired time information to a common timebase. The timestamp array stores time in the common timebase. This group will usually only be populated in TimeSeries that are stored external to the NWB file, in files storing raw data. Once timestamp data is calculated, the contents of ‘sync’ are mostly for archival purposes.

field timestamps: List[float] | None [Optional]

Timestamps for samples stored in data, in seconds, relative to the common experiment master-clock stored in NWBFile.timestamps_reference_time.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model SpikeEventSeries

Stores snapshots/snippets of recorded spike events (i.e., threshold crossings). This may also be raw data, as reported by ephys hardware. If so, the TimeSeries::description field should describe how events were detected. All SpikeEventSeries should reside in a module (under EventWaveform interface) even if the spikes were reported and stored by hardware. All events span the same recording channels and store snapshots of equal duration. TimeSeries::data array structure: [num events] [num channels] [num samples] (or [num events] [num samples] for single electrode).

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• channel_conversion (Optional[List[float]])

• comments (Optional[str])

• control (Optional[List[int]])

• control_description (Optional[List[str]])

• data (SpikeEventSeriesData)

• description (Optional[str])

• electrodes (ElectricalSeriesElectrodes)

• filtering (Optional[str])

• hdf5_path (Optional[str])

• name (str)

• starting_time (Optional[TimeSeriesStartingTime])

• sync (Optional[TimeSeriesSync])

• timestamps (List[float])

field channel_conversion: List[float] | None [Optional]

Channel-specific conversion factor. Multiply the data in the ‘data’ dataset by these values along the channel axis (as indicated by axis attribute) AND by the global conversion factor in the ‘conversion’ attribute of ‘data’ to get the data values in Volts, i.e, data in Volts = data * data.conversion * channel_conversion. This approach allows for both global and per-channel data conversion factors needed to support the storage of electrical recordings as native values generated by data acquisition systems. If this dataset is not present, then there is no channel-specific conversion factor, i.e. it is 1 for all channels.

field comments: str | None = None

Human-readable comments about the TimeSeries. This second descriptive field can be used to store additional information, or descriptive information if the primary description field is populated with a computer-readable string.

field control: List[int] | None [Optional]

Numerical labels that apply to each time point in data for the purpose of querying and slicing data by these values. If present, the length of this array should be the same size as the first dimension of data.

field control_description: List[str] | None [Optional]

Description of each control value. Must be present if control is present. If present, control_description[0] should describe time points where control == 0.

field data: SpikeEventSeriesData [Required]

Spike waveforms.

field description: str | None = None

Description of the time series.

field electrodes: ElectricalSeriesElectrodes [Required]

DynamicTableRegion pointer to the electrodes that this time series was generated from.

field filtering: str | None = None

Filtering applied to all channels of the data. For example, if this ElectricalSeries represents high-pass-filtered data (also known as AP Band), then this value could be “High-pass 4-pole Bessel filter at 500 Hz”. If this ElectricalSeries represents low-pass-filtered LFP data and the type of filter is unknown, then this value could be “Low-pass filter at 300 Hz”. If a non-standard filter type is used, provide as much detail about the filter properties as possible.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field starting_time: TimeSeriesStartingTime | None = None

Timestamp of the first sample in seconds. When timestamps are uniformly spaced, the timestamp of the first sample can be specified and all subsequent ones calculated from the sampling rate attribute.

field sync: TimeSeriesSync | None = None

Lab-specific time and sync information as provided directly from hardware devices and that is necessary for aligning all acquired time information to a common timebase. The timestamp array stores time in the common timebase. This group will usually only be populated in TimeSeries that are stored external to the NWB file, in files storing raw data. Once timestamp data is calculated, the contents of ‘sync’ are mostly for archival purposes.

field timestamps: List[float] [Optional]

Timestamps for samples stored in data, in seconds, relative to the common experiment master-clock stored in NWBFile.timestamps_reference_time. Timestamps are required for the events. Unlike for TimeSeries, timestamps are required for SpikeEventSeries and are thus re-specified here.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model FeatureExtraction

Features, such as PC1 and PC2, that are extracted from signals stored in a SpikeEventSeries or other source.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• description (List[str])

• electrodes (FeatureExtractionElectrodes)

• features (FeatureExtractionFeatures)

• hdf5_path (Optional[str])

• name (str)

• times (List[float])

field description: List[str] [Optional]

Description of features (eg, ‘’PC1’’) for each of the extracted features.

field electrodes: FeatureExtractionElectrodes [Required]

DynamicTableRegion pointer to the electrodes that this time series was generated from.

field features: FeatureExtractionFeatures [Required]

Multi-dimensional array of features extracted from each event.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field times: List[float] [Optional]

Times of events that features correspond to (can be a link).

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model EventDetection

Detected spike events from voltage trace(s).

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• detection_method (str)

• hdf5_path (Optional[str])

• name (str)

• source_idx (List[int])

• times (List[float])

field detection_method: str [Required]

Description of how events were detected, such as voltage threshold, or dV/dT threshold, as well as relevant values.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field source_idx: List[int] [Optional]

Indices (zero-based) into source ElectricalSeries::data array corresponding to time of event. ‘’description’’ should define what is meant by time of event (e.g., .25 ms before action potential peak, zero-crossing time, etc). The index points to each event from the raw data.

field times: List[float] [Optional]

Timestamps of events, in seconds.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model EventWaveform

Represents either the waveforms of detected events, as extracted from a raw data trace in /acquisition, or the event waveforms that were stored during experiment acquisition.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• children (Optional[Dict[str, SpikeEventSeries]])

• hdf5_path (Optional[str])

• name (str)

field children: Dict[str, SpikeEventSeries] | None [Optional]

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model FilteredEphys

Electrophysiology data from one or more channels that has been subjected to filtering. Examples of filtered data include Theta and Gamma (LFP has its own interface). FilteredEphys modules publish an ElectricalSeries for each filtered channel or set of channels. The name of each ElectricalSeries is arbitrary but should be informative. The source of the filtered data, whether this is from analysis of another time series or as acquired by hardware, should be noted in each’s TimeSeries::description field. There is no assumed 1::1 correspondence between filtered ephys signals and electrodes, as a single signal can apply to many nearby electrodes, and one electrode may have different filtered (e.g., theta and/or gamma) signals represented. Filter properties should be noted in the ElectricalSeries ‘filtering’ attribute.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• children (Optional[Dict[str, ElectricalSeries]])

• hdf5_path (Optional[str])

• name (str)

field children: Dict[str, ElectricalSeries] | None [Optional]

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model LFP

LFP data from one or more channels. The electrode map in each published ElectricalSeries will identify which channels are providing LFP data. Filter properties should be noted in the ElectricalSeries ‘filtering’ attribute.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• children (Optional[Dict[str, ElectricalSeries]])

• hdf5_path (Optional[str])

• name (str)

field children: Dict[str, ElectricalSeries] | None [Optional]

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model ElectrodeGroup

A physical grouping of electrodes, e.g. a shank of an array.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• description (Optional[str])

• hdf5_path (Optional[str])

• location (Optional[str])

• name (str)

• position (Optional[Any])

field description: str | None = None

Description of this electrode group.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field location: str | None = None

Location of electrode group. Specify the area, layer, comments on estimation of area/layer, etc. Use standard atlas names for anatomical regions when possible.

field name: str [Required]

field position: Any | None = None

stereotaxic or common framework coordinates

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model ClusterWaveforms

DEPRECATED The mean waveform shape, including standard deviation, of the different clusters. Ideally, the waveform analysis should be performed on data that is only high-pass filtered. This is a separate module because it is expected to require updating. For example, IMEC probes may require different storage requirements to store/display mean waveforms, requiring a new interface or an extension of this one.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• hdf5_path (Optional[str])

• name (str)

• waveform_filtering (str)

• waveform_mean (ClusterWaveformsWaveformMean)

• waveform_sd (ClusterWaveformsWaveformSd)

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field waveform_filtering: str [Required]

Filtering applied to data before generating mean/sd

field waveform_mean: ClusterWaveformsWaveformMean [Required]

The mean waveform for each cluster, using the same indices for each wave as cluster numbers in the associated Clustering module (i.e, cluster 3 is in array slot [3]). Waveforms corresponding to gaps in cluster sequence should be empty (e.g., zero- filled)

field waveform_sd: ClusterWaveformsWaveformSd [Required]

Stdev of waveforms for each cluster, using the same indices as in mean

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model Clustering

DEPRECATED Clustered spike data, whether from automatic clustering tools (e.g., klustakwik) or as a result of manual sorting.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• description (str)

• hdf5_path (Optional[str])

• name (str)

• num (List[int])

• peak_over_rms (List[float])

• times (List[float])

field description: str [Required]

Description of clusters or clustering, (e.g. cluster 0 is noise, clusters curated using Klusters, etc)

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field num: List[int] [Optional]

Cluster number of each event

field peak_over_rms: List[float] [Optional]

Maximum ratio of waveform peak to RMS on any channel in the cluster (provides a basic clustering metric).

field times: List[float] [Optional]

Times of clustered events, in seconds. This may be a link to times field in associated FeatureExtraction module.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model SpatialSeries

Direction, e.g., of gaze or travel, or position. The TimeSeries::data field is a 2D array storing position or direction relative to some reference frame. Array structure: [num measurements] [num dimensions]. Each SpatialSeries has a text dataset reference_frame that indicates the zero-position, or the zero-axes for direction. For example, if representing gaze direction, ‘straight-ahead’ might be a specific pixel on the monitor, or some other point in space. For position data, the 0,0 point might be the top-left corner of an enclosure, as viewed from the tracking camera. The unit of data will indicate how to interpret SpatialSeries values.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• comments (Optional[str])

• control (Optional[List[int]])

• control_description (Optional[List[str]])

• data (SpatialSeriesData)

• description (Optional[str])

• hdf5_path (Optional[str])

• name (str)

• reference_frame (Optional[str])

• starting_time (Optional[TimeSeriesStartingTime])

• sync (Optional[TimeSeriesSync])

• timestamps (Optional[List[float]])

field comments: str | None = None

Human-readable comments about the TimeSeries. This second descriptive field can be used to store additional information, or descriptive information if the primary description field is populated with a computer-readable string.

field control: List[int] | None [Optional]

Numerical labels that apply to each time point in data for the purpose of querying and slicing data by these values. If present, the length of this array should be the same size as the first dimension of data.

field control_description: List[str] | None [Optional]

Description of each control value. Must be present if control is present. If present, control_description[0] should describe time points where control == 0.

field data: SpatialSeriesData [Required]

1-D or 2-D array storing position or direction relative to some reference frame.

field description: str | None = None

Description of the time series.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field reference_frame: str | None = None

Description defining what exactly ‘straight-ahead’ means.

field starting_time: TimeSeriesStartingTime | None = None

Timestamp of the first sample in seconds. When timestamps are uniformly spaced, the timestamp of the first sample can be specified and all subsequent ones calculated from the sampling rate attribute.

field sync: TimeSeriesSync | None = None

Lab-specific time and sync information as provided directly from hardware devices and that is necessary for aligning all acquired time information to a common timebase. The timestamp array stores time in the common timebase. This group will usually only be populated in TimeSeries that are stored external to the NWB file, in files storing raw data. Once timestamp data is calculated, the contents of ‘sync’ are mostly for archival purposes.

field timestamps: List[float] | None [Optional]

Timestamps for samples stored in data, in seconds, relative to the common experiment master-clock stored in NWBFile.timestamps_reference_time.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model BehavioralEpochs

TimeSeries for storing behavioral epochs. The objective of this and the other two Behavioral interfaces (e.g. BehavioralEvents and BehavioralTimeSeries) is to provide generic hooks for software tools/scripts. This allows a tool/script to take the output one specific interface (e.g., UnitTimes) and plot that data relative to another data modality (e.g., behavioral events) without having to define all possible modalities in advance. Declaring one of these interfaces means that one or more TimeSeries of the specified type is published. These TimeSeries should reside in a group having the same name as the interface. For example, if a BehavioralTimeSeries interface is declared, the module will have one or more TimeSeries defined in the module sub-group ‘BehavioralTimeSeries’. BehavioralEpochs should use IntervalSeries. BehavioralEvents is used for irregular events. BehavioralTimeSeries is for continuous data.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• children (Optional[Dict[str, IntervalSeries]])

• hdf5_path (Optional[str])

• name (str)

field children: Dict[str, IntervalSeries] | None [Optional]

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model BehavioralEvents

TimeSeries for storing behavioral events. See description of <a href=”#BehavioralEpochs”>BehavioralEpochs</a> for more details.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• children (Optional[Dict[str, TimeSeries]])

• hdf5_path (Optional[str])

• name (str)

field children: Dict[str, TimeSeries] | None [Optional]

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model BehavioralTimeSeries

TimeSeries for storing Behavoioral time series data. See description of <a href=”#BehavioralEpochs”>BehavioralEpochs</a> for more details.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• children (Optional[Dict[str, TimeSeries]])

• hdf5_path (Optional[str])

• name (str)

field children: Dict[str, TimeSeries] | None [Optional]

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model PupilTracking

Eye-tracking data, representing pupil size.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• children (Optional[Dict[str, TimeSeries]])

• hdf5_path (Optional[str])

• name (str)

field children: Dict[str, TimeSeries] | None [Optional]

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model EyeTracking

Eye-tracking data, representing direction of gaze.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• children (Optional[Dict[str, SpatialSeries]])

• hdf5_path (Optional[str])

• name (str)

field children: Dict[str, SpatialSeries] | None [Optional]

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model CompassDirection

With a CompassDirection interface, a module publishes a SpatialSeries object representing a floating point value for theta. The SpatialSeries::reference_frame field should indicate what direction corresponds to 0 and which is the direction of rotation (this should be clockwise). The si_unit for the SpatialSeries should be radians or degrees.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• children (Optional[Dict[str, SpatialSeries]])

• hdf5_path (Optional[str])

• name (str)

field children: Dict[str, SpatialSeries] | None [Optional]

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model Position

Position data, whether along the x, x/y or x/y/z axis.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• children (Optional[Dict[str, SpatialSeries]])

• hdf5_path (Optional[str])

• name (str)

field children: Dict[str, SpatialSeries] | None [Optional]

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model AbstractFeatureSeries

Abstract features, such as quantitative descriptions of sensory stimuli. The TimeSeries::data field is a 2D array, storing those features (e.g., for visual grating stimulus this might be orientation, spatial frequency and contrast). Null stimuli (eg, uniform gray) can be marked as being an independent feature (eg, 1.0 for gray, 0.0 for actual stimulus) or by storing NaNs for feature values, or through use of the TimeSeries::control fields. A set of features is considered to persist until the next set of features is defined. The final set of features stored should be the null set. This is useful when storing the raw stimulus is impractical.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• comments (Optional[str])

• control (Optional[List[int]])

• control_description (Optional[List[str]])

• data (AbstractFeatureSeriesData)

• description (Optional[str])

• feature_units (Optional[List[str]])

• features (List[str])

• hdf5_path (Optional[str])

• name (str)

• starting_time (Optional[TimeSeriesStartingTime])

• sync (Optional[TimeSeriesSync])

• timestamps (Optional[List[float]])

field comments: str | None = None

Human-readable comments about the TimeSeries. This second descriptive field can be used to store additional information, or descriptive information if the primary description field is populated with a computer-readable string.

field control: List[int] | None [Optional]

Numerical labels that apply to each time point in data for the purpose of querying and slicing data by these values. If present, the length of this array should be the same size as the first dimension of data.

field control_description: List[str] | None [Optional]

Description of each control value. Must be present if control is present. If present, control_description[0] should describe time points where control == 0.

field data: AbstractFeatureSeriesData [Required]

Values of each feature at each time.

field description: str | None = None

Description of the time series.

field feature_units: List[str] | None [Optional]

Units of each feature.

field features: List[str] [Optional]

Description of the features represented in TimeSeries::data.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field starting_time: TimeSeriesStartingTime | None = None

Timestamp of the first sample in seconds. When timestamps are uniformly spaced, the timestamp of the first sample can be specified and all subsequent ones calculated from the sampling rate attribute.

field sync: TimeSeriesSync | None = None

Lab-specific time and sync information as provided directly from hardware devices and that is necessary for aligning all acquired time information to a common timebase. The timestamp array stores time in the common timebase. This group will usually only be populated in TimeSeries that are stored external to the NWB file, in files storing raw data. Once timestamp data is calculated, the contents of ‘sync’ are mostly for archival purposes.

field timestamps: List[float] | None [Optional]

Timestamps for samples stored in data, in seconds, relative to the common experiment master-clock stored in NWBFile.timestamps_reference_time.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model AnnotationSeries

Stores user annotations made during an experiment. The data[] field stores a text array, and timestamps are stored for each annotation (ie, interval=1). This is largely an alias to a standard TimeSeries storing a text array but that is identifiable as storing annotations in a machine-readable way.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• comments (Optional[str])

• control (Optional[List[int]])

• control_description (Optional[List[str]])

• data (List[str])

• description (Optional[str])

• hdf5_path (Optional[str])

• name (str)

• starting_time (Optional[TimeSeriesStartingTime])

• sync (Optional[TimeSeriesSync])

• timestamps (Optional[List[float]])

field comments: str | None = None

Human-readable comments about the TimeSeries. This second descriptive field can be used to store additional information, or descriptive information if the primary description field is populated with a computer-readable string.

field control: List[int] | None [Optional]

Numerical labels that apply to each time point in data for the purpose of querying and slicing data by these values. If present, the length of this array should be the same size as the first dimension of data.

field control_description: List[str] | None [Optional]

Description of each control value. Must be present if control is present. If present, control_description[0] should describe time points where control == 0.

field data: List[str] [Optional]

Annotations made during an experiment.

field description: str | None = None

Description of the time series.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field starting_time: TimeSeriesStartingTime | None = None

Timestamp of the first sample in seconds. When timestamps are uniformly spaced, the timestamp of the first sample can be specified and all subsequent ones calculated from the sampling rate attribute.

field sync: TimeSeriesSync | None = None

Lab-specific time and sync information as provided directly from hardware devices and that is necessary for aligning all acquired time information to a common timebase. The timestamp array stores time in the common timebase. This group will usually only be populated in TimeSeries that are stored external to the NWB file, in files storing raw data. Once timestamp data is calculated, the contents of ‘sync’ are mostly for archival purposes.

field timestamps: List[float] | None [Optional]

Timestamps for samples stored in data, in seconds, relative to the common experiment master-clock stored in NWBFile.timestamps_reference_time.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model IntervalSeries

Stores intervals of data. The timestamps field stores the beginning and end of intervals. The data field stores whether the interval just started (>0 value) or ended (<0 value). Different interval types can be represented in the same series by using multiple key values (eg, 1 for feature A, 2 for feature B, 3 for feature C, etc). The field data stores an 8-bit integer. This is largely an alias of a standard TimeSeries but that is identifiable as representing time intervals in a machine-readable way.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• comments (Optional[str])

• control (Optional[List[int]])

• control_description (Optional[List[str]])

• data (List[int])

• description (Optional[str])

• hdf5_path (Optional[str])

• name (str)

• starting_time (Optional[TimeSeriesStartingTime])

• sync (Optional[TimeSeriesSync])

• timestamps (Optional[List[float]])

field comments: str | None = None

Human-readable comments about the TimeSeries. This second descriptive field can be used to store additional information, or descriptive information if the primary description field is populated with a computer-readable string.

field control: List[int] | None [Optional]

Numerical labels that apply to each time point in data for the purpose of querying and slicing data by these values. If present, the length of this array should be the same size as the first dimension of data.

field control_description: List[str] | None [Optional]

Description of each control value. Must be present if control is present. If present, control_description[0] should describe time points where control == 0.

field data: List[int] [Optional]

Use values >0 if interval started, <0 if interval ended.

field description: str | None = None

Description of the time series.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field starting_time: TimeSeriesStartingTime | None = None

Timestamp of the first sample in seconds. When timestamps are uniformly spaced, the timestamp of the first sample can be specified and all subsequent ones calculated from the sampling rate attribute.

field sync: TimeSeriesSync | None = None

Lab-specific time and sync information as provided directly from hardware devices and that is necessary for aligning all acquired time information to a common timebase. The timestamp array stores time in the common timebase. This group will usually only be populated in TimeSeries that are stored external to the NWB file, in files storing raw data. Once timestamp data is calculated, the contents of ‘sync’ are mostly for archival purposes.

field timestamps: List[float] | None [Optional]

Timestamps for samples stored in data, in seconds, relative to the common experiment master-clock stored in NWBFile.timestamps_reference_time.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model DecompositionSeries

Spectral analysis of a time series, e.g. of an LFP or a speech signal.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• bands (DecompositionSeriesBands)

• comments (Optional[str])

• control (Optional[List[int]])

• control_description (Optional[List[str]])

• data (DecompositionSeriesData)

• description (Optional[str])

• hdf5_path (Optional[str])

• metric (str)

• name (str)

• source_channels (Optional[DecompositionSeriesSourceChannels])

• starting_time (Optional[TimeSeriesStartingTime])

• sync (Optional[TimeSeriesSync])

• timestamps (Optional[List[float]])

field bands: DecompositionSeriesBands [Required]

Table for describing the bands that this series was generated from. There should be one row in this table for each band.

field comments: str | None = None

Human-readable comments about the TimeSeries. This second descriptive field can be used to store additional information, or descriptive information if the primary description field is populated with a computer-readable string.

field control: List[int] | None [Optional]

Numerical labels that apply to each time point in data for the purpose of querying and slicing data by these values. If present, the length of this array should be the same size as the first dimension of data.

field control_description: List[str] | None [Optional]

Description of each control value. Must be present if control is present. If present, control_description[0] should describe time points where control == 0.

field data: DecompositionSeriesData [Required]

Data decomposed into frequency bands.

field description: str | None = None

Description of the time series.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field metric: str [Required]

The metric used, e.g. phase, amplitude, power.

field name: str [Required]

field source_channels: DecompositionSeriesSourceChannels | None = None

DynamicTableRegion pointer to the channels that this decomposition series was generated from.

field starting_time: TimeSeriesStartingTime | None = None

Timestamp of the first sample in seconds. When timestamps are uniformly spaced, the timestamp of the first sample can be specified and all subsequent ones calculated from the sampling rate attribute.

field sync: TimeSeriesSync | None = None

Lab-specific time and sync information as provided directly from hardware devices and that is necessary for aligning all acquired time information to a common timebase. The timestamp array stores time in the common timebase. This group will usually only be populated in TimeSeries that are stored external to the NWB file, in files storing raw data. Once timestamp data is calculated, the contents of ‘sync’ are mostly for archival purposes.

field timestamps: List[float] | None [Optional]

Timestamps for samples stored in data, in seconds, relative to the common experiment master-clock stored in NWBFile.timestamps_reference_time.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model Units

Data about spiking units. Event times of observed units (e.g. cell, synapse, etc.) should be concatenated and stored in spike_times.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• colnames (Optional[str])

• description (Optional[str])

• electrode_group (Optional[List[ElectrodeGroup]])

• electrodes (Optional[UnitsElectrodes])

• electrodes_index (Optional[UnitsElectrodesIndex])

• hdf5_path (Optional[str])

• id (List[int])

• name (str)

• obs_intervals (Optional[UnitsObsIntervals])

• obs_intervals_index (Optional[UnitsObsIntervalsIndex])

• spike_times (Optional[UnitsSpikeTimes])

• spike_times_index (Optional[UnitsSpikeTimesIndex])

• vector_data (Optional[List[VectorData]])

• waveform_mean (Optional[UnitsWaveformMean])

• waveform_sd (Optional[UnitsWaveformSd])

• waveforms (Optional[UnitsWaveforms])

• waveforms_index (Optional[UnitsWaveformsIndex])

• waveforms_index_index (Optional[UnitsWaveformsIndexIndex])

field colnames: str | None = None

The names of the columns in this table. This should be used to specify an order to the columns.

field description: str | None = None

Description of what is in this dynamic table.

field electrode_group: List[ElectrodeGroup] | None [Optional]

Electrode group that each spike unit came from.

field electrodes: UnitsElectrodes | None = None

Electrode that each spike unit came from, specified using a DynamicTableRegion.

field electrodes_index: UnitsElectrodesIndex | None = None

Index into electrodes.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field id: List[int] [Optional]

Array of unique identifiers for the rows of this dynamic table.

field name: str [Required]

field obs_intervals: UnitsObsIntervals | None = None

Observation intervals for each unit.

field obs_intervals_index: UnitsObsIntervalsIndex | None = None

Index into the obs_intervals dataset.

field spike_times: UnitsSpikeTimes | None = None

Spike times for each unit in seconds.

field spike_times_index: UnitsSpikeTimesIndex | None = None

Index into the spike_times dataset.

field vector_data: List[VectorData] | None [Optional]

Vector columns, including index columns, of this dynamic table.

field waveform_mean: UnitsWaveformMean | None = None

Spike waveform mean for each spike unit.

field waveform_sd: UnitsWaveformSd | None = None

Spike waveform standard deviation for each spike unit.

field waveforms: UnitsWaveforms | None = None

Individual waveforms for each spike on each electrode. This is a doubly indexed column. The ‘waveforms_index’ column indexes which waveforms in this column belong to the same spike event for a given unit, where each waveform was recorded from a different electrode. The ‘waveforms_index_index’ column indexes the ‘waveforms_index’ column to indicate which spike events belong to a given unit. For example, if the ‘waveforms_index_index’ column has values [2, 5, 6], then the first 2 elements of the ‘waveforms_index’ column correspond to the 2 spike events of the first unit, the next 3 elements of the ‘waveforms_index’ column correspond to the 3 spike events of the second unit, and the next 1 element of the ‘waveforms_index’ column corresponds to the 1 spike event of the third unit. If the ‘waveforms_index’ column has values [3, 6, 8, 10, 12, 13], then the first 3 elements of the ‘waveforms’ column contain the 3 spike waveforms that were recorded from 3 different electrodes for the first spike time of the first unit. See https://nwb-schema.readthedocs.io/en/stable/format_description.html#doubly-ragged-arrays for a graphical representation of this example. When there is only one electrode for each unit (i.e., each spike time is associated with a single waveform), then the ‘waveforms_index’ column will have values 1, 2, …, N, where N is the number of spike events. The number of electrodes for each spike event should be the same within a given unit. The ‘electrodes’ column should be used to indicate which electrodes are associated with each unit, and the order of the waveforms within a given unit x spike event should be in the same order as the electrodes referenced in the ‘electrodes’ column of this table. The number of samples for each waveform must be the same.

field waveforms_index: UnitsWaveformsIndex | None = None

Index into the waveforms dataset. One value for every spike event. See ‘waveforms’ for more detail.

field waveforms_index_index: UnitsWaveformsIndexIndex | None = None

Index into the waveforms_index dataset. One value for every unit (row in the table). See ‘waveforms’ for more detail.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model ScratchData

Any one-off datasets

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• hdf5_path (Optional[str])

• name (str)

• notes (Optional[str])

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field notes: str | None = None

Any notes the user has about the dataset being stored

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model NWBFile

An NWB file storing cellular-based neurophysiology data from a single experimental session.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• acquisition (Optional[Dict[str, Union[DynamicTable, NWBDataInterface]]])

• analysis (Optional[Dict[str, Union[DynamicTable, NWBContainer]]])

• file_create_date (List[datetime])

• general (NWBFileGeneral)

• hdf5_path (Optional[str])

• identifier (str)

• intervals (Optional[NWBFileIntervals])

• name (Literal['root'])

• nwb_version (Optional[str])

• processing (Optional[Dict[str, ProcessingModule]])

• scratch (Optional[Dict[str, Union[DynamicTable, NWBContainer]]])

• session_description (str)

• session_start_time (datetime)

• stimulus (NWBFileStimulus)

• timestamps_reference_time (datetime)

• units (Optional[Units])

field acquisition: Dict[str, DynamicTable | NWBDataInterface] | None [Optional]

Data streams recorded from the system, including ephys, ophys, tracking, etc. This group should be read-only after the experiment is completed and timestamps are corrected to a common timebase. The data stored here may be links to raw data stored in external NWB files. This will allow keeping bulky raw data out of the file while preserving the option of keeping some/all in the file. Acquired data includes tracking and experimental data streams (i.e., everything measured from the system). If bulky data is stored in the /acquisition group, the data can exist in a separate NWB file that is linked to by the file being used for processing and analysis.

field analysis: Dict[str, DynamicTable | NWBContainer] | None [Optional]

Lab-specific and custom scientific analysis of data. There is no defined format for the content of this group - the format is up to the individual user/lab. To facilitate sharing analysis data between labs, the contents here should be stored in standard types (e.g., neurodata_types) and appropriately documented. The file can store lab-specific and custom data analysis without restriction on its form or schema, reducing data formatting restrictions on end users. Such data should be placed in the analysis group. The analysis data should be documented so that it could be shared with other labs.

field file_create_date: List[datetime] [Optional]

A record of the date the file was created and of subsequent modifications. The date is stored in UTC with local timezone offset as ISO 8601 extended formatted strings: 2018-09-28T14:43:54.123+02:00. Dates stored in UTC end in “Z” with no timezone offset. Date accuracy is up to milliseconds. The file can be created after the experiment was run, so this may differ from the experiment start time. Each modification to the nwb file adds a new entry to the array.

field general: NWBFileGeneral [Required]

Experimental metadata, including protocol, notes and description of hardware device(s). The metadata stored in this section should be used to describe the experiment. Metadata necessary for interpreting the data is stored with the data. General experimental metadata, including animal strain, experimental protocols, experimenter, devices, etc, are stored under ‘general’. Core metadata (e.g., that required to interpret data fields) is stored with the data itself, and implicitly defined by the file specification (e.g., time is in seconds). The strategy used here for storing non-core metadata is to use free-form text fields, such as would appear in sentences or paragraphs from a Methods section. Metadata fields are text to enable them to be more general, for example to represent ranges instead of numerical values. Machine-readable metadata is stored as attributes to these free-form datasets. All entries in the below table are to be included when data is present. Unused groups (e.g., intracellular_ephys in an optophysiology experiment) should not be created unless there is data to store within them.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field identifier: str [Required]

A unique text identifier for the file. For example, concatenated lab name, file creation date/time and experimentalist, or a hash of these and/or other values. The goal is that the string should be unique to all other files.

field intervals: NWBFileIntervals | None = None

Experimental intervals, whether that be logically distinct sub-experiments having a particular scientific goal, trials (see trials subgroup) during an experiment, or epochs (see epochs subgroup) deriving from analysis of data.

field name: Literal['root'] = 'root'

field nwb_version: str | None = None

File version string. Use semantic versioning, e.g. 1.2.1. This will be the name of the format with trailing major, minor and patch numbers.

field processing: Dict[str, ProcessingModule] | None [Optional]

The home for ProcessingModules. These modules perform intermediate analysis of data that is necessary to perform before scientific analysis. Examples include spike clustering, extracting position from tracking data, stitching together image slices. ProcessingModules can be large and express many data sets from relatively complex analysis (e.g., spike detection and clustering) or small, representing extraction of position information from tracking video, or even binary lick/no-lick decisions. Common software tools (e.g., klustakwik, MClust) are expected to read/write data here. ‘Processing’ refers to intermediate analysis of the acquired data to make it more amenable to scientific analysis.

field scratch: Dict[str, DynamicTable | NWBContainer] | None [Optional]

A place to store one-off analysis results. Data placed here is not intended for sharing. By placing data here, users acknowledge that there is no guarantee that their data meets any standard.

field session_description: str [Required]

A description of the experimental session and data in the file.

field session_start_time: datetime [Required]

Date and time of the experiment/session start. The date is stored in UTC with local timezone offset as ISO 8601 extended formatted string: 2018-09-28T14:43:54.123+02:00. Dates stored in UTC end in “Z” with no timezone offset. Date accuracy is up to milliseconds.

field stimulus: NWBFileStimulus [Required]

Data pushed into the system (eg, video stimulus, sound, voltage, etc) and secondary representations of that data (eg, measurements of something used as a stimulus). This group should be made read-only after experiment complete and timestamps are corrected to common timebase. Stores both presented stimuli and stimulus templates, the latter in case the same stimulus is presented multiple times, or is pulled from an external stimulus library. Stimuli are here defined as any signal that is pushed into the system as part of the experiment (eg, sound, video, voltage, etc). Many different experiments can use the same stimuli, and stimuli can be re-used during an experiment. The stimulus group is organized so that one version of template stimuli can be stored and these be used multiple times. These templates can exist in the present file or can be linked to a remote library file.

field timestamps_reference_time: datetime [Required]

Date and time corresponding to time zero of all timestamps. The date is stored in UTC with local timezone offset as ISO 8601 extended formatted string: 2018-09-28T14:43:54.123+02:00. Dates stored in UTC end in “Z” with no timezone offset. Date accuracy is up to milliseconds. All times stored in the file use this time as reference (i.e., time zero).

field units: Units | None = None

Data about sorted spike units.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model LabMetaData

Lab-specific meta-data.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• hdf5_path (Optional[str])

• name (str)

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model Subject

Information about the animal or person from which the data was measured.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• age (Optional[SubjectAge])

• date_of_birth (Optional[datetime])

• description (Optional[str])

• genotype (Optional[str])

• hdf5_path (Optional[str])

• name (str)

• sex (Optional[str])

• species (Optional[str])

• strain (Optional[str])

• subject_id (Optional[str])

• weight (Optional[str])

field age: SubjectAge | None = None

Age of subject. Can be supplied instead of ‘date_of_birth’.

field date_of_birth: datetime | None = None

Date of birth of subject. Can be supplied instead of ‘age’.

field description: str | None = None

Description of subject and where subject came from (e.g., breeder, if animal).

field genotype: str | None = None

Genetic strain. If absent, assume Wild Type (WT).

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field name: str [Required]

field sex: str | None = None

Gender of subject.

field species: str | None = None

Species of subject.

field strain: str | None = None

Strain of subject.

field subject_id: str | None = None

ID of animal/person used/participating in experiment (lab convention).

field weight: str | None = None

Weight at time of experiment, at time of surgery and at other important times.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model TimeIntervals

A container for aggregating epoch data and the TimeSeries that each epoch applies to.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• colnames (Optional[str])

• description (Optional[str])

• hdf5_path (Optional[str])

• id (List[int])

• name (str)

• start_time (Optional[List[float]])

• stop_time (Optional[List[float]])

• tags (Optional[List[str]])

• tags_index (Optional[TimeIntervalsTagsIndex])

• timeseries (Optional[TimeIntervalsTimeseries])

• timeseries_index (Optional[TimeIntervalsTimeseriesIndex])

• vector_data (Optional[List[VectorData]])

field colnames: str | None = None

The names of the columns in this table. This should be used to specify an order to the columns.

field description: str | None = None

Description of what is in this dynamic table.

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

field id: List[int] [Optional]

Array of unique identifiers for the rows of this dynamic table.

field name: str [Required]

field start_time: List[float] | None [Optional]

Start time of epoch, in seconds.

field stop_time: List[float] | None [Optional]

Stop time of epoch, in seconds.

field tags: List[str] | None [Optional]

User-defined tags that identify or categorize events.

field tags_index: TimeIntervalsTagsIndex | None = None

Index for tags.

field timeseries: TimeIntervalsTimeseries | None = None

An index into a TimeSeries object.

field timeseries_index: TimeIntervalsTimeseriesIndex | None = None

Index for timeseries.

field vector_data: List[VectorData] | None [Optional]

Vector columns, including index columns, of this dynamic table.

linkml_meta: ClassVar[LinkML_Meta] = FieldInfo(annotation=NoneType, required=False, default=LinkML_Meta(tree_root=True), frozen=True)

pydantic model ConfiguredBaseModel

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Config:

• validate_assignment: bool = True

• validate_default: bool = True

• extra: str = forbid

• arbitrary_types_allowed: bool = True

• use_enum_values: bool = True

Fields:

• hdf5_path (Optional[str])

field hdf5_path: str | None = None

The absolute path that this object is stored in an NWB file

pydantic model LinkML_Meta

Extra LinkML Metadata stored as a class attribute

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

__init__ uses __pydantic_self__ instead of the more common self for the first arg to allow self as a field name.

Fields:

• tree_root (bool)

field tree_root: bool = False