diff --git a/python/stubs/arbor/__init__.pyi b/python/stubs/arbor/__init__.pyi index 83f19fd01b9664d59e9add1ba97d832d4ea0bbc2..e8b8099bd49cb2d0bc0be5d7ae998d34e4f0e566 100644 --- a/python/stubs/arbor/__init__.pyi +++ b/python/stubs/arbor/__init__.pyi @@ -109,6 +109,8 @@ from arbor._arbor import poisson_schedule from arbor._arbor import print_config from arbor._arbor import probe from arbor._arbor import proc_allocation +from arbor._arbor import profiler_initialize +from arbor._arbor import profiler_summary from arbor._arbor import recipe from arbor._arbor import regular_schedule from arbor._arbor import reversal_potential @@ -132,168 +134,11 @@ from arbor._arbor import units from arbor._arbor import voltage_process from arbor._arbor import write_component from . import _arbor - -__all__ = [ - "ArbFileNotFoundError", - "ArbValueError", - "MechCatItemIterator", - "MechCatKeyIterator", - "MechCatValueIterator", - "allen_catalogue", - "asc_color", - "asc_marker", - "asc_marker_set", - "asc_metadata", - "asc_spine", - "axial_resistivity", - "backend", - "bbp_catalogue", - "benchmark_cell", - "build_catalogue", - "cable", - "cable_cell", - "cable_component", - "cable_global_properties", - "cable_probe_axial_current", - "cable_probe_density_state", - "cable_probe_density_state_cell", - "cable_probe_ion_current_cell", - "cable_probe_ion_current_density", - "cable_probe_ion_diff_concentration", - "cable_probe_ion_diff_concentration_cell", - "cable_probe_ion_ext_concentration", - "cable_probe_ion_ext_concentration_cell", - "cable_probe_ion_int_concentration", - "cable_probe_ion_int_concentration_cell", - "cable_probe_membrane_voltage", - "cable_probe_membrane_voltage_cell", - "cable_probe_point_info", - "cable_probe_point_state", - "cable_probe_point_state_cell", - "cable_probe_stimulus_current_cell", - "cable_probe_total_current_cell", - "cable_probe_total_ion_current_cell", - "cable_probe_total_ion_current_density", - "catalogue", - "cell_address", - "cell_cv_data", - "cell_global_label", - "cell_kind", - "cell_local_label", - "cell_member", - "component_meta_data", - "config", - "connection", - "context", - "cv_data", - "cv_policy", - "cv_policy_every_segment", - "cv_policy_explicit", - "cv_policy_fixed_per_branch", - "cv_policy_max_extent", - "cv_policy_single", - "decor", - "default_catalogue", - "density", - "domain_decomposition", - "env", - "event_generator", - "explicit_schedule", - "ext_concentration", - "extent", - "gap_junction_connection", - "group_description", - "iclamp", - "int_concentration", - "intersect_region", - "ion_data", - "ion_dependency", - "ion_diffusivity", - "ion_settings", - "isometry", - "junction", - "label_dict", - "lif_cell", - "lif_probe_metadata", - "lif_probe_voltage", - "load_asc", - "load_catalogue", - "load_component", - "load_swc_arbor", - "load_swc_neuron", - "loaded_morphology", - "location", - "mechanism", - "mechanism_field", - "mechanism_info", - "membrane_capacitance", - "membrane_potential", - "meter_manager", - "meter_report", - "mnpos", - "modcc", - "morphology", - "morphology_provider", - "mpoint", - "msegment", - "neuroml", - "neuron_cable_properties", - "nml_metadata", - "partition_by_group", - "partition_hint", - "partition_load_balance", - "place_pwlin", - "poisson_schedule", - "print_config", - "probe", - "proc_allocation", - "recipe", - "regular_schedule", - "reversal_potential", - "reversal_potential_method", - "scaled_mechanism", - "schedule_base", - "segment_tree", - "selection_policy", - "simulation", - "single_cell_model", - "spike", - "spike_recording", - "spike_source_cell", - "stochastic_catalogue", - "swc_metadata", - "synapse", - "temperature", - "threshold_detector", - "trace", - "units", - "voltage_process", - "write_component", -] - -def build_catalogue(): ... -def modcc(): ... - -__config__: dict = { - "mpi": False, - "mpi4py": False, - "gpu": None, - "vectorize": True, - "profiling": False, - "neuroml": True, - "bundled": True, - "version": "0.9.1-dev", - "source": "2024-03-01T14:59:23+01:00 dcdfe101f389cb4854ac3d0a067feeb280600c88 modified", - "build_config": "DEBUG", - "arch": "native", - "prefix": "/usr/local", - "python_lib_path": "/usr/local/lib/python3.12/site-packages", - "binary_path": "bin", - "lib_path": "lib", - "data_path": "share", - "CXX": "/opt/homebrew/bin/clang++", - "pybind-version": "2.11.1", - "timestamp": "Mar 4 2024 20:56:20", -} -__version__: str = "0.9.1-dev" +__all__ = ['ArbFileNotFoundError', 'ArbValueError', 'MechCatItemIterator', 'MechCatKeyIterator', 'MechCatValueIterator', 'allen_catalogue', 'asc_color', 'asc_marker', 'asc_marker_set', 'asc_metadata', 'asc_spine', 'axial_resistivity', 'backend', 'bbp_catalogue', 'benchmark_cell', 'build_catalogue', 'cable', 'cable_cell', 'cable_component', 'cable_global_properties', 'cable_probe_axial_current', 'cable_probe_density_state', 'cable_probe_density_state_cell', 'cable_probe_ion_current_cell', 'cable_probe_ion_current_density', 'cable_probe_ion_diff_concentration', 'cable_probe_ion_diff_concentration_cell', 'cable_probe_ion_ext_concentration', 'cable_probe_ion_ext_concentration_cell', 'cable_probe_ion_int_concentration', 'cable_probe_ion_int_concentration_cell', 'cable_probe_membrane_voltage', 'cable_probe_membrane_voltage_cell', 'cable_probe_point_info', 'cable_probe_point_state', 'cable_probe_point_state_cell', 'cable_probe_stimulus_current_cell', 'cable_probe_total_current_cell', 'cable_probe_total_ion_current_cell', 'cable_probe_total_ion_current_density', 'catalogue', 'cell_address', 'cell_cv_data', 'cell_global_label', 'cell_kind', 'cell_local_label', 'cell_member', 'component_meta_data', 'config', 'connection', 'context', 'cv_data', 'cv_policy', 'cv_policy_every_segment', 'cv_policy_explicit', 'cv_policy_fixed_per_branch', 'cv_policy_max_extent', 'cv_policy_single', 'decor', 'default_catalogue', 'density', 'domain_decomposition', 'env', 'event_generator', 'explicit_schedule', 'ext_concentration', 'extent', 'gap_junction_connection', 'group_description', 'iclamp', 'int_concentration', 'intersect_region', 'ion_data', 'ion_dependency', 'ion_diffusivity', 'ion_settings', 'isometry', 'junction', 'label_dict', 'lif_cell', 'lif_probe_metadata', 'lif_probe_voltage', 'load_asc', 'load_catalogue', 'load_component', 'load_swc_arbor', 'load_swc_neuron', 'loaded_morphology', 'location', 'mechanism', 'mechanism_field', 'mechanism_info', 'membrane_capacitance', 'membrane_potential', 'meter_manager', 'meter_report', 'mnpos', 'modcc', 'morphology', 'morphology_provider', 'mpoint', 'msegment', 'neuroml', 'neuron_cable_properties', 'nml_metadata', 'partition_by_group', 'partition_hint', 'partition_load_balance', 'place_pwlin', 'poisson_schedule', 'print_config', 'probe', 'proc_allocation', 'profiler_initialize', 'profiler_summary', 'recipe', 'regular_schedule', 'reversal_potential', 'reversal_potential_method', 'scaled_mechanism', 'schedule_base', 'segment_tree', 'selection_policy', 'simulation', 'single_cell_model', 'spike', 'spike_recording', 'spike_source_cell', 'stochastic_catalogue', 'swc_metadata', 'synapse', 'temperature', 'threshold_detector', 'trace', 'units', 'voltage_process', 'write_component'] +def build_catalogue(): + ... +def modcc(): + ... +__config__: dict = {'mpi': False, 'mpi4py': False, 'gpu': None, 'vectorize': True, 'profiling': True, 'neuroml': True, 'bundled': True, 'version': '0.9.1-dev', 'source': '2024-04-11T13:13:43+02:00 8dac3a25b35f3e73f7ad50c27bd06d018e10bb6f modified', 'build_config': 'RELEASE', 'arch': 'native', 'prefix': '/usr/local', 'python_lib_path': '/opt/homebrew/lib/python3.12/site-packages', 'binary_path': 'bin', 'lib_path': 'lib', 'data_path': 'share', 'CXX': '/opt/homebrew/bin/clang++', 'pybind-version': '2.11.1', 'timestamp': 'Apr 11 2024 20:38:51'} +__version__: str = '0.9.1-dev' mnpos: int = 4294967295 diff --git a/python/stubs/arbor/_arbor/__init__.pyi b/python/stubs/arbor/_arbor/__init__.pyi index 94e4178308e9d49469609239efb68182f884bc0b..4a5b2288d00351cf1173363850a74dd741f5a694 100644 --- a/python/stubs/arbor/_arbor/__init__.pyi +++ b/python/stubs/arbor/_arbor/__init__.pyi @@ -1,288 +1,171 @@ """ arbor: multicompartment neural network models. """ - from __future__ import annotations import typing from . import env from . import units - -__all__ = [ - "ArbFileNotFoundError", - "ArbValueError", - "MechCatItemIterator", - "MechCatKeyIterator", - "MechCatValueIterator", - "allen_catalogue", - "asc_color", - "asc_marker", - "asc_marker_set", - "asc_metadata", - "asc_spine", - "axial_resistivity", - "backend", - "bbp_catalogue", - "benchmark_cell", - "cable", - "cable_cell", - "cable_component", - "cable_global_properties", - "cable_probe_axial_current", - "cable_probe_density_state", - "cable_probe_density_state_cell", - "cable_probe_ion_current_cell", - "cable_probe_ion_current_density", - "cable_probe_ion_diff_concentration", - "cable_probe_ion_diff_concentration_cell", - "cable_probe_ion_ext_concentration", - "cable_probe_ion_ext_concentration_cell", - "cable_probe_ion_int_concentration", - "cable_probe_ion_int_concentration_cell", - "cable_probe_membrane_voltage", - "cable_probe_membrane_voltage_cell", - "cable_probe_point_info", - "cable_probe_point_state", - "cable_probe_point_state_cell", - "cable_probe_stimulus_current_cell", - "cable_probe_total_current_cell", - "cable_probe_total_ion_current_cell", - "cable_probe_total_ion_current_density", - "catalogue", - "cell_address", - "cell_cv_data", - "cell_global_label", - "cell_kind", - "cell_local_label", - "cell_member", - "component_meta_data", - "config", - "connection", - "context", - "cv_data", - "cv_policy", - "cv_policy_every_segment", - "cv_policy_explicit", - "cv_policy_fixed_per_branch", - "cv_policy_max_extent", - "cv_policy_single", - "decor", - "default_catalogue", - "density", - "domain_decomposition", - "env", - "event_generator", - "explicit_schedule", - "ext_concentration", - "extent", - "gap_junction_connection", - "group_description", - "iclamp", - "int_concentration", - "intersect_region", - "ion_data", - "ion_dependency", - "ion_diffusivity", - "ion_settings", - "isometry", - "junction", - "label_dict", - "lif_cell", - "lif_probe_metadata", - "lif_probe_voltage", - "load_asc", - "load_catalogue", - "load_component", - "load_swc_arbor", - "load_swc_neuron", - "loaded_morphology", - "location", - "mechanism", - "mechanism_field", - "mechanism_info", - "membrane_capacitance", - "membrane_potential", - "meter_manager", - "meter_report", - "mnpos", - "morphology", - "morphology_provider", - "mpoint", - "msegment", - "neuroml", - "neuron_cable_properties", - "nml_metadata", - "partition_by_group", - "partition_hint", - "partition_load_balance", - "place_pwlin", - "poisson_schedule", - "print_config", - "probe", - "proc_allocation", - "recipe", - "regular_schedule", - "reversal_potential", - "reversal_potential_method", - "scaled_mechanism", - "schedule_base", - "segment_tree", - "selection_policy", - "simulation", - "single_cell_model", - "spike", - "spike_recording", - "spike_source_cell", - "stochastic_catalogue", - "swc_metadata", - "synapse", - "temperature", - "threshold_detector", - "trace", - "units", - "voltage_process", - "write_component", -] - +__all__ = ['ArbFileNotFoundError', 'ArbValueError', 'MechCatItemIterator', 'MechCatKeyIterator', 'MechCatValueIterator', 'allen_catalogue', 'asc_color', 'asc_marker', 'asc_marker_set', 'asc_metadata', 'asc_spine', 'axial_resistivity', 'backend', 'bbp_catalogue', 'benchmark_cell', 'cable', 'cable_cell', 'cable_component', 'cable_global_properties', 'cable_probe_axial_current', 'cable_probe_density_state', 'cable_probe_density_state_cell', 'cable_probe_ion_current_cell', 'cable_probe_ion_current_density', 'cable_probe_ion_diff_concentration', 'cable_probe_ion_diff_concentration_cell', 'cable_probe_ion_ext_concentration', 'cable_probe_ion_ext_concentration_cell', 'cable_probe_ion_int_concentration', 'cable_probe_ion_int_concentration_cell', 'cable_probe_membrane_voltage', 'cable_probe_membrane_voltage_cell', 'cable_probe_point_info', 'cable_probe_point_state', 'cable_probe_point_state_cell', 'cable_probe_stimulus_current_cell', 'cable_probe_total_current_cell', 'cable_probe_total_ion_current_cell', 'cable_probe_total_ion_current_density', 'catalogue', 'cell_address', 'cell_cv_data', 'cell_global_label', 'cell_kind', 'cell_local_label', 'cell_member', 'component_meta_data', 'config', 'connection', 'context', 'cv_data', 'cv_policy', 'cv_policy_every_segment', 'cv_policy_explicit', 'cv_policy_fixed_per_branch', 'cv_policy_max_extent', 'cv_policy_single', 'decor', 'default_catalogue', 'density', 'domain_decomposition', 'env', 'event_generator', 'explicit_schedule', 'ext_concentration', 'extent', 'gap_junction_connection', 'group_description', 'iclamp', 'int_concentration', 'intersect_region', 'ion_data', 'ion_dependency', 'ion_diffusivity', 'ion_settings', 'isometry', 'junction', 'label_dict', 'lif_cell', 'lif_probe_metadata', 'lif_probe_voltage', 'load_asc', 'load_catalogue', 'load_component', 'load_swc_arbor', 'load_swc_neuron', 'loaded_morphology', 'location', 'mechanism', 'mechanism_field', 'mechanism_info', 'membrane_capacitance', 'membrane_potential', 'meter_manager', 'meter_report', 'mnpos', 'morphology', 'morphology_provider', 'mpoint', 'msegment', 'neuroml', 'neuron_cable_properties', 'nml_metadata', 'partition_by_group', 'partition_hint', 'partition_load_balance', 'place_pwlin', 'poisson_schedule', 'print_config', 'probe', 'proc_allocation', 'profiler_initialize', 'profiler_summary', 'recipe', 'regular_schedule', 'reversal_potential', 'reversal_potential_method', 'scaled_mechanism', 'schedule_base', 'segment_tree', 'selection_policy', 'simulation', 'single_cell_model', 'spike', 'spike_recording', 'spike_source_cell', 'stochastic_catalogue', 'swc_metadata', 'synapse', 'temperature', 'threshold_detector', 'trace', 'units', 'voltage_process', 'write_component'] class ArbFileNotFoundError(FileNotFoundError): pass - class ArbValueError(ValueError): pass - class MechCatItemIterator: - def __iter__(self) -> MechCatItemIterator: ... - def __next__(self) -> tuple[str, mechanism_info]: ... - + def __iter__(self) -> MechCatItemIterator: + ... + def __next__(self) -> tuple[str, mechanism_info]: + ... class MechCatKeyIterator: - def __iter__(self) -> MechCatKeyIterator: ... - def __next__(self) -> str: ... - + def __iter__(self) -> MechCatKeyIterator: + ... + def __next__(self) -> str: + ... class MechCatValueIterator: - def __iter__(self) -> MechCatValueIterator: ... - def __next__(self) -> mechanism_info: ... - + def __iter__(self) -> MechCatValueIterator: + ... + def __next__(self) -> mechanism_info: + ... class asc_color: """ Neurolucida color tag. """ - @property - def blue(self) -> int: ... + def blue(self) -> int: + ... @property - def green(self) -> int: ... + def green(self) -> int: + ... @property - def red(self) -> int: ... - + def red(self) -> int: + ... class asc_marker: """ Neurolucida marker type. - + Members: - + dot - + cross - + circle - + none """ - - __members__: typing.ClassVar[ - dict[str, asc_marker] - ] # value = {'dot': <asc_marker.dot: 0>, 'cross': <asc_marker.cross: 2>, 'circle': <asc_marker.circle: 1>, 'none': <asc_marker.none: 3>} + __members__: typing.ClassVar[dict[str, asc_marker]] # value = {'dot': <asc_marker.dot: 0>, 'cross': <asc_marker.cross: 2>, 'circle': <asc_marker.circle: 1>, 'none': <asc_marker.none: 3>} circle: typing.ClassVar[asc_marker] # value = <asc_marker.circle: 1> cross: typing.ClassVar[asc_marker] # value = <asc_marker.cross: 2> dot: typing.ClassVar[asc_marker] # value = <asc_marker.dot: 0> none: typing.ClassVar[asc_marker] # value = <asc_marker.none: 3> - def __eq__(self, other: typing.Any) -> bool: ... - def __getstate__(self) -> int: ... - def __hash__(self) -> int: ... - def __index__(self) -> int: ... - def __init__(self, value: int) -> None: ... - def __int__(self) -> int: ... - def __ne__(self, other: typing.Any) -> bool: ... - def __repr__(self) -> str: ... - def __setstate__(self, state: int) -> None: ... - def __str__(self) -> str: ... - @property - def name(self) -> str: ... - @property - def value(self) -> int: ... - + def __eq__(self, other: typing.Any) -> bool: + ... + def __getstate__(self) -> int: + ... + def __hash__(self) -> int: + ... + def __index__(self) -> int: + ... + def __init__(self, value: int) -> None: + ... + def __int__(self) -> int: + ... + def __ne__(self, other: typing.Any) -> bool: + ... + def __repr__(self) -> str: + ... + def __setstate__(self, state: int) -> None: + ... + def __str__(self) -> str: + ... + @property + def name(self) -> str: + ... + @property + def value(self) -> int: + ... class asc_marker_set: """ Neurolucida marker set type. """ - @property - def color(self) -> asc_color: ... + def color(self) -> asc_color: + ... @property - def locations(self) -> list[mpoint]: ... + def locations(self) -> list[mpoint]: + ... @property - def marker(self) -> asc_marker: ... + def marker(self) -> asc_marker: + ... @property - def name(self) -> str: ... - + def name(self) -> str: + ... class asc_metadata: """ Neurolucida metadata type: Spines and marker sets. """ - @property - def markers(self) -> list[asc_marker_set]: ... + def markers(self) -> list[asc_marker_set]: + ... @property - def spines(self) -> list[asc_spine]: ... - + def spines(self) -> list[asc_spine]: + ... class asc_spine: """ Neurolucida spine marker. """ - @property - def location(self) -> mpoint: ... + def location(self) -> mpoint: + ... @property - def name(self) -> str: ... - + def name(self) -> str: + ... class axial_resistivity: """ Setting the axial resistivity. """ - - def __init__(self, arg0: units.quantity) -> None: ... - def __repr__(self) -> str: ... - + def __init__(self, arg0: units.quantity) -> None: + ... + def __repr__(self) -> str: + ... class backend: """ Enumeration used to indicate which hardware backend to execute a cell group on. - + Members: - + gpu : Use GPU backend. - + multicore : Use multicore backend. """ - - __members__: typing.ClassVar[ - dict[str, backend] - ] # value = {'gpu': <backend.gpu: 0>, 'multicore': <backend.multicore: 1>} + __members__: typing.ClassVar[dict[str, backend]] # value = {'gpu': <backend.gpu: 0>, 'multicore': <backend.multicore: 1>} gpu: typing.ClassVar[backend] # value = <backend.gpu: 0> multicore: typing.ClassVar[backend] # value = <backend.multicore: 1> - def __eq__(self, other: typing.Any) -> bool: ... - def __getstate__(self) -> int: ... - def __hash__(self) -> int: ... - def __index__(self) -> int: ... - def __init__(self, value: int) -> None: ... - def __int__(self) -> int: ... - def __ne__(self, other: typing.Any) -> bool: ... - def __repr__(self) -> str: ... - def __setstate__(self, state: int) -> None: ... - def __str__(self) -> str: ... - @property - def name(self) -> str: ... - @property - def value(self) -> int: ... - + def __eq__(self, other: typing.Any) -> bool: + ... + def __getstate__(self) -> int: + ... + def __hash__(self) -> int: + ... + def __index__(self) -> int: + ... + def __init__(self, value: int) -> None: + ... + def __int__(self) -> int: + ... + def __ne__(self, other: typing.Any) -> bool: + ... + def __repr__(self) -> str: + ... + def __setstate__(self, state: int) -> None: + ... + def __str__(self) -> str: + ... + @property + def name(self) -> str: + ... + @property + def value(self) -> int: + ... class benchmark_cell: """ A benchmarking cell, used by Arbor developers to test communication performance. @@ -291,153 +174,118 @@ class benchmark_cell: for example if realtime_ratio=2, a cell will take 2 seconds of CPU time to simulate 1 second. """ - @typing.overload - def __init__( - self, - source_label: str, - target_label: str, - schedule: regular_schedule, - realtime_ratio: float = 1.0, - ) -> None: + def __init__(self, source_label: str, target_label: str, schedule: regular_schedule, realtime_ratio: float = 1.0) -> None: """ Construct a benchmark cell that generates spikes on 'source_label' at regular intervals. The cell has one source labeled 'source_label', and one target labeled 'target_label'. """ - @typing.overload - def __init__( - self, - source_label: str, - target_label: str, - schedule: explicit_schedule, - realtime_ratio: float = 1.0, - ) -> None: + def __init__(self, source_label: str, target_label: str, schedule: explicit_schedule, realtime_ratio: float = 1.0) -> None: """ Construct a benchmark cell that generates spikes on 'source_label' at a sequence of user-defined times. The cell has one source labeled 'source_label', and one target labeled 'target_label'. """ - @typing.overload - def __init__( - self, - source_label: str, - target_label: str, - schedule: poisson_schedule, - realtime_ratio: float = 1.0, - ) -> None: + def __init__(self, source_label: str, target_label: str, schedule: poisson_schedule, realtime_ratio: float = 1.0) -> None: """ Construct a benchmark cell that generates spikeson 'source_label' at times defined by a Poisson sequence. The cell has one source labeled 'source_label', and one target labeled 'target_label'. """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... - + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... class cable: __hash__: typing.ClassVar[None] = None - def __eq__(self, arg0: cable) -> bool: ... - def __init__(self, branch: int, prox: float, dist: float) -> None: ... - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __eq__(self, arg0: cable) -> bool: + ... + def __init__(self, branch: int, prox: float, dist: float) -> None: + ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def branch(self) -> int: """ The id of the branch on which the cable lies. """ - @property def dist(self) -> float: """ The relative position of the distal end of the cable on its branch ∈ [0,1]. """ - @property def prox(self) -> float: """ The relative position of the proximal end of the cable on its branch ∈ [0,1]. """ - class cable_cell: """ Represents morphologically-detailed cell models, with morphology represented as a tree of one-dimensional cable segments. """ - @typing.overload - def __init__( - self, morphology: morphology, decor: decor, labels: label_dict | None = None - ) -> None: + def __init__(self, morphology: morphology, decor: decor, labels: label_dict | None = None) -> None: """ Construct with a morphology, decor, and label dictionary. """ - @typing.overload - def __init__( - self, segment_tree: segment_tree, decor: decor, labels: label_dict | None = None - ) -> None: + def __init__(self, segment_tree: segment_tree, decor: decor, labels: label_dict | None = None) -> None: """ Construct with a morphology derived from a segment tree, decor, and label dictionary. """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... def cables(self, label: str) -> list[cable]: """ The cable segments of the cell morphology for a region label. """ - def locations(self, label: str) -> list[location]: """ The locations of the cell morphology for a locset label. """ - @property def num_branches(self) -> int: """ The number of unbranched cable sections in the morphology. """ - class cable_component: - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def component(self) -> morphology | label_dict | decor | cable_cell: """ cable-cell component. """ - @property def meta_data(self) -> component_meta_data: """ cable-cell component meta-data. """ - @meta_data.setter - def meta_data(self, arg0: component_meta_data) -> None: ... - + def meta_data(self, arg0: component_meta_data) -> None: + ... class cable_global_properties: membrane_voltage_limit: float | None @typing.overload - def __init__(self) -> None: ... + def __init__(self) -> None: + ... @typing.overload - def __init__(self, arg0: cable_global_properties) -> None: ... - def __str__(self) -> str: ... + def __init__(self, arg0: cable_global_properties) -> None: + ... + def __str__(self) -> str: + ... def check(self) -> None: """ Test whether all default parameters and ion species properties have been set. """ - - def set_ion( - self, - ion: str, - valence: int | None = None, - int_con: units.quantity | None = None, - ext_con: units.quantity | None = None, - rev_pot: units.quantity | None = None, - method: typing.Any = None, - diff: units.quantity | None = None, - ) -> None: + def set_ion(self, ion: str, valence: int | None = None, int_con: units.quantity | None = None, ext_con: units.quantity | None = None, rev_pot: units.quantity | None = None, method: typing.Any = None, diff: units.quantity | None = None) -> None: """ Set the global default properties of ion species named 'ion'. * valence: valence of the ion species [e]. @@ -455,14 +303,7 @@ class cable_global_properties: reversal potential is global for all compartments in the cell, and can't be overriden locally. """ - - def set_property( - self, - Vm: units.quantity | None = None, - cm: units.quantity | None = None, - rL: units.quantity | None = None, - tempK: units.quantity | None = None, - ) -> None: + def set_property(self, Vm: units.quantity | None = None, cm: units.quantity | None = None, rL: units.quantity | None = None, tempK: units.quantity | None = None) -> None: """ Set global default values for cable and cell properties. * Vm: initial membrane voltage [mV]. @@ -471,179 +312,169 @@ class cable_global_properties: * tempK: temperature [Kelvin]. These values can be overridden on specific regions using the paint interface. """ - def unset_ion(self, arg0: str) -> None: """ Remove ion species from properties. """ - @property - def axial_resistivity(self) -> float | None: ... + def axial_resistivity(self) -> float | None: + ... @property def catalogue(self) -> catalogue: """ The mechanism catalogue. """ - @catalogue.setter - def catalogue(self, arg0: catalogue) -> None: ... + def catalogue(self, arg0: catalogue) -> None: + ... @property def coalesce_synapses(self) -> bool: """ Flag for enabling/disabling linear syanpse coalescing. """ - @coalesce_synapses.setter - def coalesce_synapses(self, arg0: bool) -> None: ... + def coalesce_synapses(self, arg0: bool) -> None: + ... @property - def ion_data(self) -> dict[str, ion_data]: ... + def ion_data(self) -> dict[str, ion_data]: + ... @property - def ion_reversal_potential(self) -> dict[str, mechanism]: ... + def ion_reversal_potential(self) -> dict[str, mechanism]: + ... @property - def ion_valence(self) -> dict[str, int]: ... + def ion_valence(self) -> dict[str, int]: + ... @property def ions(self) -> dict[str, ion_settings]: """ Return a view of all ion settings. """ - @property - def membrane_capacitance(self) -> float | None: ... + def membrane_capacitance(self) -> float | None: + ... @property - def membrane_potential(self) -> float | None: ... + def membrane_potential(self) -> float | None: + ... @property - def temperature(self) -> float | None: ... - + def temperature(self) -> float | None: + ... class cable_probe_point_info: """ Probe metadata associated with a cable cell probe for point process state. """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def location(self) -> location: """ Location of point process instance on cell. """ - @location.setter - def location(self, arg0: location) -> None: ... + def location(self, arg0: location) -> None: + ... @property def multiplicity(self) -> int: """ Number of coalesced point processes (linear synapses) associated with this instance. """ - @multiplicity.setter - def multiplicity(self, arg0: int) -> None: ... + def multiplicity(self, arg0: int) -> None: + ... @property def target(self) -> int: """ The target index of the point process instance on the cell. """ - @target.setter - def target(self, arg0: int) -> None: ... - + def target(self, arg0: int) -> None: + ... class catalogue: def __contains__(self, name: str) -> bool: """ Is 'name' in the catalogue? """ - - def __getitem__(self, arg0: str) -> mechanism_info: ... + def __getitem__(self, arg0: str) -> mechanism_info: + ... @typing.overload - def __init__(self) -> None: ... + def __init__(self) -> None: + ... @typing.overload - def __init__(self, arg0: catalogue) -> None: ... + def __init__(self, arg0: catalogue) -> None: + ... def __iter__(self) -> MechCatKeyIterator: """ Return an iterator over all mechanism names in this catalogues. """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... - def derive( - self, - name: str, - parent: str, - globals: dict[str, float] = {}, - ions: dict[str, str] = {}, - ) -> None: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... + def derive(self, name: str, parent: str, globals: dict[str, float] = {}, ions: dict[str, str] = {}) -> None: + ... def extend(self, other: catalogue, prefix: str) -> None: """ Import another catalogue, possibly with a prefix. Will overwrite in case of name collisions. """ - def is_derived(self, name: str) -> bool: """ Is 'name' a derived mechanism or can it be implicitly derived? """ - def items(self) -> MechCatItemIterator: """ Return an iterator over all (name, mechanism) tuples in this catalogues. """ - def keys(self) -> MechCatKeyIterator: """ Return an iterator over all mechanism names in this catalogues. """ - def values(self) -> MechCatValueIterator: """ Return an iterator over all mechanism info values in this catalogues. """ - class cell_address: gid: int tag: str - class cell_cv_data: """ Provides information on the CVs representing the discretization of a cable-cell. """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... def cables(self, index: int) -> list[cable]: """ Return a list of cables representing the CV at the given index. """ - def children(self, index: int) -> list[int]: """ Return a list of indices of the CVs representing the children of the CV at the given index. """ - def parent(self, index: int) -> int: """ Return the index of the CV representing the parent of the CV at the given index. """ - @property def num_cv(self) -> int: """ Return the number of CVs in the cell. """ - class cell_global_label: """ For global identification of an item. - + cell_global_label members: (1) a unique cell identified by its gid. (2) a cell_local_label, referring to a labeled group of items on the cell and a policy for selecting a single item out of the group. """ - @typing.overload def __init__(self, gid: int, label: str) -> None: """ Construct a cell_global_label identifier from a gid and a label argument identifying an item on the cell. The default round_robin policy is used for selecting one of possibly multiple items on the cell associated with the label. """ - @typing.overload def __init__(self, gid: int, label: cell_local_label) -> None: """ @@ -651,7 +482,6 @@ class cell_global_label: gid: The global identifier of the cell. label: The cell_local_label representing the label and selection policy of an item on the cell. """ - @typing.overload def __init__(self, arg0: tuple[int, cell_local_label]) -> None: """ @@ -659,7 +489,6 @@ class cell_global_label: gid: The global identifier of the cell. label: The cell_local_label representing the label and selection policy of an item on the cell. """ - @typing.overload def __init__(self, arg0: tuple[int, str]) -> None: """ @@ -667,79 +496,85 @@ class cell_global_label: gid: The global identifier of the cell. label: The tag of an item on the cell. """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def gid(self) -> int: """ The global identifier of the cell. """ - @gid.setter - def gid(self, arg0: int) -> None: ... + def gid(self, arg0: int) -> None: + ... @property def label(self) -> cell_local_label: """ The cell_local_label representing the label and selection policy of an item on the cell. """ - @label.setter - def label(self, arg0: cell_local_label) -> None: ... - + def label(self, arg0: cell_local_label) -> None: + ... class cell_kind: """ Enumeration used to identify the cell kind, used by the model to group equal kinds in the same cell group. - + Members: - + benchmark : Proxy cell used for benchmarking. - + cable : A cell with morphology described by branching 1D cable segments. - + lif : Leaky-integrate and fire neuron. - + spike_source : Proxy cell that generates spikes from a spike sequence provided by the user. """ - - __members__: typing.ClassVar[ - dict[str, cell_kind] - ] # value = {'benchmark': <cell_kind.benchmark: 3>, 'cable': <cell_kind.cable: 0>, 'lif': <cell_kind.lif: 1>, 'spike_source': <cell_kind.spike_source: 2>} + __members__: typing.ClassVar[dict[str, cell_kind]] # value = {'benchmark': <cell_kind.benchmark: 3>, 'cable': <cell_kind.cable: 0>, 'lif': <cell_kind.lif: 1>, 'spike_source': <cell_kind.spike_source: 2>} benchmark: typing.ClassVar[cell_kind] # value = <cell_kind.benchmark: 3> cable: typing.ClassVar[cell_kind] # value = <cell_kind.cable: 0> lif: typing.ClassVar[cell_kind] # value = <cell_kind.lif: 1> spike_source: typing.ClassVar[cell_kind] # value = <cell_kind.spike_source: 2> - def __eq__(self, other: typing.Any) -> bool: ... - def __getstate__(self) -> int: ... - def __hash__(self) -> int: ... - def __index__(self) -> int: ... - def __init__(self, value: int) -> None: ... - def __int__(self) -> int: ... - def __ne__(self, other: typing.Any) -> bool: ... - def __repr__(self) -> str: ... - def __setstate__(self, state: int) -> None: ... - def __str__(self) -> str: ... - @property - def name(self) -> str: ... - @property - def value(self) -> int: ... - + def __eq__(self, other: typing.Any) -> bool: + ... + def __getstate__(self) -> int: + ... + def __hash__(self) -> int: + ... + def __index__(self) -> int: + ... + def __init__(self, value: int) -> None: + ... + def __int__(self) -> int: + ... + def __ne__(self, other: typing.Any) -> bool: + ... + def __repr__(self) -> str: + ... + def __setstate__(self, state: int) -> None: + ... + def __str__(self) -> str: + ... + @property + def name(self) -> str: + ... + @property + def value(self) -> int: + ... class cell_local_label: """ For local identification of an item. - + cell_local_label identifies: (1) a labeled group of one or more items on one or more locations on the cell. (2) a policy for selecting one of the items. """ - @typing.overload def __init__(self, label: str) -> None: """ Construct a cell_local_label identifier from a label argument identifying a group of one or more items on a cell. The default round_robin policy is used for selecting one of possibly multiple items associated with the label. """ - @typing.overload def __init__(self, label: str, policy: selection_policy) -> None: """ @@ -747,7 +582,6 @@ class cell_local_label: label: The identifier of a group of one or more items on a cell. policy: The policy for selecting one of possibly multiple items associated with the label. """ - @typing.overload def __init__(self, arg0: tuple[str, selection_policy]) -> None: """ @@ -755,7 +589,6 @@ class cell_local_label: label: The identifier of a group of one or more items on a cell. policy: The policy for selecting one of possibly multiple items associated with the label. """ - @typing.overload def __init__(self, arg0: tuple[str, selection_policy]) -> None: """ @@ -763,35 +596,34 @@ class cell_local_label: label: The identifier of a group of one or more items on a cell. policy: The policy for selecting one of possibly multiple items associated with the label. """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def label(self) -> str: """ The identifier of a a group of one or more items on a cell. """ - @label.setter - def label(self, arg0: str) -> None: ... + def label(self, arg0: str) -> None: + ... @property def policy(self) -> selection_policy: """ The policy for selecting one of possibly multiple items associated with the label. """ - @policy.setter - def policy(self, arg0: selection_policy) -> None: ... - + def policy(self, arg0: selection_policy) -> None: + ... class cell_member: """ For global identification of a cell-local item. - + Items of cell_member must: (1) be associated with a unique cell, identified by the member gid; (2) identify an item within a cell-local collection by the member index. """ - @typing.overload def __init__(self, gid: int, index: int) -> None: """ @@ -799,7 +631,6 @@ class cell_member: gid: The global identifier of the cell. index: The cell-local index of the item. """ - @typing.overload def __init__(self, arg0: tuple) -> None: """ @@ -807,49 +638,41 @@ class cell_member: gid: The global identifier of the cell. index: The cell-local index of the item. """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def gid(self) -> int: """ The global identifier of the cell. """ - @gid.setter - def gid(self, arg0: int) -> None: ... + def gid(self, arg0: int) -> None: + ... @property def index(self) -> int: """ Cell-local index of the item. """ - @index.setter - def index(self, arg0: int) -> None: ... - + def index(self, arg0: int) -> None: + ... class component_meta_data: @property def version(self) -> str: """ cable-cell component version. """ - @version.setter - def version(self, arg0: str) -> None: ... - + def version(self, arg0: str) -> None: + ... class connection: """ Describes a connection between two cells: Defined by source and destination end points (that is pre-synaptic and post-synaptic respectively), a connection weight and a delay time. """ - - def __init__( - self, - source: cell_global_label, - dest: cell_local_label, - weight: float, - delay: units.quantity, - ) -> None: + def __init__(self, source: cell_global_label, dest: cell_local_label, weight: float, delay: units.quantity) -> None: """ Construct a connection with arguments: source: The source end point of the connection. @@ -857,64 +680,53 @@ class connection: weight: The weight delivered to the target synapse (unit defined by the type of synapse target). delay: The delay of the connection [ms]. """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def delay(self) -> float: """ The delay time of the connection [ms]. """ - @delay.setter - def delay(self, arg0: float) -> None: ... + def delay(self, arg0: float) -> None: + ... @property def dest(self) -> cell_local_label: """ The destination label of the connection. """ - @dest.setter - def dest(self, arg0: cell_local_label) -> None: ... + def dest(self, arg0: cell_local_label) -> None: + ... @property def source(self) -> cell_global_label: """ The source gid and label of the connection. """ - @source.setter - def source(self, arg0: cell_global_label) -> None: ... + def source(self, arg0: cell_global_label) -> None: + ... @property def weight(self) -> float: """ The weight of the connection. """ - @weight.setter - def weight(self, arg0: float) -> None: ... - + def weight(self, arg0: float) -> None: + ... class context: """ An opaque handle for the hardware resources used in a simulation. """ - @typing.overload def __init__(self) -> None: """ Construct a local context with proc_allocation = env.default_allocation(). """ - @typing.overload - def __init__( - self, - *, - threads: int = 1, - gpu_id: typing.Any = None, - mpi: typing.Any = None, - inter: typing.Any = None, - bind_procs: bool = False, - bind_threads: bool = False, - ) -> None: + def __init__(self, *, threads: int = 1, gpu_id: typing.Any = None, mpi: typing.Any = None, inter: typing.Any = None, bind_procs: bool = False, bind_threads: bool = False) -> None: """ Construct a context with arguments: threads: The number of threads available locally for execution. Must be set to 1 at minimum. 1 by default. @@ -924,141 +736,106 @@ class context: bind_procs: Create process binding mask. bind_threads: Create thread binding mask. """ - @typing.overload - def __init__( - self, - alloc: proc_allocation, - *, - mpi: typing.Any = None, - inter: typing.Any = None, - ) -> None: + def __init__(self, alloc: proc_allocation, *, mpi: typing.Any = None, inter: typing.Any = None) -> None: """ Construct a context with arguments: alloc: The computational resources to be used for the simulation. mpi: The MPI communicator, None by default. Only available if arbor.__config__['mpi']==True. inter: An MPI intercommunicator used to connect to external simulations, None by default. Only available if arbor.__config__['mpi']==True. """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def has_gpu(self) -> bool: """ Whether the context has a GPU. """ - @property def has_mpi(self) -> bool: """ Whether the context uses MPI for distributed communication. """ - @property def rank(self) -> int: """ The numeric id of the local domain (equivalent to MPI rank). """ - @property def ranks(self) -> int: """ The number of distributed domains (equivalent to the number of MPI ranks). """ - @property def threads(self) -> int: """ The number of threads in the context's thread pool. """ - class cv_policy: """ Describes the rules used to discretize (compartmentalise) a cable cell morphology. """ - - def __add__(self, arg0: cv_policy) -> cv_policy: ... + def __add__(self, arg0: cv_policy) -> cv_policy: + ... def __init__(self, expression: str) -> None: """ A valid CV policy expression """ - - def __or__(self, arg0: cv_policy) -> cv_policy: ... - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __or__(self, arg0: cv_policy) -> cv_policy: + ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def domain(self) -> str: """ The domain on which the policy is applied. """ - class decor: """ Description of the decorations to be applied to a cable cell, that is the painted, placed and defaulted properties, mecahanisms, ion species etc. """ - - @typing.overload - def __init__(self) -> None: ... - @typing.overload - def __init__(self, arg0: decor) -> None: ... - def defaults( - self, - ) -> list[ - membrane_potential - | axial_resistivity - | temperature - | membrane_capacitance - | ion_diffusivity - | int_concentration - | ext_concentration - | reversal_potential - | reversal_potential_method - | cv_policy - ]: + @typing.overload + def __init__(self) -> None: + ... + @typing.overload + def __init__(self, arg0: decor) -> None: + ... + def defaults(self) -> list[membrane_potential | axial_resistivity | temperature | membrane_capacitance | ion_diffusivity | int_concentration | ext_concentration | reversal_potential | reversal_potential_method | cv_policy]: """ Return a view of all defaults. """ - @typing.overload def discretization(self, policy: cv_policy) -> decor: """ A cv_policy used to discretise the cell into compartments for simulation """ - @typing.overload def discretization(self, policy: str) -> decor: """ An s-expression string representing a cv_policy used to discretise the cell into compartments for simulation """ - @typing.overload def paint(self, region: str, mechanism: density) -> decor: """ Associate a density mechanism with a region. """ - @typing.overload def paint(self, region: str, mechanism: voltage_process) -> decor: """ Associate a voltage process mechanism with a region. """ - @typing.overload def paint(self, region: str, mechanism: scaled_mechanism) -> None: """ Associate a scaled density mechanism with a region. """ - @typing.overload - def paint( - self, - region: str, - Vm: units.quantity | tuple[units.quantity, str] | None = None, - cm: units.quantity | tuple[units.quantity, str] | None = None, - rL: units.quantity | tuple[units.quantity, str] | None = None, - tempK: units.quantity | tuple[units.quantity, str] | None = None, - ) -> decor: + def paint(self, region: str, Vm: units.quantity | tuple[units.quantity, str] | None = None, cm: units.quantity | tuple[units.quantity, str] | None = None, rL: units.quantity | tuple[units.quantity, str] | None = None, tempK: units.quantity | tuple[units.quantity, str] | None = None) -> decor: """ Set cable properties on a region. Set global default values for cable and cell properties. @@ -1068,18 +845,8 @@ class decor: * tempK: temperature [Kelvin]. Each value can be given as a plain quantity or a tuple of (quantity, 'scale') where scale is an iexpr. """ - @typing.overload - def paint( - self, - region: str, - *, - ion: str, - int_con: units.quantity | tuple[units.quantity, str] | None = None, - ext_con: units.quantity | tuple[units.quantity, str] | None = None, - rev_pot: units.quantity | tuple[units.quantity, str] | None = None, - diff: units.quantity | tuple[units.quantity, str] | None = None, - ) -> decor: + def paint(self, region: str, *, ion: str, int_con: units.quantity | tuple[units.quantity, str] | None = None, ext_con: units.quantity | tuple[units.quantity, str] | None = None, rev_pot: units.quantity | tuple[units.quantity, str] | None = None, diff: units.quantity | tuple[units.quantity, str] | None = None) -> decor: """ Set ion species properties conditions on a region. * int_con: initial internal concentration [mM]. @@ -1089,69 +856,35 @@ class decor: * diff: diffusivity [m^2/s]. Each value can be given as a plain quantity or a tuple of (quantity, 'scale') where scale is an iexpr. """ - - def paintings( - self, - ) -> list[ - tuple[ - str, - membrane_potential - | axial_resistivity - | temperature - | membrane_capacitance - | ion_diffusivity - | int_concentration - | ext_concentration - | reversal_potential - | density - | voltage_process - | scaled_mechanism, - ] - ]: + def paintings(self) -> list[tuple[str, membrane_potential | axial_resistivity | temperature | membrane_capacitance | ion_diffusivity | int_concentration | ext_concentration | reversal_potential | density | voltage_process | scaled_mechanism]]: """ Return a view of all painted items. """ - @typing.overload def place(self, locations: str, synapse: synapse, label: str) -> decor: """ Place one instance of 'synapse' on each location in 'locations'.The group of synapses has the label 'label', used for forming connections between cells. """ - @typing.overload def place(self, locations: str, junction: junction, label: str) -> decor: """ Place one instance of 'junction' on each location in 'locations'.The group of junctions has the label 'label', used for forming gap-junction connections between cells. """ - @typing.overload def place(self, locations: str, iclamp: iclamp, label: str) -> decor: """ Add a current stimulus at each location in locations.The group of current stimuli has the label 'label'. """ - @typing.overload def place(self, locations: str, detector: threshold_detector, label: str) -> decor: """ Add a voltage spike detector at each location in locations.The group of spike detectors has the label 'label', used for forming connections between cells. """ - - def placements( - self, - ) -> list[tuple[str, iclamp | threshold_detector | synapse | junction, str]]: + def placements(self) -> list[tuple[str, iclamp | threshold_detector | synapse | junction, str]]: """ Return a view of all placed items. """ - - def set_ion( - self, - ion: str, - int_con: units.quantity | None = None, - ext_con: units.quantity | None = None, - rev_pot: units.quantity | None = None, - method: typing.Any = None, - diff: units.quantity | None = None, - ) -> decor: + def set_ion(self, ion: str, int_con: units.quantity | None = None, ext_con: units.quantity | None = None, rev_pot: units.quantity | None = None, method: typing.Any = None, diff: units.quantity | None = None) -> decor: """ Set the cell-level properties of ion species named 'ion'. * int_con: initial internal concentration [mM]. @@ -1168,14 +901,7 @@ class decor: reversal potential is global for all compartments in the cell, and can't be overriden locally. """ - - def set_property( - self, - Vm: units.quantity | None = None, - cm: units.quantity | None = None, - rL: units.quantity | None = None, - tempK: units.quantity | None = None, - ) -> decor: + def set_property(self, Vm: units.quantity | None = None, cm: units.quantity | None = None, rL: units.quantity | None = None, tempK: units.quantity | None = None) -> decor: """ Set default values for cable and cell properties: * Vm: initial membrane voltage [mV]. @@ -1184,372 +910,331 @@ class decor: * tempK: temperature [Kelvin]. These values can be overridden on specific regions using the paint interface. """ - class density: """ For painting a density mechanism on a region. """ - @typing.overload - def __init__(self, arg0: str) -> None: ... + def __init__(self, arg0: str) -> None: + ... @typing.overload - def __init__(self, arg0: mechanism) -> None: ... + def __init__(self, arg0: mechanism) -> None: + ... @typing.overload - def __init__(self, arg0: str, arg1: dict[str, float]) -> None: ... + def __init__(self, arg0: str, arg1: dict[str, float]) -> None: + ... @typing.overload - def __init__(self, arg0: mechanism, arg1: dict[str, float]) -> None: ... + def __init__(self, arg0: mechanism, arg1: dict[str, float]) -> None: + ... @typing.overload - def __init__(self, arg0: str, **kwargs) -> None: ... + def __init__(self, arg0: str, **kwargs) -> None: + ... @typing.overload - def __init__(self, arg0: mechanism, **kwargs) -> None: ... - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __init__(self, arg0: mechanism, **kwargs) -> None: + ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def mech(self) -> mechanism: """ The underlying mechanism. """ - class domain_decomposition: """ The domain decomposition is responsible for describing the distribution of cells across cell groups and domains. """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... def gid_domain(self, gid: int) -> int: """ Query the domain id that a cell assigned to (using global identifier gid). """ - @property def domain_id(self) -> int: """ The index of the local domain. Always 0 for non-distributed models, and corresponds to the MPI rank for distributed runs. """ - @property def groups(self) -> list[group_description]: """ Descriptions of the cell groups on the local domain. """ - @property def num_domains(self) -> int: """ Number of domains that the model is distributed over. """ - @property def num_global_cells(self) -> int: """ Total number of cells in the global model (sum of num_local_cells over all domains). """ - @property def num_groups(self) -> int: """ Total number of cell groups in the local domain. """ - @property def num_local_cells(self) -> int: """ Total number of cells in the local domain. """ - class event_generator: - def __init__( - self, target: cell_local_label, weight: float, sched: schedule_base - ) -> None: + def __init__(self, target: cell_local_label, weight: float, sched: schedule_base) -> None: """ Construct an event generator with arguments: target: The target synapse label and selection policy. weight: The weight of events to deliver. sched: A schedule of the events. """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def target(self) -> cell_local_label: """ The target synapse (gid, local_id). """ - @target.setter - def target(self, arg0: cell_local_label) -> None: ... + def target(self, arg0: cell_local_label) -> None: + ... @property def weight(self) -> float: """ The weight of events to deliver. """ - @weight.setter - def weight(self, arg0: float) -> None: ... - + def weight(self, arg0: float) -> None: + ... class explicit_schedule(schedule_base): """ Describes an explicit schedule at a predetermined (sorted) sequence of times. """ - @typing.overload def __init__(self) -> None: """ Construct an empty explicit schedule. """ - @typing.overload def __init__(self, times: list[units.quantity]) -> None: """ Construct an explicit schedule with argument: times: A list of times [ms], [] by default. """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... def events(self, arg0: float, arg1: float) -> list[float]: """ A view of monotonically increasing time values in the half-open interval [t0, t1) in [ms]. """ - @property def times_ms(self) -> list[float]: """ A list of times [ms]. """ - @times_ms.setter - def times_ms(self, arg1: list[float]) -> None: ... - + def times_ms(self, arg1: list[float]) -> None: + ... class ext_concentration: """ Setting the initial external ion concentration. """ - - def __init__(self, arg0: str, arg1: units.quantity) -> None: ... - def __repr__(self) -> str: ... - + def __init__(self, arg0: str, arg1: units.quantity) -> None: + ... + def __repr__(self) -> str: + ... class extent: """ A potentially empty region on a morphology. """ - class gap_junction_connection: """ Describes a gap junction between two gap junction sites. """ - - def __init__( - self, peer: cell_global_label, local: cell_local_label, weight: float - ) -> None: + def __init__(self, peer: cell_global_label, local: cell_local_label, weight: float) -> None: """ Construct a gap junction connection with arguments: peer: remote half of the gap junction connection. local: local half of the gap junction connection. weight: Gap junction connection weight [unit-less]. """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def local(self) -> cell_local_label: """ Local label of the gap junction connection. """ - @local.setter - def local(self, arg0: cell_local_label) -> None: ... + def local(self, arg0: cell_local_label) -> None: + ... @property def peer(self) -> cell_global_label: """ Remote gid and label of the gap junction connection. """ - @peer.setter - def peer(self, arg0: cell_global_label) -> None: ... + def peer(self, arg0: cell_global_label) -> None: + ... @property def weight(self) -> float: """ Gap junction connection weight [unit-less]. """ - @weight.setter - def weight(self, arg0: float) -> None: ... - + def weight(self, arg0: float) -> None: + ... class group_description: """ The indexes of a set of cells of the same kind that are grouped together in a cell group. """ - def __init__(self, kind: cell_kind, gids: list[int], backend: backend) -> None: """ Construct a group description with cell kind, list of gids, and backend kind. """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def backend(self) -> backend: """ The hardware backend on which the cell group will run. """ - @property def gids(self) -> list[int]: """ The list of gids of the cells in the group. """ - @property def kind(self) -> cell_kind: """ The type of cell in the cell group. """ - class iclamp: """ A current clamp for injecting a DC or fixed frequency current governed by a piecewise linear envelope. """ - @typing.overload - def __init__( - self, - tstart: units.quantity, - duration: units.quantity, - current: units.quantity, - *, - frequency: units.quantity = ..., - phase: units.quantity = ..., - ) -> None: + def __init__(self, tstart: units.quantity, duration: units.quantity, current: units.quantity, *, frequency: units.quantity = ..., phase: units.quantity = ...) -> None: """ Construct finite duration current clamp, constant amplitude """ - @typing.overload - def __init__( - self, - current: units.quantity, - *, - frequency: units.quantity = ..., - phase: units.quantity = ..., - ) -> None: + def __init__(self, current: units.quantity, *, frequency: units.quantity = ..., phase: units.quantity = ...) -> None: """ Construct constant amplitude current clamp """ - @typing.overload - def __init__( - self, - envelope: list[tuple[units.quantity, units.quantity]], - *, - frequency: units.quantity = ..., - phase: units.quantity = ..., - ) -> None: + def __init__(self, envelope: list[tuple[units.quantity, units.quantity]], *, frequency: units.quantity = ..., phase: units.quantity = ...) -> None: """ Construct current clamp according to (time, amplitude) linear envelope """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def envelope(self) -> list[tuple[float, float]]: """ List of (time [ms], amplitude [nA]) points comprising the piecewise linear envelope """ - @property def frequency(self) -> float: """ Oscillation frequency (kHz), zero implies DC stimulus. """ - @property def phase(self) -> float: """ Oscillation initial phase (rad) """ - class int_concentration: """ Setting the initial internal ion concentration. """ - - def __init__(self, arg0: str, arg1: units.quantity) -> None: ... - def __repr__(self) -> str: ... - + def __init__(self, arg0: str, arg1: units.quantity) -> None: + ... + def __repr__(self) -> str: + ... class ion_data: @property def charge(self) -> int: """ Valence. """ - @property def diffusivity(self) -> float | None: """ Diffusivity. """ - @property def external_concentration(self) -> float | None: """ External concentration. """ - @property def internal_concentration(self) -> float | None: """ Internal concentration. """ - @property def reversal_concentration(self) -> float | None: """ Reversal potential. """ - @property def reversal_potential(self) -> float | None: """ Reversal potential. """ - @property def reversal_potential_method(self) -> str: """ Reversal potential method. """ - class ion_dependency: """ Information about a mechanism's dependence on an ion species. """ - - def __init__(self, arg0: ion_dependency) -> None: ... - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __init__(self, arg0: ion_dependency) -> None: + ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property - def read_rev_pot(self) -> bool: ... + def read_rev_pot(self) -> bool: + ... @property - def write_ext_con(self) -> bool: ... + def write_ext_con(self) -> bool: + ... @property - def write_int_con(self) -> bool: ... + def write_int_con(self) -> bool: + ... @property - def write_rev_pot(self) -> bool: ... - + def write_rev_pot(self) -> bool: + ... class ion_diffusivity: """ Setting the ion diffusivity. """ - - def __init__(self, arg0: str, arg1: units.quantity) -> None: ... - def __repr__(self) -> str: ... - + def __init__(self, arg0: str, arg1: units.quantity) -> None: + ... + def __repr__(self) -> str: + ... class ion_settings: pass - class isometry: @staticmethod @typing.overload @@ -1557,122 +1242,121 @@ class isometry: """ Construct a rotation isometry of angle theta about the axis in direction (x, y, z). """ - @staticmethod @typing.overload def rotate(theta: float, axis: tuple) -> isometry: """ Construct a rotation isometry of angle theta about the given axis in the direction described by a tuple. """ - @staticmethod @typing.overload def translate(x: float, y: float, z: float) -> isometry: """ Construct a translation isometry from displacements x, y, and z. """ - @staticmethod @typing.overload def translate(arg0: tuple) -> isometry: """ Construct a translation isometry from the first three components of a tuple. """ - @staticmethod @typing.overload def translate(arg0: mpoint) -> isometry: """ Construct a translation isometry from the x, y, and z components of an mpoint. """ - @typing.overload def __call__(self, arg0: mpoint) -> mpoint: """ Apply isometry to mpoint argument. """ - @typing.overload def __call__(self, arg0: tuple) -> tuple: """ Apply isometry to first three components of tuple argument. """ - def __init__(self) -> None: """ Construct a trivial isometry. """ - - def __mul__(self, arg0: isometry) -> isometry: ... - + def __mul__(self, arg0: isometry) -> isometry: + ... class junction: """ For placing a gap-junction mechanism on a locset. """ - @typing.overload - def __init__(self, arg0: str) -> None: ... + def __init__(self, arg0: str) -> None: + ... @typing.overload - def __init__(self, arg0: mechanism) -> None: ... + def __init__(self, arg0: mechanism) -> None: + ... @typing.overload - def __init__(self, arg0: str, arg1: dict[str, float]) -> None: ... + def __init__(self, arg0: str, arg1: dict[str, float]) -> None: + ... @typing.overload - def __init__(self, arg0: str, **kwargs) -> None: ... + def __init__(self, arg0: str, **kwargs) -> None: + ... @typing.overload - def __init__(self, arg0: mechanism, arg1: dict[str, float]) -> None: ... + def __init__(self, arg0: mechanism, arg1: dict[str, float]) -> None: + ... @typing.overload - def __init__(self, arg0: mechanism, **kwargs) -> None: ... - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __init__(self, arg0: mechanism, **kwargs) -> None: + ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def mech(self) -> mechanism: """ The underlying mechanism. """ - class label_dict: """ A dictionary of labelled region and locset definitions, with a unique label assigned to each definition. """ - @staticmethod def append(*args, **kwargs) -> label_dict: """ Import the entries of a another label dictionary with an optional prefix. """ - - def __contains__(self, arg0: str) -> bool: ... - def __getitem__(self, arg0: str) -> str: ... + def __contains__(self, arg0: str) -> bool: + ... + def __getitem__(self, arg0: str) -> str: + ... @typing.overload def __init__(self) -> None: """ Create an empty label dictionary. """ - @typing.overload def __init__(self, arg0: dict[str, str]) -> None: """ Initialize a label dictionary from a dictionary with string labels as keys, and corresponding definitions as strings. """ - @typing.overload def __init__(self, arg0: label_dict) -> None: """ Initialize a label dictionary from another one """ - @typing.overload def __init__(self, arg0: typing.Iterator) -> None: """ Initialize a label dictionary from an iterable of key, definition pairs """ - - def __iter__(self) -> typing.Iterator: ... - def __len__(self) -> int: ... - def __repr__(self) -> str: ... - def __setitem__(self, arg0: str, arg1: str) -> None: ... - def __str__(self) -> str: ... + def __iter__(self) -> typing.Iterator: + ... + def __len__(self) -> int: + ... + def __repr__(self) -> str: + ... + def __setitem__(self, arg0: str, arg1: str) -> None: + ... + def __str__(self) -> str: + ... def add_swc_tags(self) -> label_dict: """ Add standard SWC tagged regions. @@ -1681,44 +1365,31 @@ class label_dict: - dend: (tag 3) - apic: (tag 4) """ - - def items(self) -> typing.Iterator: ... - def keys(self) -> typing.Iterator: ... + def items(self) -> typing.Iterator: + ... + def keys(self) -> typing.Iterator: + ... def update(self, other: label_dict) -> label_dict: """ The label_dict to be importedImport the entries of a another label dictionary. """ - - def values(self) -> typing.Iterator: ... + def values(self) -> typing.Iterator: + ... @property def locsets(self) -> list[str]: """ The locset definitions. """ - @property def regions(self) -> list[str]: """ The region definitions. """ - class lif_cell: """ A leaky integrate-and-fire cell. """ - - def __init__( - self, - source_label: str, - target_label: str, - *, - tau_m: units.quantity | None = None, - V_th: units.quantity | None = None, - C_m: units.quantity | None = None, - E_L: units.quantity | None = None, - V_m: units.quantity | None = None, - t_ref: units.quantity | None = None, - ) -> None: + def __init__(self, source_label: str, target_label: str, *, tau_m: units.quantity | None = None, V_th: units.quantity | None = None, C_m: units.quantity | None = None, E_L: units.quantity | None = None, V_m: units.quantity | None = None, t_ref: units.quantity | None = None) -> None: """ Construct a lif cell with one source labeled 'source_label', and one target labeled 'target_label'.Can optionally take physical parameters: * tau_m: Membrane potential decaying constant [ms]. @@ -1728,151 +1399,143 @@ class lif_cell: * V_m: Initial value of the Membrane potential [mV]. * t_ref: Refractory period [ms]. """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def C_m(self) -> units.quantity: """ Membrane capacitance [pF]. """ - @C_m.setter - def C_m(self, arg0: units.quantity) -> None: ... + def C_m(self, arg0: units.quantity) -> None: + ... @property def E_L(self) -> units.quantity: """ Resting potential [mV]. """ - @E_L.setter - def E_L(self, arg0: units.quantity) -> None: ... + def E_L(self, arg0: units.quantity) -> None: + ... @property def E_R(self) -> units.quantity: """ Reset potential [mV]. """ - @E_R.setter - def E_R(self, arg0: units.quantity) -> None: ... + def E_R(self, arg0: units.quantity) -> None: + ... @property def V_m(self) -> units.quantity: """ Initial value of the Membrane potential [mV]. """ - @V_m.setter - def V_m(self, arg0: units.quantity) -> None: ... + def V_m(self, arg0: units.quantity) -> None: + ... @property def V_th(self) -> units.quantity: """ Firing threshold [mV]. """ - @V_th.setter - def V_th(self, arg0: units.quantity) -> None: ... + def V_th(self, arg0: units.quantity) -> None: + ... @property def source(self) -> str: """ Label of the single build-in source on the cell. """ - @source.setter - def source(self, arg0: str) -> None: ... + def source(self, arg0: str) -> None: + ... @property def t_ref(self) -> units.quantity: """ Refractory period [ms]. """ - @t_ref.setter - def t_ref(self, arg0: units.quantity) -> None: ... + def t_ref(self, arg0: units.quantity) -> None: + ... @property def target(self) -> str: """ Label of the single build-in target on the cell. """ - @target.setter - def target(self, arg0: str) -> None: ... + def target(self, arg0: str) -> None: + ... @property def tau_m(self) -> units.quantity: """ Membrane potential decaying constant [ms]. """ - @tau_m.setter - def tau_m(self, arg0: units.quantity) -> None: ... - + def tau_m(self, arg0: units.quantity) -> None: + ... class lif_probe_metadata: """ Probe metadata associated with a LIF cell probe. """ - class loaded_morphology: """ The morphology and label dictionary meta-data loaded from file. """ - @property def labels(self) -> label_dict: """ Any labels defined by the loaded file. """ - @property def metadata(self) -> swc_metadata | asc_metadata | nml_metadata: """ File type specific metadata. """ - @property def morphology(self) -> morphology: """ The cable cell morphology. """ - @property def segment_tree(self) -> segment_tree: """ The raw segment tree. """ - class location: """ A location on a cable cell. """ - __hash__: typing.ClassVar[None] = None - def __eq__(self, arg0: location) -> bool: ... + def __eq__(self, arg0: location) -> bool: + ... def __init__(self, branch: int, pos: float) -> None: """ Construct a location specification holding: branch: The id of the branch. pos: The relative position (from 0., proximal, to 1., distal) on the branch. """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def branch(self) -> int: """ The id of the branch. """ - @property def pos(self) -> float: """ The relative position on the branch (∈ [0.,1.], where 0. means proximal and 1. distal). """ - class mechanism: @typing.overload def __init__(self, name: str) -> None: """ The name of the mechanism """ - @typing.overload def __init__(self, name: str, params: dict[str, float]) -> None: """ @@ -1881,11 +1544,10 @@ class mechanism: will create parameters for the 'expsyn' mechanism, with the provided value for 'tau' overrides the default. If a parameter is not set, the default (as defined in NMODL) is used. - + Example overriding a global parameter: m = arbor.mechanism('nernst/R=8.3145,F=96485') """ - @typing.overload def __init__(self, name: str, **kwargs) -> None: """ @@ -1894,310 +1556,306 @@ class mechanism: will create parameters for the 'expsyn' mechanism, with the provided value for 'tau' overrides the default. If a parameter is not set, the default (as defined in NMODL) is used. - + Example overriding a global parameter: m = arbor.mechanism('nernst/R=8.3145,F=96485') """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... def set(self, name: str, value: float) -> None: """ Set parameter value. """ - @property def name(self) -> str: """ The name of the mechanism. """ - @property def values(self) -> dict[str, float]: """ A dictionary of parameter values with parameter name as key. """ - class mechanism_field: """ Basic information about a mechanism field. """ - - def __init__(self, arg0: mechanism_field) -> None: ... - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __init__(self, arg0: mechanism_field) -> None: + ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property - def default(self) -> float: ... + def default(self) -> float: + ... @property - def max(self) -> float: ... + def max(self) -> float: + ... @property - def min(self) -> float: ... + def min(self) -> float: + ... @property - def units(self) -> str: ... - + def units(self) -> str: + ... class mechanism_info: """ Meta data about a mechanism's fields and ion dependendencies. """ - - def __init__(self, arg0: mechanism_info) -> None: ... - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __init__(self, arg0: mechanism_info) -> None: + ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def globals(self) -> dict[str, mechanism_field]: """ Global fields have one value common to an instance of a mechanism, are constant in time and set at instantiation. """ - @property def ions(self) -> dict[str, ion_dependency]: """ Ion dependencies. """ - @property def kind(self) -> str: """ String representation of the kind of the mechanism. """ - @property def linear(self) -> bool: """ True if a synapse mechanism has linear current contributions so that multiple instances on the same compartment can be coalesced. """ - @property def parameters(self) -> dict[str, mechanism_field]: """ Parameter fields may vary across the extent of a mechanism, but are constant in time and set at instantiation. """ - @property def post_events(self) -> bool: """ True if a synapse mechanism has a `POST_EVENT` procedure defined. """ - @property def state(self) -> dict[str, mechanism_field]: """ State fields vary in time and across the extent of a mechanism, and potentially can be sampled at run-time. """ - class membrane_capacitance: """ Setting the membrane capacitance. """ - - def __init__(self, arg0: units.quantity) -> None: ... - def __repr__(self) -> str: ... - + def __init__(self, arg0: units.quantity) -> None: + ... + def __repr__(self) -> str: + ... class membrane_potential: """ Setting the initial membrane voltage. """ - - def __init__(self, arg0: units.quantity) -> None: ... - def __repr__(self) -> str: ... - + def __init__(self, arg0: units.quantity) -> None: + ... + def __repr__(self) -> str: + ... class meter_manager: """ Manage metering by setting checkpoints and starting the timing region. """ - - def __init__(self) -> None: ... - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __init__(self) -> None: + ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... def checkpoint(self, name: str, context: context) -> None: """ Create a new checkpoint. Records the time since the last checkpoint(or the call to start if no previous checkpoints exist),and restarts the timer for the next checkpoint. """ - def start(self, context: context) -> None: """ Start the metering. Records a time stamp, that marks the start of the first checkpoint timing region. """ - @property def checkpoint_names(self) -> list[str]: """ A list of all metering checkpoint names. """ - @property def times(self) -> list[float]: """ A list of all metering times. """ - class meter_report: """ Summarises the performance meter results, used to print a report to screen or file. If a distributed context is used, the report will contain a summary of results from all MPI ranks. """ - - def __init__(self, manager: meter_manager, context: context) -> None: ... - def __repr__(self) -> str: ... - def __str__(self) -> str: ... - + def __init__(self, manager: meter_manager, context: context) -> None: + ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... class morphology: """ A cell morphology. """ - + def __init__(self, arg0: segment_tree) -> None: + ... + def __str__(self) -> str: + ... + def branch_children(self, i: int) -> list[int]: + """ + The child branches of branch i. + """ + def branch_parent(self, i: int) -> int: + """ + The parent branch of branch i. + """ + def branch_segments(self, i: int) -> list[msegment]: + """ + A list of the segments in branch i, ordered from proximal to distal ends of the branch. + """ + def to_segment_tree(self) -> segment_tree: + """ + Convert this morphology to a segment_tree. + """ + @property + def empty(self) -> bool: + """ + Whether the morphology is empty. + """ + @property + def num_branches(self) -> int: + """ + The number of branches in the morphology. + """ class morphology_provider: def __init__(self, morphology: morphology) -> None: """ Construct a morphology provider. """ - def reify_locset(self, arg0: str) -> list[location]: """ Turn a locset into a list of locations. """ - def reify_region(self, arg0: str) -> extent: """ Turn a region into an extent. """ - class mpoint: __hash__: typing.ClassVar[None] = None - def __eq__(self, arg0: mpoint) -> bool: ... + def __eq__(self, arg0: mpoint) -> bool: + ... @typing.overload def __init__(self, x: float, y: float, z: float, radius: float) -> None: """ Create an mpoint object from parameters x, y, z, and radius, specified in µm. """ - @typing.overload def __init__(self, arg0: tuple[float, float, float, float]) -> None: """ Create an mpoint object from a tuple (x, y, z, radius), specified in µm. """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def radius(self) -> float: """ Radius of cable at sample location centred at coordinates [μm]. """ - @property def x(self) -> float: """ X coordinate [μm]. """ - @property def y(self) -> float: """ Y coordinate [μm]. """ - @property def z(self) -> float: """ Z coordinate [μm]. """ - class msegment: @property def dist(self) -> mpoint: """ the location and radius of the distal end. """ - @property def prox(self) -> mpoint: """ the location and radius of the proximal end. """ - @property def tag(self) -> int: """ tag meta-data. """ - class neuroml: def __init__(self, arg0: typing.Any) -> None: """ Construct NML morphology from filename or stream. """ - def cell_ids(self) -> list[str]: """ Query top-level cells. """ - - def cell_morphology( - self, cell_id: str, allow_spherical_root: bool = False - ) -> loaded_morphology | None: + def cell_morphology(self, cell_id: str, allow_spherical_root: bool = False) -> loaded_morphology | None: """ Retrieve nml_morph_data associated with cell_id. """ - - def morphology( - self, morph_id: str, allow_spherical_root: bool = False - ) -> loaded_morphology | None: + def morphology(self, morph_id: str, allow_spherical_root: bool = False) -> loaded_morphology | None: """ Retrieve top-level nml_morph_data associated with morph_id. """ - def morphology_ids(self) -> list[str]: """ Query top-level standalone morphologies. """ - class nml_metadata: def groups(self) -> label_dict: """ Label dictionary containing one region expression for each segmentGroup id. """ - def named_segments(self) -> label_dict: """ Label dictionary containing one region expression for each name applied to one or more segments. """ - def segments(self) -> label_dict: """ Label dictionary containing one region expression for each segment id. """ - @property def cell_id(self) -> str | None: """ Cell id, or empty if morphology was taken from a top-level <morphology> element. """ - @property def group_segments(self) -> dict[str, list[int]]: """ Map from segmentGroup ids to their corresponding segment ids. """ - @property def id(self) -> str: """ Morphology id. """ - class partition_hint: """ Provide a hint on how the cell groups should be partitioned. """ - max_size: typing.ClassVar[int] = 18446744073709551615 - def __init__( - self, - cpu_group_size: int = 1, - gpu_group_size: int = 18446744073709551615, - prefer_gpu: bool = True, - ) -> None: + def __init__(self, cpu_group_size: int = 1, gpu_group_size: int = 18446744073709551615, prefer_gpu: bool = True) -> None: """ Construct a partition hint with arguments: cpu_group_size: The size of cell group assigned to CPU, each cell in its own group by default. @@ -2206,78 +1864,64 @@ class partition_hint: Must be positive, else set to default value. prefer_gpu: Whether GPU is preferred, True by default. """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def cpu_group_size(self) -> int: """ The size of cell group assigned to CPU. """ - @cpu_group_size.setter - def cpu_group_size(self, arg0: int) -> None: ... + def cpu_group_size(self, arg0: int) -> None: + ... @property def gpu_group_size(self) -> int: """ The size of cell group assigned to GPU. """ - @gpu_group_size.setter - def gpu_group_size(self, arg0: int) -> None: ... + def gpu_group_size(self, arg0: int) -> None: + ... @property def prefer_gpu(self) -> bool: """ Whether GPU usage is preferred. """ - @prefer_gpu.setter - def prefer_gpu(self, arg0: bool) -> None: ... - + def prefer_gpu(self, arg0: bool) -> None: + ... class place_pwlin: def __init__(self, morphology: morphology, isometry: isometry = ...) -> None: """ Construct a piecewise-linear placement object from the given morphology and optional isometry. """ - def all_at(self, location: location) -> list[mpoint]: """ Return list of all possible interpolated mpoints corresponding to the location argument. """ - def all_segments(self, arg0: list[cable]) -> list[msegment]: """ Return maximal list of non-overlapping full or partial msegments whose union is coterminous with the extent of the given list of cables. """ - def at(self, location: location) -> mpoint: """ Return an interpolated mpoint corresponding to the location argument. """ - def closest(self, arg0: float, arg1: float, arg2: float) -> tuple: """ Find the location on the morphology that is closest to a 3d point. Returns the location and its distance from the point. """ - def segments(self, arg0: list[cable]) -> list[msegment]: """ Return minimal list of full or partial msegments whose union is coterminous with the extent of the given list of cables. """ - class poisson_schedule(schedule_base): """ Describes a schedule according to a Poisson process within the interval [tstart, tstop). """ - - def __init__( - self, - freq: units.quantity, - *, - tstart: units.quantity = ..., - seed: int = 0, - tstop: units.quantity | None = None, - ) -> None: + def __init__(self, freq: units.quantity, *, tstart: units.quantity = ..., seed: int = 0, tstop: units.quantity | None = None) -> None: """ Construct a Poisson schedule with arguments: tstart: The delivery time of the first event in the sequence [ms], 0 by default. @@ -2285,64 +1929,56 @@ class poisson_schedule(schedule_base): seed: The seed for the random number generator, 0 by default. tstop: No events delivered after this time [ms], None by default. """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... def events(self, arg0: units.quantity, arg1: units.quantity) -> list[float]: """ A view of monotonically increasing time values in the half-open interval [t0, t1). """ - @property def freq(self) -> units.quantity: """ The expected frequency [kHz]. """ - @freq.setter - def freq(self, arg1: units.quantity) -> None: ... + def freq(self, arg1: units.quantity) -> None: + ... @property def seed(self) -> int: """ The seed for the random number generator. """ - @seed.setter - def seed(self, arg0: int) -> None: ... + def seed(self, arg0: int) -> None: + ... @property def tstart(self) -> units.quantity: """ The delivery time of the first event in the sequence [ms]. """ - @tstart.setter - def tstart(self, arg1: units.quantity) -> None: ... + def tstart(self, arg1: units.quantity) -> None: + ... @property def tstop(self) -> units.quantity: """ No events delivered after this time [ms]. """ - @tstop.setter - def tstop(self, arg1: units.quantity) -> None: ... - + def tstop(self, arg1: units.quantity) -> None: + ... class probe: - def __repr__(self) -> str: ... - def __str__(self) -> str: ... - + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... class proc_allocation: """ Enumerates the computational resources on a node to be used for simulation. """ - - def __init__( - self, - *, - threads: int = 1, - gpu_id: typing.Any = None, - bind_procs: bool = False, - bind_threads: bool = False, - ) -> None: + def __init__(self, *, threads: int = 1, gpu_id: typing.Any = None, bind_procs: bool = False, bind_threads: bool = False) -> None: """ Construct an allocation with arguments: threads: The number of threads available locally for execution. Must be set to 1 at minimum. 1 by default. @@ -2350,482 +1986,424 @@ class proc_allocation: bind_procs: Create process binding mask. bind_threads: Create thread binding mask. """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def bind_procs(self) -> bool: """ Try to bind MPI procs? """ - @bind_procs.setter - def bind_procs(self, arg1: bool) -> None: ... + def bind_procs(self, arg1: bool) -> None: + ... @property def bind_threads(self) -> bool: """ Try to bind threads? """ - @bind_threads.setter - def bind_threads(self, arg1: bool) -> None: ... + def bind_threads(self, arg1: bool) -> None: + ... @property def gpu_id(self) -> int | None: """ The identifier of the GPU to use. Corresponds to the integer parameter used to identify GPUs in CUDA API calls. """ - @gpu_id.setter - def gpu_id(self, arg1: typing.Any) -> None: ... + def gpu_id(self, arg1: typing.Any) -> None: + ... @property def has_gpu(self) -> bool: """ Whether a GPU is being used (True/False). """ - @property def threads(self) -> int: """ The number of threads available locally for execution. """ - @threads.setter - def threads(self, arg1: int) -> None: ... - + def threads(self, arg1: int) -> None: + ... class recipe: """ A description of a model, describing the cells and the network via a cell-centric interface. """ - - def __init__(self) -> None: ... - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __init__(self) -> None: + ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... def cell_description(self, gid: int) -> typing.Any: """ High level description of the cell with global identifier gid. """ - def cell_kind(self, gid: int) -> cell_kind: """ The kind of cell with global identifier gid. """ - def connections_on(self, gid: int) -> list[connection]: """ A list of all the incoming connections to gid, [] by default. """ - def event_generators(self, gid: int) -> list[typing.Any]: """ A list of all the event generators that are attached to gid, [] by default. """ - def external_connections_on(self, gid: int) -> list[connection]: """ A list of all the incoming connections from _remote_ locations to gid, [] by default. """ - def gap_junctions_on(self, gid: int) -> list[gap_junction_connection]: """ A list of the gap junctions connected to gid, [] by default. """ - def global_properties(self, kind: cell_kind) -> typing.Any: """ The default properties applied to all cells of type 'kind' in the model. """ - def num_cells(self) -> int: """ The number of cells in the model. """ - def probes(self, gid: int) -> list[probe]: """ The probes to allow monitoring. """ - class regular_schedule(schedule_base): """ Describes a regular schedule with multiples of dt within the interval [tstart, tstop). """ - @typing.overload - def __init__( - self, - tstart: units.quantity, - dt: units.quantity, - tstop: units.quantity | None = None, - ) -> None: + def __init__(self, tstart: units.quantity, dt: units.quantity, tstop: units.quantity | None = None) -> None: """ Construct a regular schedule with arguments: tstart: The delivery time of the first event in the sequence [ms]. dt: The interval between time points [ms]. tstop: No events delivered after this time [ms], None by default. """ - @typing.overload def __init__(self, dt: units.quantity) -> None: """ Construct a regular schedule, starting from t = 0 and never terminating, with arguments: dt: The interval between time points [ms]. """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... def events(self, arg0: float, arg1: float) -> list[float]: """ A view of monotonically increasing time values in the half-open interval [t0, t1). """ - @property def dt(self) -> units.quantity: """ The interval between time points [ms]. """ - @dt.setter - def dt(self, arg1: units.quantity) -> None: ... + def dt(self, arg1: units.quantity) -> None: + ... @property def tstart(self) -> units.quantity: """ The delivery time of the first event in the sequence [ms]. """ - @tstart.setter - def tstart(self, arg1: units.quantity) -> None: ... + def tstart(self, arg1: units.quantity) -> None: + ... @property def tstop(self) -> units.quantity | None: """ No events delivered after this time [ms]. """ - @tstop.setter - def tstop(self, arg1: units.quantity | None) -> None: ... - + def tstop(self, arg1: units.quantity | None) -> None: + ... class reversal_potential: """ Setting the initial reversal potential. """ - - def __init__(self, arg0: str, arg1: units.quantity) -> None: ... - def __repr__(self) -> str: ... - + def __init__(self, arg0: str, arg1: units.quantity) -> None: + ... + def __repr__(self) -> str: + ... class reversal_potential_method: """ Describes the mechanism used to compute eX for ion X. """ - - def __init__(self, arg0: str, arg1: mechanism) -> None: ... - def __repr__(self) -> str: ... - + def __init__(self, arg0: str, arg1: mechanism) -> None: + ... + def __repr__(self) -> str: + ... class scaled_mechanism: """ For painting a scaled density mechanism on a region. """ - @typing.overload - def __init__(self, arg0: density) -> None: ... + def __init__(self, arg0: density) -> None: + ... @typing.overload - def __init__(self, arg0: density, arg1: dict[str, str]) -> None: ... + def __init__(self, arg0: density, arg1: dict[str, str]) -> None: + ... @typing.overload - def __init__(self, arg0: density, **kwargs) -> None: ... - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __init__(self, arg0: density, **kwargs) -> None: + ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... def scale(self, name: str, ex: str) -> scaled_mechanism: """ Add a scaling expression to a parameter. """ - class schedule_base: """ Schedule abstract base class. """ - class segment_tree: - def __init__(self) -> None: ... - def __str__(self) -> str: ... + def __init__(self) -> None: + ... + def __str__(self) -> str: + ... @typing.overload def append(self, parent: int, prox: mpoint, dist: mpoint, tag: int) -> int: """ Append a segment to the tree. """ - @typing.overload def append(self, parent: int, dist: mpoint, tag: int) -> int: """ Append a segment to the tree. """ - @typing.overload - def append( - self, parent: int, x: float, y: float, z: float, radius: float, tag: int - ) -> int: + def append(self, parent: int, x: float, y: float, z: float, radius: float, tag: int) -> int: """ Append a segment to the tree, using the distal location of the parent segment as the proximal end. """ - def apply_isometry(self, arg0: isometry) -> segment_tree: """ Apply an isometry to all segments in the tree. """ - def equivalent(self, arg0: segment_tree) -> bool: """ Two trees are equivalent, but not neccessarily identical, ie they have the same segments and structure. """ - def is_fork(self, i: int) -> bool: """ True if segment has more than one child. """ - def is_root(self, i: int) -> bool: """ True if segment has no parent. """ - def is_terminal(self, i: int) -> bool: """ True if segment has no children. """ - def join_at(self, arg0: int, arg1: segment_tree) -> segment_tree: """ Join two subtrees at a given id, such that said id becomes the parent of the inserted sub-tree. """ - - def reserve(self, arg0: int) -> None: ... + def reserve(self, arg0: int) -> None: + ... def split_at(self, arg0: int) -> tuple[segment_tree, segment_tree]: """ Split into a pair of trees at the given id, such that one tree is the subtree rooted at id and the other is the original tree without said subtree. """ - def tag_roots(self, arg0: int) -> list[int]: """ Get roots of tag region of this segment tree. """ - @property def empty(self) -> bool: """ Indicates whether the tree is empty (i.e. whether it has size 0) """ - @property def parents(self) -> list[int]: """ A list with the parent index of each segment. """ - @property def segments(self) -> list[msegment]: """ A list of the segments. """ - @property def size(self) -> int: """ The number of segments in the tree. """ - class selection_policy: """ Enumeration used to identify a selection policy, used by the model for selecting one of possibly multiple locations on the cell associated with a labeled item. - + Members: - + round_robin : Iterate round-robin over all possible locations. - + round_robin_halt : Halts at the current location until the round_robin policy is called (again). - + univalent : Assert that there is only one possible location associated with a labeled item on the cell. The model throws an exception if the assertion fails. """ - - __members__: typing.ClassVar[ - dict[str, selection_policy] - ] # value = {'round_robin': <selection_policy.round_robin: 0>, 'round_robin_halt': <selection_policy.round_robin_halt: 1>, 'univalent': <selection_policy.univalent: 2>} - round_robin: typing.ClassVar[ - selection_policy - ] # value = <selection_policy.round_robin: 0> - round_robin_halt: typing.ClassVar[ - selection_policy - ] # value = <selection_policy.round_robin_halt: 1> - univalent: typing.ClassVar[ - selection_policy - ] # value = <selection_policy.univalent: 2> - def __eq__(self, other: typing.Any) -> bool: ... - def __getstate__(self) -> int: ... - def __hash__(self) -> int: ... - def __index__(self) -> int: ... - def __init__(self, value: int) -> None: ... - def __int__(self) -> int: ... - def __ne__(self, other: typing.Any) -> bool: ... - def __repr__(self) -> str: ... - def __setstate__(self, state: int) -> None: ... - def __str__(self) -> str: ... - @property - def name(self) -> str: ... - @property - def value(self) -> int: ... - + __members__: typing.ClassVar[dict[str, selection_policy]] # value = {'round_robin': <selection_policy.round_robin: 0>, 'round_robin_halt': <selection_policy.round_robin_halt: 1>, 'univalent': <selection_policy.univalent: 2>} + round_robin: typing.ClassVar[selection_policy] # value = <selection_policy.round_robin: 0> + round_robin_halt: typing.ClassVar[selection_policy] # value = <selection_policy.round_robin_halt: 1> + univalent: typing.ClassVar[selection_policy] # value = <selection_policy.univalent: 2> + def __eq__(self, other: typing.Any) -> bool: + ... + def __getstate__(self) -> int: + ... + def __hash__(self) -> int: + ... + def __index__(self) -> int: + ... + def __init__(self, value: int) -> None: + ... + def __int__(self) -> int: + ... + def __ne__(self, other: typing.Any) -> bool: + ... + def __repr__(self) -> str: + ... + def __setstate__(self, state: int) -> None: + ... + def __str__(self) -> str: + ... + @property + def name(self) -> str: + ... + @property + def value(self) -> int: + ... class simulation: """ The executable form of a model. A simulation is constructed from a recipe, and then used to update and monitor model state. """ - @staticmethod - def deserialize(*args, **kwargs) -> None: ... - def __init__( - self, - recipe: recipe, - context: context | None = None, - domains: domain_decomposition | None = None, - seed: int = 0, - ) -> None: + def deserialize(*args, **kwargs) -> None: + ... + def __init__(self, recipe: recipe, context: context | None = None, domains: domain_decomposition | None = None, seed: int = 0) -> None: """ Initialize the model described by a recipe, with cells and network distributed according to the domain decomposition and computational resources described by a context. Initialize PRNG using seed """ - def clear_samplers(self) -> None: """ Clearing spike and sample information. restoring memory """ - @typing.overload def probe_metadata(self, probeset_id: cell_address) -> list: """ Retrieve metadata associated with given probe id. """ - @typing.overload def probe_metadata(self, addr: tuple[int, str]) -> list: """ Retrieve metadata associated with given probe id. """ - @typing.overload def probe_metadata(self, gid: int, tag: str) -> list: """ Retrieve metadata associated with given probe id. """ - def progress_banner(self) -> None: """ Show a text progress bar during simulation. """ - def record(self, arg0: spike_recording) -> None: """ Disable or enable local or global spike recording. """ - def remove_all_samplers(self, arg0: int) -> None: """ Remove all sampling on the simulatr. """ - def remove_sampler(self, handle: int) -> None: """ Remove sampling associated with the given handle. """ - def reset(self) -> None: """ Reset the state of the simulation to its initial state. """ - def run(self, tfinal: units.quantity, dt: units.quantity = ...) -> float: """ Run the simulation from current simulation time to tfinal [ms], with maximum time step size dt [ms]. """ - @typing.overload def sample(self, probeset_id: cell_address, schedule: schedule_base) -> int: """ Record data from probes with given probeset_id according to supplied schedule. Returns handle for retrieving data or removing the sampling. """ - @typing.overload def sample(self, gid: int, tag: str, schedule: schedule_base) -> int: """ Record data from probes with given probeset_id=(gid, tag) according to supplied schedule. Returns handle for retrieving data or removing the sampling. """ - @typing.overload def sample(self, probeset_id: tuple[int, str], schedule: schedule_base) -> int: """ Record data from probes with given probeset_id=(gid, tag) according to supplied schedule. Returns handle for retrieving data or removing the sampling. """ - def samples(self, handle: int) -> list: """ Retrieve sample data as a list, one element per probe associated with the query. """ - def serialize(self) -> str: """ Serialize the simulation object to a JSON string. """ - def set_remote_spike_filter(self, pred: typing.Callable[[spike], bool]) -> None: """ Add a callback to filter spikes going out over external connections. `pred` isa callable on the `spike` type. **Caution**: This will be extremely slow; use C++ if you want to make use of this. """ - def spikes(self) -> typing.Any: """ Retrieve recorded spikes as numpy array. """ - def update(self, recipe: recipe) -> None: """ Rebuild the connection table from recipe::connections_on and the eventgenerators based on recipe::event_generators. """ - class single_cell_model: """ Wrapper for simplified description, and execution, of single cell models. """ - @typing.overload - def __init__( - self, tree: segment_tree, decor: decor, labels: label_dict = ... - ) -> None: + def __init__(self, tree: segment_tree, decor: decor, labels: label_dict = ...) -> None: """ Build single cell model from cable cell components """ - @typing.overload - def __init__( - self, morph: morphology, decor: decor, labels: label_dict = ... - ) -> None: + def __init__(self, morph: morphology, decor: decor, labels: label_dict = ...) -> None: """ Build single cell model from cable cell components """ - @typing.overload def __init__(self, cell: cable_cell) -> None: """ Initialise a single cell model for a cable cell. """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... def event_generator(self, event_generator: event_generator) -> None: """ Register an event generator. event_generator: An Arbor event generator. """ - @typing.overload def probe(self, what: str, where: str, tag: str, frequency: units.quantity) -> None: """ @@ -2835,11 +2413,8 @@ class single_cell_model: tag: Unique name for this probe. frequency: The target frequency at which to sample [kHz]. """ - @typing.overload - def probe( - self, what: str, where: location, tag: str, frequency: units.quantity - ) -> None: + def probe(self, what: str, where: location, tag: str, frequency: units.quantity) -> None: """ Sample a variable on the cell. what: Name of the variable to record (currently only 'voltage'). @@ -2847,390 +2422,371 @@ class single_cell_model: tag: Unique name for this probe. frequency: The target frequency at which to sample [kHz]. """ - def run(self, tfinal: units.quantity, dt: units.quantity = ...) -> None: """ Run model from t=0 to t=tfinal ms. """ - @property def cable_cell(self) -> cable_cell: """ The cable cell held by this model. """ - @property def properties(self) -> cable_global_properties: """ Global properties. """ - @properties.setter - def properties(self, arg0: cable_global_properties) -> None: ... + def properties(self, arg0: cable_global_properties) -> None: + ... @property def spikes(self) -> list[float]: """ Holds spike times [ms] after a call to run(). """ - @property def traces(self) -> list[trace]: """ Holds sample traces after a call to run(). """ - class spike: - def __init__(self, arg0: cell_member, arg1: float) -> None: ... - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __init__(self, arg0: cell_member, arg1: float) -> None: + ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def source(self) -> cell_member: """ The global identifier of the cell. """ - @source.setter - def source(self, arg0: cell_member) -> None: ... + def source(self, arg0: cell_member) -> None: + ... @property def time(self) -> float: """ The time of spike. """ - @time.setter - def time(self, arg0: float) -> None: ... - + def time(self, arg0: float) -> None: + ... class spike_recording: """ Members: - + off - + local - + all """ - - __members__: typing.ClassVar[ - dict[str, spike_recording] - ] # value = {'off': <spike_recording.off: 0>, 'local': <spike_recording.local: 1>, 'all': <spike_recording.all: 2>} + __members__: typing.ClassVar[dict[str, spike_recording]] # value = {'off': <spike_recording.off: 0>, 'local': <spike_recording.local: 1>, 'all': <spike_recording.all: 2>} all: typing.ClassVar[spike_recording] # value = <spike_recording.all: 2> local: typing.ClassVar[spike_recording] # value = <spike_recording.local: 1> off: typing.ClassVar[spike_recording] # value = <spike_recording.off: 0> - def __eq__(self, other: typing.Any) -> bool: ... - def __getstate__(self) -> int: ... - def __hash__(self) -> int: ... - def __index__(self) -> int: ... - def __init__(self, value: int) -> None: ... - def __int__(self) -> int: ... - def __ne__(self, other: typing.Any) -> bool: ... - def __repr__(self) -> str: ... - def __setstate__(self, state: int) -> None: ... - def __str__(self) -> str: ... - @property - def name(self) -> str: ... - @property - def value(self) -> int: ... - + def __eq__(self, other: typing.Any) -> bool: + ... + def __getstate__(self) -> int: + ... + def __hash__(self) -> int: + ... + def __index__(self) -> int: + ... + def __init__(self, value: int) -> None: + ... + def __int__(self) -> int: + ... + def __ne__(self, other: typing.Any) -> bool: + ... + def __repr__(self) -> str: + ... + def __setstate__(self, state: int) -> None: + ... + def __str__(self) -> str: + ... + @property + def name(self) -> str: + ... + @property + def value(self) -> int: + ... class spike_source_cell: """ A spike source cell, that generates a user-defined sequence of spikes that act as inputs for other cells in the network. """ - @typing.overload def __init__(self, source_label: str, schedule: regular_schedule) -> None: """ Construct a spike source cell with a single source labeled 'source_label'. The cell generates spikes on 'source_label' at regular intervals. """ - @typing.overload def __init__(self, source_label: str, schedule: explicit_schedule) -> None: """ Construct a spike source cell with a single source labeled 'source_label'. The cell generates spikes on 'source_label' at a sequence of user-defined times. """ - @typing.overload def __init__(self, source_label: str, schedule: poisson_schedule) -> None: """ Construct a spike source cell with a single source labeled 'source_label'. The cell generates spikes on 'source_label' at times defined by a Poisson sequence. """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... - + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... class swc_metadata: """ SWC metadata type: empty. """ - class synapse: """ For placing a synaptic mechanism on a locset. """ - @typing.overload - def __init__(self, arg0: str) -> None: ... + def __init__(self, arg0: str) -> None: + ... @typing.overload - def __init__(self, arg0: mechanism) -> None: ... + def __init__(self, arg0: mechanism) -> None: + ... @typing.overload - def __init__(self, arg0: str, arg1: dict[str, float]) -> None: ... + def __init__(self, arg0: str, arg1: dict[str, float]) -> None: + ... @typing.overload - def __init__(self, arg0: mechanism, arg1: dict[str, float]) -> None: ... + def __init__(self, arg0: mechanism, arg1: dict[str, float]) -> None: + ... @typing.overload - def __init__(self, arg0: str, **kwargs) -> None: ... + def __init__(self, arg0: str, **kwargs) -> None: + ... @typing.overload - def __init__(self, arg0: mechanism, **kwargs) -> None: ... - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __init__(self, arg0: mechanism, **kwargs) -> None: + ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def mech(self) -> mechanism: """ The underlying mechanism. """ - class temperature: """ Setting the temperature. """ - - def __init__(self, arg0: units.quantity) -> None: ... - def __repr__(self) -> str: ... - + def __init__(self, arg0: units.quantity) -> None: + ... + def __repr__(self) -> str: + ... class threshold_detector: """ A spike detector, generates a spike when voltage crosses a threshold. Can be used as source endpoint for an arbor.connection. """ - def __init__(self, threshold: units.quantity) -> None: """ Voltage threshold of spike detector [mV] """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def threshold(self) -> float: """ Voltage threshold of spike detector [mV] """ - class trace: """ Values and meta-data for a sample-trace on a single cell model. """ - - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def location(self) -> location: """ Location on cell morphology. """ - @property def time(self) -> list[float]: """ Time stamps of samples [ms]. """ - @property def value(self) -> list[float]: """ Sample values. """ - @property def variable(self) -> str: """ Name of the variable being recorded. """ - class voltage_process: """ For painting a voltage_process mechanism on a region. """ - @typing.overload - def __init__(self, arg0: str) -> None: ... + def __init__(self, arg0: str) -> None: + ... @typing.overload - def __init__(self, arg0: mechanism) -> None: ... + def __init__(self, arg0: mechanism) -> None: + ... @typing.overload - def __init__(self, arg0: str, arg1: dict[str, float]) -> None: ... + def __init__(self, arg0: str, arg1: dict[str, float]) -> None: + ... @typing.overload - def __init__(self, arg0: mechanism, arg1: dict[str, float]) -> None: ... + def __init__(self, arg0: mechanism, arg1: dict[str, float]) -> None: + ... @typing.overload - def __init__(self, arg0: mechanism, **kwargs) -> None: ... + def __init__(self, arg0: mechanism, **kwargs) -> None: + ... @typing.overload - def __init__(self, arg0: str, **kwargs) -> None: ... - def __repr__(self) -> str: ... - def __str__(self) -> str: ... + def __init__(self, arg0: str, **kwargs) -> None: + ... + def __repr__(self) -> str: + ... + def __str__(self) -> str: + ... @property def mech(self) -> mechanism: """ The underlying mechanism. """ - -def allen_catalogue() -> catalogue: ... -def bbp_catalogue() -> catalogue: ... +def allen_catalogue() -> catalogue: + ... +def bbp_catalogue() -> catalogue: + ... def cable_probe_axial_current(where: str, tag: str) -> probe: """ Probe specification for cable cell axial current at points in a location set. """ - -def cable_probe_density_state( - where: str, mechanism: str, state: str, tag: str -) -> probe: +def cable_probe_density_state(where: str, mechanism: str, state: str, tag: str) -> probe: """ Probe specification for a cable cell density mechanism state variable at points in a location set. """ - def cable_probe_density_state_cell(mechanism: str, state: str, tag: str) -> probe: """ Probe specification for a cable cell density mechanism state variable on each cable in each CV where defined. """ - def cable_probe_ion_current_cell(ion: str, tag: str) -> probe: """ Probe specification for cable cell ionic current across each cable in each CV. """ - def cable_probe_ion_current_density(where: str, ion: str, tag: str) -> probe: """ Probe specification for cable cell ionic current density at points in a location set. """ - def cable_probe_ion_diff_concentration(where: str, ion: str, tag: str) -> probe: """ Probe specification for cable cell diffusive ionic concentration at points in a location set. """ - def cable_probe_ion_diff_concentration_cell(ion: str, tag: str) -> probe: """ Probe specification for cable cell diffusive ionic concentration for each cable in each CV. """ - def cable_probe_ion_ext_concentration(where: str, ion: str, tag: str) -> probe: """ Probe specification for cable cell external ionic concentration at points in a location set. """ - def cable_probe_ion_ext_concentration_cell(ion: str, tag: str) -> probe: """ Probe specification for cable cell external ionic concentration for each cable in each CV. """ - def cable_probe_ion_int_concentration(where: str, ion: str, tag: str) -> probe: """ Probe specification for cable cell internal ionic concentration at points in a location set. """ - def cable_probe_ion_int_concentration_cell(ion: str, tag: str) -> probe: """ Probe specification for cable cell internal ionic concentration for each cable in each CV. """ - def cable_probe_membrane_voltage(where: str, tag: str) -> probe: """ Probe specification for cable cell membrane voltage interpolated at points in a location set. """ - def cable_probe_membrane_voltage_cell(tag: str) -> probe: """ Probe specification for cable cell membrane voltage associated with each cable in each CV. """ - def cable_probe_point_state(target: int, mechanism: str, state: str, tag: str) -> probe: """ Probe specification for a cable cell point mechanism state variable value at a given target index. """ - def cable_probe_point_state_cell(mechanism: str, state: str, tag: str) -> probe: """ Probe specification for a cable cell point mechanism state variable value at every corresponding target. """ - def cable_probe_stimulus_current_cell(tag: str) -> probe: """ Probe specification for cable cell stimulus current across each cable in each CV. """ - def cable_probe_total_current_cell(tag: str) -> probe: """ Probe specification for cable cell total transmembrane current for each cable in each CV. """ - def cable_probe_total_ion_current_cell(tag: str) -> probe: """ Probe specification for cable cell total transmembrane current excluding capacitive currents for each cable in each CV. """ - def cable_probe_total_ion_current_density(where: str, tag: str) -> probe: """ Probe specification for cable cell total transmembrane current density excluding capacitive currents at points in a location set. """ - def config() -> dict: """ Get Arbor's configuration. """ - def cv_data(cell: cable_cell) -> cell_cv_data | None: """ Returns a cell_cv_data object representing the CVs comprising the cable-cell according to the discretization policy provided in the decor of the cell. Returns None if no CV-policy was provided in the decor. """ - -def cv_policy_every_segment(domain: str = "(all)") -> cv_policy: +def cv_policy_every_segment(domain: str = '(all)') -> cv_policy: """ Policy to create one compartment per component of a region. """ - -def cv_policy_explicit(locset: str, domain: str = "(all)") -> cv_policy: +def cv_policy_explicit(locset: str, domain: str = '(all)') -> cv_policy: """ Policy to create compartments at explicit locations. """ - -def cv_policy_fixed_per_branch(n: int, domain: str = "(all)") -> cv_policy: +def cv_policy_fixed_per_branch(n: int, domain: str = '(all)') -> cv_policy: """ Policy to use the same number of CVs for each branch. """ - -def cv_policy_max_extent(length: float, domain: str = "(all)") -> cv_policy: +def cv_policy_max_extent(length: float, domain: str = '(all)') -> cv_policy: """ Policy to use as many CVs as required to ensure that no CV has a length longer than a given value. """ - -def cv_policy_single(domain: str = "(all)") -> cv_policy: +def cv_policy_single(domain: str = '(all)') -> cv_policy: """ Policy to create one compartment per component of a region. """ - -def default_catalogue() -> catalogue: ... +def default_catalogue() -> catalogue: + ... def intersect_region(reg: str, data: cell_cv_data, integrate_along: str) -> list[tuple]: """ Returns a list of [index, proportion] tuples identifying the CVs present in the region. `index` is the index of the CV in the cell_cv_data object provided as an argument. `proportion` is the proportion of the CV (itegrated by area or length) included in the region. """ - def lif_probe_voltage(tag: str) -> probe: """ Probe specification for LIF cell membrane voltage. """ - def load_asc(filename_or_stream: typing.Any) -> loaded_morphology: """ Load a morphology or segment_tree and meta data from a Neurolucida ASCII .asc file. """ - -def load_catalogue(arg0: typing.Any) -> catalogue: ... +def load_catalogue(arg0: typing.Any) -> catalogue: + ... def load_component(filename_or_descriptor: typing.Any) -> cable_component: """ Load arbor-component (decor, morphology, label_dict, cable_cell) from file. """ - def load_swc_arbor(filename_or_stream: typing.Any) -> loaded_morphology: """ Generate a morphology/segment_tree from an SWC file following the rules prescribed by Arbor. @@ -3241,74 +2797,64 @@ def load_swc_arbor(filename_or_stream: typing.Any) -> loaded_morphology: * A segment is always created between a sample and its parent, meaning there are no gaps in the resulting morphology. """ - def load_swc_neuron(filename_or_stream: typing.Any) -> loaded_morphology: """ Generate a morphology from an SWC file following the rules prescribed by NEURON. See the documentation https://docs.arbor-sim.org/en/latest/fileformat/swc.html for a detailed description of the interpretation. """ - def neuron_cable_properties() -> cable_global_properties: """ default NEURON cable_global_properties """ - -def partition_by_group( - recipe: recipe, context: context, groups: list[group_description] -) -> domain_decomposition: +def partition_by_group(recipe: recipe, context: context, groups: list[group_description]) -> domain_decomposition: """ - Construct a domain_decomposition that assigned the groups of cell provided as argument + Construct a domain_decomposition that assigned the groups of cell provided as argument to the local hardware resources described by context on the calling rank. The cell_groups are guaranteed to be present on the calling rank. """ - -def partition_load_balance( - recipe: recipe, context: context, hints: dict[cell_kind, partition_hint] = {} -) -> domain_decomposition: +def partition_load_balance(recipe: recipe, context: context, hints: dict[cell_kind, partition_hint] = {}) -> domain_decomposition: """ Construct a domain_decomposition that distributes the cells in the model described by recipe over the distributed and local hardware resources described by context. Optionally, provide a dictionary of partition hints for certain cell kinds, by default empty. """ - def print_config() -> None: """ Print Arbor's configuration. """ - -def stochastic_catalogue() -> catalogue: ... +def profiler_initialize(arg0: context) -> None: + ... +def profiler_summary(limit: float = 0.0) -> str: + """ + Show summary of the profile; printing contributions above `limit` percent. Defaults to showing all. + """ +def stochastic_catalogue() -> catalogue: + ... @typing.overload -def write_component( - object: cable_component, filename_or_descriptor: typing.Any -) -> None: +def write_component(object: cable_component, filename_or_descriptor: typing.Any) -> None: """ Write cable_component to file. """ - @typing.overload def write_component(object: decor, filename_or_descriptor: typing.Any) -> None: """ Write decor to file. """ - @typing.overload def write_component(object: label_dict, filename_or_descriptor: typing.Any) -> None: """ Write label_dict to file. """ - @typing.overload def write_component(object: morphology, filename_or_descriptor: typing.Any) -> None: """ Write morphology to file. """ - @typing.overload def write_component(object: cable_cell, filename_or_descriptor: typing.Any) -> None: """ Write cable_cell to file. """ - -__version__: str = "0.9.1-dev" +__version__: str = '0.9.1-dev' mnpos: int = 4294967295 diff --git a/python/stubs/arbor/_arbor/env.pyi b/python/stubs/arbor/_arbor/env.pyi index 72be0ec6daa5b91edafccfa43ccdd9bb0c80e14a..2073f67e9961e20e45fb4e6ab30053f9cc0add56 100644 --- a/python/stubs/arbor/_arbor/env.pyi +++ b/python/stubs/arbor/_arbor/env.pyi @@ -1,46 +1,31 @@ """ Wrappers for arborenv. """ - from __future__ import annotations import arbor._arbor import typing - -__all__ = [ - "default_allocation", - "default_concurrency", - "default_gpu", - "find_private_gpu", - "get_env_num_threads", - "thread_concurrency", -] - +__all__ = ['default_allocation', 'default_concurrency', 'default_gpu', 'find_private_gpu', 'get_env_num_threads', 'thread_concurrency'] def default_allocation() -> arbor._arbor.proc_allocation: """ Attempts to detect the number of locally available CPU cores. Returns 1 if unable to detect the number of cores. Use with caution in combination with MPI. """ - def default_concurrency() -> arbor._arbor.proc_allocation: """ Returns number of threads to use from get_env_num_threads(), or else from thread_concurrency() if get_env_num_threads() returns zero. """ - def default_gpu() -> int | None: """ Determine GPU id to use from the ARBENV_GPU_ID environment variable, or from the first available GPU id of those detected. """ - def find_private_gpu(arg0: typing.Any) -> None: """ Identify a private GPU id per node, only available if built with GPU and MPI. mpi: The MPI communicator. """ - def get_env_num_threads() -> int: """ Retrieve user-specified number of threads to use from the environment variable ARBENV_NUM_THREADS. """ - def thread_concurrency() -> int: """ Attempts to detect the number of locally available CPU cores. Returns 1 if unable to detect the number of cores. Use with caution in combination with MPI. diff --git a/python/stubs/arbor/_arbor/units.pyi b/python/stubs/arbor/_arbor/units.pyi index 664b21ae329d1cfd12b9afdcbee758cf05100e0a..3cbb1f7811b5059e818b4e0d6c54beeab6078033 100644 --- a/python/stubs/arbor/_arbor/units.pyi +++ b/python/stubs/arbor/_arbor/units.pyi @@ -1,146 +1,103 @@ """ Units and quantities for driving the user interface. """ - from __future__ import annotations import typing - -__all__ = [ - "A", - "C", - "Celsius", - "F", - "Hz", - "Kelvin", - "M", - "MOhm", - "Ohm", - "S", - "V", - "cm", - "cm2", - "deg", - "giga", - "kHz", - "kOhm", - "kilo", - "m", - "m2", - "mA", - "mM", - "mS", - "mV", - "mega", - "micro", - "milli", - "mm", - "mm2", - "mol", - "ms", - "nA", - "nF", - "nano", - "nil", - "nm", - "nm2", - "ns", - "pA", - "pF", - "pico", - "quantity", - "rad", - "s", - "uA", - "uF", - "uS", - "um", - "um2", - "unit", - "us", -] - +__all__ = ['A', 'C', 'Celsius', 'F', 'Hz', 'Kelvin', 'M', 'MOhm', 'Ohm', 'S', 'V', 'cm', 'cm2', 'deg', 'giga', 'kHz', 'kOhm', 'kilo', 'm', 'm2', 'mA', 'mM', 'mS', 'mV', 'mega', 'micro', 'milli', 'mm', 'mm2', 'mol', 'ms', 'nA', 'nF', 'nano', 'nil', 'nm', 'nm2', 'ns', 'pA', 'pF', 'pico', 'quantity', 'rad', 's', 'uA', 'uF', 'uS', 'um', 'um2', 'unit', 'us'] class quantity: """ A quantity, comprising a magnitude and a unit. """ - __hash__: typing.ClassVar[None] = None - def __add__(self, arg0: quantity) -> quantity: ... - def __eq__(self, arg0: quantity) -> bool: ... + def __add__(self, arg0: quantity) -> quantity: + ... + def __eq__(self, arg0: quantity) -> bool: + ... @typing.overload - def __mul__(self, arg0: quantity) -> quantity: ... + def __mul__(self, arg0: quantity) -> quantity: + ... @typing.overload - def __mul__(self, arg0: float) -> quantity: ... + def __mul__(self, arg0: float) -> quantity: + ... @typing.overload - def __mul__(self, arg0: unit) -> quantity: ... - def __ne__(self, arg0: quantity) -> bool: ... - def __pow__(self: unit, arg0: int) -> unit: ... + def __mul__(self, arg0: unit) -> quantity: + ... + def __ne__(self, arg0: quantity) -> bool: + ... + def __pow__(self: unit, arg0: int) -> unit: + ... def __repr__(self) -> str: """ Convert quantity to string. """ - - def __rmul__(self, arg0: float) -> quantity: ... - def __rtruediv__(self, arg0: float) -> quantity: ... + def __rmul__(self, arg0: float) -> quantity: + ... + def __rtruediv__(self, arg0: float) -> quantity: + ... def __str__(self) -> str: """ Convert quantity to string. """ - - def __sub__(self, arg0: quantity) -> quantity: ... + def __sub__(self, arg0: quantity) -> quantity: + ... @typing.overload - def __truediv__(self, arg0: quantity) -> quantity: ... + def __truediv__(self, arg0: quantity) -> quantity: + ... @typing.overload - def __truediv__(self, arg0: float) -> quantity: ... + def __truediv__(self, arg0: float) -> quantity: + ... @typing.overload - def __truediv__(self, arg0: unit) -> quantity: ... + def __truediv__(self, arg0: unit) -> quantity: + ... def value_as(self, unit: unit) -> float: """ Convert quantity to given unit and return magnitude. """ - @property def units(self) -> unit: """ Return units. """ - @property def value(self) -> float: """ Return magnitude. """ - class unit: """ A unit. """ - __hash__: typing.ClassVar[None] = None - def __eq__(self, arg0: unit) -> bool: ... + def __eq__(self, arg0: unit) -> bool: + ... @typing.overload - def __mul__(self, arg0: unit) -> unit: ... + def __mul__(self, arg0: unit) -> unit: + ... @typing.overload - def __mul__(self, arg0: float) -> quantity: ... - def __ne__(self, arg0: unit) -> bool: ... - def __pow__(self, arg0: int) -> unit: ... + def __mul__(self, arg0: float) -> quantity: + ... + def __ne__(self, arg0: unit) -> bool: + ... + def __pow__(self, arg0: int) -> unit: + ... def __repr__(self) -> str: """ Convert unit to string. """ - - def __rmul__(self, arg0: float) -> quantity: ... - def __rtruediv__(self, arg0: float) -> quantity: ... + def __rmul__(self, arg0: float) -> quantity: + ... + def __rtruediv__(self, arg0: float) -> quantity: + ... def __str__(self) -> str: """ Convert unit to string. """ - @typing.overload - def __truediv__(self, arg0: unit) -> unit: ... + def __truediv__(self, arg0: unit) -> unit: + ... @typing.overload - def __truediv__(self, arg0: float) -> quantity: ... - + def __truediv__(self, arg0: float) -> quantity: + ... A: unit # value = A C: unit # value = C Celsius: unit # value = °C @@ -175,7 +132,7 @@ ms: unit # value = ms nA: unit # value = nA nF: unit # value = nF nano: unit # value = 1e-09 -nil: unit # value = +nil: unit # value = nm: unit # value = nm nm2: unit # value = nm^2 ns: unit # value = ns