From a677a50d8bd7b594f77b70cbb7a0a305bf6e6223 Mon Sep 17 00:00:00 2001 From: "Ankur Sinha (Ankur Sinha Gmail)" Date: Tue, 1 Oct 2024 16:45:44 +0100 Subject: [PATCH 1/8] feat(2.3.2): copy over 2.3.1 to 2.3.2 --- neuroml/__version__.py | 2 +- neuroml/nml/NeuroML_v2.3.2.xsd | 3963 ++++++++++++++++++++++++++++++++ 2 files changed, 3964 insertions(+), 1 deletion(-) create mode 100644 neuroml/nml/NeuroML_v2.3.2.xsd diff --git a/neuroml/__version__.py b/neuroml/__version__.py index b22c62b..715286c 100644 --- a/neuroml/__version__.py +++ b/neuroml/__version__.py @@ -18,4 +18,4 @@ __version_info__: tuple = tuple(int(i) for i in __version__.split(".")) -current_neuroml_version: str = "v2.3.1" +current_neuroml_version: str = "v2.3.2" diff --git a/neuroml/nml/NeuroML_v2.3.2.xsd b/neuroml/nml/NeuroML_v2.3.2.xsd new file mode 100644 index 0000000..741f1e8 --- /dev/null +++ b/neuroml/nml/NeuroML_v2.3.2.xsd @@ -0,0 +1,3963 @@ + + + + + + + + An id attribute for elements which need to be identified uniquely (normally just within their parent element). + + + + + + + + A value for a physical quantity in NeuroML 2, e.g. 20, -60.0mV or 5nA + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + An id string for pointing to an entry in an annotation element related to a MIRIAM resource. Based on metaid of SBML + + + + + + + + An id string for pointing to an entry in the NeuroLex ontology. Use of this attribute is a shorthand for a full + RDF based reference to the MIRIAM Resource urn:miriam:neurolex, with an bqbiol:is qualifier + + + + + + + + + A path referring to another component. + + + + + + + + + An attribute useful as id of segments, connections, etc: integer >=0 only! + + + + + + + + + + + Integer >=1 only! + + + + + + + + + + + Double >0 only + + + + + + + + Value which is either 0 or 1 + + + + + + + + + + + + + Textual human readable notes related to the element in question. It's useful to put these into + the NeuroML files instead of XML comments, as the notes can be extracted and repeated in the files to which the NeuroML is mapped. + + + + + + + A property ( a **tag** and **value** pair ), which can be on any **baseStandalone** either as a direct child, or within an **Annotation** . Generally something which helps the visual display or facilitates simulation of a Component, but is not a core physiological property. Common examples include: **numberInternalDivisions,** equivalent of nseg in NEURON; **radius,** for a radius to use in graphical displays for abstract cells ( i. e. without defined morphologies ); **color,** the color to use for a **Population** or **populationList** of cells; **recommended_dt_ms,** the recommended timestep to use for simulating a **Network** , **recommended_duration_ms** the recommended duration to use when running a **Network** + + + + + + + + + + + + A structured annotation containing metadata, specifically RDF or **property** elements + + + + + + + + + + + + + + Contains an extension to NeuroML by creating custom LEMS ComponentType. + + + + + + + + + + + + + + + + + + LEMS ComponentType for Constant. + + + + + + + + + + + + + LEMS Exposure (ComponentType property) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + LEMS DerivedParamter element + + + + + + + + + + + + + + + + + + + + + + + + + + + + LEMS ComponentType for Dynamics + + + + + + + + + + + + + + + LEMS ComponentType for DerivedVariable + + + + + + + + + + + + + + + + + + + LEMS ComponentType for ConditionalDerivedVariable + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Float value restricted to between 1 and 0 + + + + + + + + + + + + The root NeuroML element. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Various types of cells which are defined in NeuroML 2. This list will be expanded... + + + + + + + + + + + + + + + + + + + + + Various types of cells which are defined in NeuroML 2 based on PyNN standard cell models. + + + + + + + + + + + + + + Various types of synapse which are defined in NeuroML 2. This list will be expanded... + + + + + + + + + + + + + + + + + + Various types of synapse which are defined in NeuroML 2 based on PyNN standard cell/synapse models. + + + + + + + + + + + Various types of inputs which are defined in NeuroML2. This list will be expanded... + + + + + + + + + + + + + + + + + + + + + + + + + Various types of input which are defined in NeuroML 2 based on PyNN standard cell/synapse models. + + + + + + + + Various types of concentration model which are defined in NeuroML 2. This list will be expanded... + + + + + + + + + + + + + + + + + + + + + + A kinetic scheme based ion channel with multiple **gateKS** s, each of which consists of multiple **KSState** s and **KSTransition** s giving the rates of transition between them +\n +:param conductance: +:type conductance: conductance + + + + + + + + + + + + + + + + + Note **ionChannel** and **ionChannelHH** are currently functionally identical. This is needed since many existing examples use ionChannel, some use ionChannelHH. NeuroML v2beta4 should remove one of these, probably ionChannelHH. +\n +:param conductance: +:type conductance: conductance + + + + + + + + + + + + + + + + + + + + + + + + Note **ionChannel** and **ionChannelHH** are currently functionally identical. This is needed since many existing examples use ionChannel, some use ionChannelHH. NeuroML v2beta4 should remove one of these, probably ionChannelHH. +\n +:param conductance: +:type conductance: conductance + + + + + + + + + + Same as **ionChannel** , but with a **vShift** parameter to change voltage activation of gates. The exact usage of **vShift** in expressions for rates is determined by the individual gates. +\n +:param vShift: +:type vShift: voltage +:param conductance: +:type conductance: conductance + + + + + + + + + + + + + + + + + + + A value for the conductance scaling which varies as a standard function of the difference between the current temperature, **temperature,** and the temperature at which the conductance was originally determined, **experimentalTemp** +\n +:param q10Factor: +:type q10Factor: none +:param experimentalTemp: +:type experimentalTemp: temperature + + + + + + + + + + + + + + + + + + + + + + + + + A **KSState** with **relativeConductance** of 0 +\n +:param relativeConductance: +:type relativeConductance: none + + + + + + + + + + + + A **KSState** with **relativeConductance** of 1 +\n +:param relativeConductance: +:type relativeConductance: none + + + + + + + + + + + + A forward only **KSTransition** for a **gateKS** which specifies a **rate** ( type **baseHHRate** ) which follows one of the standard Hodgkin Huxley forms ( e. g. **HHExpRate** , **HHSigmoidRate** , **HHExpLinearRate** + + + + + + + + + + + + + + + + A reverse only **KSTransition** for a **gateKS** which specifies a **rate** ( type **baseHHRate** ) which follows one of the standard Hodgkin Huxley forms ( e. g. **HHExpRate** , **HHSigmoidRate** , **HHExpLinearRate** + + + + + + + + + + + + + + + + + + + + + + KS Transition specified in terms of time constant **tau** and steady state **inf** + + + + + + + + + + + + + + + + A gate which consists of multiple **KSState** s and **KSTransition** s giving the rates of transition between them +\n +:param instances: +:type instances: none + + + + + + + + + + + + + + + + + + + + + + Note all sub elements for gateHHrates, gateHHratesTau, gateFractional etc. allowed here. Which are valid should be constrained by what type is set + + + + + + + + + + + + + + + + + + + + + Gate which follows the general Hodgkin Huxley formalism +\n +:param instances: +:type instances: none + + + + + + + + + + + + + + + + + + + Gate which follows the general Hodgkin Huxley formalism +\n +:param instances: +:type instances: none + + + + + + + + + + + + + + + + + + + Gate which follows the general Hodgkin Huxley formalism +\n +:param instances: +:type instances: none + + + + + + + + + + + + + + + + + + + + + Gate which follows the general Hodgkin Huxley formalism +\n +:param instances: +:type instances: none + + + + + + + + + + + + + + + + + + + + Gate which follows the general Hodgkin Huxley formalism +\n +:param instances: +:type instances: none + + + + + + + + + + + + + + + + + + + + Gate which follows the general Hodgkin Huxley formalism but is instantaneous, so tau = 0 and gate follows exactly inf value +\n +:param instances: +:type instances: none + + + + + + + + + + + + + + + + + Gate composed of subgates contributing with fractional conductance +\n +:param instances: +:type instances: none + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Model of an intracellular buffering mechanism for **ion** ( currently hard Coded to be calcium, due to requirement for **iCa** ) which has a baseline level **restingConc** and tends to this value with time course **decayConstant.** The ion is assumed to occupy a shell inside the membrane of thickness **shellThickness.** +\n +:param restingConc: +:type restingConc: concentration +:param decayConstant: +:type decayConstant: time +:param shellThickness: +:type shellThickness: length + + + + + + + + + + + + + + + + + + Model of buffering of concentration of an ion ( currently hard coded to be calcium, due to requirement for **iCa** ) which has a baseline level **restingConc** and tends to this value with time course **decayConstant.** A fixed factor **rho** is used to scale the incoming current *independently of the size of the compartment* to produce a concentration change. +\n +:param restingConc: +:type restingConc: concentration +:param decayConstant: +:type decayConstant: time +:param rho: +:type rho: rho_factor + + + + + + + + + + + + + + + + + + + + + Base type for all synapses, i. e. ComponentTypes which produce a current ( dimension current ) and change Dynamics in response to an incoming event. cno_0000009 + + + + + + + + + + + Base type for synapses with a dependence on membrane potential + + + + + + + + + + + Synapse model which produces a synaptic current. + + + + + + + + + + + Synapse model which exposes a conductance **g** in addition to producing a current. Not necessarily ohmic!! cno_0000027 +\n +:param gbase: Baseline conductance, generally the maximum conductance following a single spike +:type gbase: conductance +:param erev: Reversal potential of the synapse +:type erev: voltage + + + + + + + + + + + + + Synapse model suited for a sum of two expTwoSynapses which exposes a conductance **g** in addition to producing a current. Not necessarily ohmic!! cno_0000027 +\n +:param gbase1: Baseline conductance 1 +:type gbase1: conductance +:param gbase2: Baseline conductance 2 +:type gbase2: conductance +:param erev: Reversal potential of the synapse +:type erev: voltage + + + + + + + + + + + + + + Gap junction/single electrical connection +\n +:param conductance: +:type conductance: conductance + + + + + + + + + + + + Dummy synapse which emits no current. Used as presynaptic endpoint for analog synaptic connection. + + + + + + + + + + + Behaves just like a one way gap junction. +\n +:param conductance: +:type conductance: conductance + + + + + + + + + + + + Graded/analog synapse. Based on synapse in Methods of http://www. nature.com/neuro/journal/v7/n12/abs/nn1352.html +\n +:param conductance: +:type conductance: conductance +:param delta: Slope of the activation curve +:type delta: voltage +:param k: Rate constant for transmitter-receptor dissociation rate +:type k: per_time +:param Vth: The half-activation voltage of the synapse +:type Vth: voltage +:param erev: The reversal potential of the synapse +:type erev: voltage + + + + + + + + + + + + + + + + Alpha current synapse: rise time and decay time are both **tau.** +\n +:param tau: Time course for rise and decay +:type tau: time +:param ibase: Baseline current increase after receiving a spike +:type ibase: current + + + + + + + + + + + + + Ohmic synapse model where rise time and decay time are both **tau.** Max conductance reached during this time ( assuming zero conductance before ) is **gbase** * **weight.** +\n +:param tau: Time course of rise/decay +:type tau: time +:param gbase: Baseline conductance, generally the maximum conductance following a single spike +:type gbase: conductance +:param erev: Reversal potential of the synapse +:type erev: voltage + + + + + + + + + + + + Ohmic synapse model whose conductance rises instantaneously by ( **gbase** * **weight** ) on receiving an event, and which decays exponentially to zero with time course **tauDecay** +\n +:param tauDecay: Time course of decay +:type tauDecay: time +:param gbase: Baseline conductance, generally the maximum conductance following a single spike +:type gbase: conductance +:param erev: Reversal potential of the synapse +:type erev: voltage + + + + + + + + + + + + Ohmic synapse model whose conductance waveform on receiving an event has a rise time of **tauRise** and a decay time of **tauDecay.** Max conductance reached during this time ( assuming zero conductance before ) is **gbase** * **weight.** +\n +:param tauRise: +:type tauRise: time +:param tauDecay: +:type tauDecay: time +:param gbase: Baseline conductance, generally the maximum conductance following a single spike +:type gbase: conductance +:param erev: Reversal potential of the synapse +:type erev: voltage + + + + + + + + + + + + + Ohmic synapse similar to expTwoSynapse but consisting of two components that can differ in decay times and max conductances but share the same rise time. +\n +:param tauRise: +:type tauRise: time +:param tauDecay1: +:type tauDecay1: time +:param tauDecay2: +:type tauDecay2: time +:param gbase1: Baseline conductance 1 +:type gbase1: conductance +:param gbase2: Baseline conductance 2 +:type gbase2: conductance +:param erev: Reversal potential of the synapse +:type erev: voltage + + + + + + + + + + + + + + Synapse consisting of two independent synaptic mechanisms ( e. g. AMPA-R and NMDA-R ), which can be easily colocated in connections + + + + + + + + + + + + + + Biexponential synapse that allows for optional block and plasticity mechanisms, which can be expressed as child elements. +\n +:param tauRise: +:type tauRise: time +:param tauDecay: +:type tauDecay: time +:param gbase: Baseline conductance, generally the maximum conductance following a single spike +:type gbase: conductance +:param erev: Reversal potential of the synapse +:type erev: voltage + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Base type of any cell ( e. g. point neuron like **izhikevich2007Cell** , or a morphologically detailed **Cell** with **segment** s ) which can be used in a **population** + + + + + + + + + + + Integrate and fire cell which returns to its leak reversal potential of **leakReversal** with a time constant **tau** +\n +:param leakReversal: +:type leakReversal: voltage +:param tau: +:type tau: time +:param thresh: The membrane potential at which to emit a spiking event and reset voltage +:type thresh: voltage +:param reset: The value the membrane potential is reset to on spiking +:type reset: voltage + + + + + + + + + + + + + + + Integrate and fire cell which returns to its leak reversal potential of **leakReversal** with a time course **tau.** It has a refractory period of **refract** after spiking +\n +:param refract: +:type refract: time +:param leakReversal: +:type leakReversal: voltage +:param tau: +:type tau: time +:param thresh: The membrane potential at which to emit a spiking event and reset voltage +:type thresh: voltage +:param reset: The value the membrane potential is reset to on spiking +:type reset: voltage + + + + + + + + + + + + Integrate and fire cell with capacitance **C,** **leakConductance** and **leakReversal** +\n +:param leakConductance: +:type leakConductance: conductance +:param leakReversal: +:type leakReversal: voltage +:param thresh: +:type thresh: voltage +:param reset: +:type reset: voltage +:param C: Total capacitance of the cell membrane +:type C: capacitance + + + + + + + + + + + + + + + + Integrate and fire cell with capacitance **C,** **leakConductance,** **leakReversal** and refractory period **refract** +\n +:param refract: +:type refract: time +:param leakConductance: +:type leakConductance: conductance +:param leakReversal: +:type leakReversal: voltage +:param thresh: +:type thresh: voltage +:param reset: +:type reset: voltage +:param C: Total capacitance of the cell membrane +:type C: capacitance + + + + + + + + + + + + Cell based on the 2003 model of Izhikevich, see http://izhikevich.org/publications/spikes.htm +\n +:param v0: Initial membrane potential +:type v0: voltage +:param a: Time scale of the recovery variable U +:type a: none +:param b: Sensitivity of U to the subthreshold fluctuations of the membrane potential V +:type b: none +:param c: After-spike reset value of V +:type c: none +:param d: After-spike increase to U +:type d: none +:param thresh: Spike threshold +:type thresh: voltage + + + + + + + + + + + + + + + + + Any cell with a membrane potential **v** with voltage units and a membrane capacitance **C.** Also defines exposed value **iSyn** for current due to external synapses and **iMemb** for total transmembrane current ( usually channel currents plus **iSyn** ) +\n +:param C: Total capacitance of the cell membrane +:type C: capacitance + + + + + + + + + + + + + + + + + + Cell based on the modified Izhikevich model in Izhikevich 2007, Dynamical systems in neuroscience, MIT Press +\n +:param v0: Initial membrane potential +:type v0: voltage +:param k: +:type k: conductance_per_voltage +:param vr: Resting membrane potential +:type vr: voltage +:param vt: Spike threshold +:type vt: voltage +:param vpeak: Peak action potential value +:type vpeak: voltage +:param a: Time scale of recovery variable u +:type a: per_time +:param b: Sensitivity of recovery variable u to subthreshold fluctuations of membrane potential v +:type b: conductance +:param c: After-spike reset value of v +:type c: voltage +:param d: After-spike increase to u +:type d: current +:param C: Total capacitance of the cell membrane +:type C: capacitance + + + + + + + + + + + + + + + + + + + + Model based on Brette R and Gerstner W ( 2005 ) Adaptive Exponential Integrate-and-Fire Model as an Effective Description of Neuronal Activity. J Neurophysiol 94:3637-3642 +\n +:param gL: Leak conductance +:type gL: conductance +:param EL: Leak reversal potential +:type EL: voltage +:param VT: Spike threshold +:type VT: voltage +:param thresh: Spike detection threshold +:type thresh: voltage +:param reset: Reset potential +:type reset: voltage +:param delT: Slope factor +:type delT: voltage +:param tauw: Adaptation time constant +:type tauw: time +:param refract: Refractory period +:type refract: time +:param a: Sub-threshold adaptation variable +:type a: conductance +:param b: Spike-triggered adaptation variable +:type b: current +:param C: Total capacitance of the cell membrane +:type C: capacitance + + + + + + + + + + + + + + + + + + + + + Simple dimensionless model of spiking cell from FitzHugh and Nagumo. Superseded by **fitzHughNagumo1969Cell** ( See https://github.com/NeuroML/NeuroML2/issues/42 ) +\n +:param I: +:type I: none + + + + + + + + + + + + The Fitzhugh Nagumo model is a two-dimensional simplification of the Hodgkin-Huxley model of spike generation in squid giant axons. This system was suggested by FitzHugh ( FitzHugh R. [1961]: Impulses and physiological states in theoretical models of nerve membrane. Biophysical J. 1:445-466 ), who called it " Bonhoeffer-van der Pol model ", and the equivalent circuit by Nagumo et al. ( Nagumo J. , Arimoto S. , and Yoshizawa S. [1962] An active pulse transmission line simulating nerve axon. Proc IRE. 50:2061-2070. 1962 ). This version corresponds to the one described in FitzHugh R. [1969]: Mathematical models of excitation and propagation in nerve. Chapter 1 ( pp. 1-85 in H. P. Schwan, ed. Biological Engineering, McGraw-Hill Book Co. , N. Y. ) +\n +:param a: +:type a: none +:param b: +:type b: none +:param I: plays the role of an external injected current +:type I: none +:param phi: +:type phi: none +:param V0: +:type V0: none +:param W0: +:type W0: none + + + + + + + + + + + + + + + + + Reduced CA3 cell model from Pinsky, P. F. , Rinzel, J. Intrinsic and network rhythmogenesis in a reduced traub model for CA3 neurons. J Comput Neurosci 1, 39-60 ( 1994 ). See https://github.com/OpenSourceBrain/PinskyRinzelModel +\n +:param iSoma: +:type iSoma: currentDensity +:param iDend: +:type iDend: currentDensity +:param gLs: +:type gLs: conductanceDensity +:param gLd: +:type gLd: conductanceDensity +:param gNa: +:type gNa: conductanceDensity +:param gKdr: +:type gKdr: conductanceDensity +:param gCa: +:type gCa: conductanceDensity +:param gKahp: +:type gKahp: conductanceDensity +:param gKC: +:type gKC: conductanceDensity +:param gc: +:type gc: conductanceDensity +:param eNa: +:type eNa: voltage +:param eCa: +:type eCa: voltage +:param eK: +:type eK: voltage +:param eL: +:type eL: voltage +:param pp: +:type pp: none +:param cm: +:type cm: specificCapacitance +:param alphac: +:type alphac: none +:param betac: +:type betac: none +:param gNmda: +:type gNmda: conductanceDensity +:param gAmpa: +:type gAmpa: conductanceDensity +:param qd0: +:type qd0: none + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + The Hindmarsh Rose model is a simplified point cell model which captures complex firing patterns of single neurons, such as periodic and chaotic bursting. It has a fast spiking subsystem, which is a generalization of the FitzHugh-Nagumo system, coupled to a slower subsystem which allows the model to fire bursts. The dynamical variables x, y, z correspond to the membrane potential, a recovery variable, and a slower adaptation current, respectively. See Hindmarsh J. L. , and Rose R. M. ( 1984 ) A model of neuronal bursting using three coupled first order differential equations. Proc. R. Soc. London, Ser. B 221:87–102. +\n +:param a: cubic term in x nullcline +:type a: none +:param b: quadratic term in x nullcline +:type b: none +:param c: constant term in y nullcline +:type c: none +:param d: quadratic term in y nullcline +:type d: none +:param r: timescale separation between slow and fast subsystem ( r greater than 0; r much less than 1 ) +:type r: none +:param s: related to adaptation +:type s: none +:param x1: related to the system's resting potential +:type x1: none +:param v_scaling: scaling of x for physiological membrane potential +:type v_scaling: voltage +:param x0: +:type x0: none +:param y0: +:type y0: none +:param z0: +:type z0: none +:param C: Total capacitance of the cell membrane +:type C: capacitance + + + + + + + + + + + + + + + + + + + + + + Cell with **segment** s specified in a **morphology** element along with details on its **biophysicalProperties** . NOTE: this can only be correctly simulated using jLEMS when there is a single segment in the cell, and **v** of this cell represents the membrane potential in that isopotential segment. + + + + + + + + + + + + + + + + + + + + + + Variant of cell with two independent Ca2+ pools. Cell with **segment** s specified in a **morphology** element along with details on its **biophysicalProperties** . NOTE: this can only be correctly simulated using jLEMS when there is a single segment in the cell, and **v** of this cell represents the membrane potential in that isopotential segment. + + + + + + + + + + + + + The collection of **segment** s which specify the 3D structure of the cell, along with a number of **segmentGroup** s + + + + + + + + + + + + + + A segment defines the smallest unit within a possibly branching structure ( **morphology** ), such as a dendrite or axon. Its **id** should be a nonnegative integer ( usually soma/root = 0 ). Its end points are given by the **proximal** and **distal** points. The **proximal** point can be omitted, usually because it is the same as a point on the **parent** segment, see **proximal** for details. **parent** specifies the parent segment. The first segment of a **cell** ( with no **parent** ) usually represents the soma. The shape is normally a cylinder ( radii of the **proximal** and **distal** equal, but positions different ) or a conical frustum ( radii and positions different ). If the x, y, x positions of the **proximal** and **distal** are equal, the segment can be interpreted as a sphere, and in this case the radii of these points must be equal. NOTE: LEMS does not yet support multicompartmental modelling, so the Dynamics here is only appropriate for single compartment modelling. + + + + + + + + + + + + + + + + + + + + + + + + + + Base type for ComponentTypes which specify an ( **x,** **y,** **z** ) coordinate along with a **diameter.** Note: no dimension used in the attributes for these coordinates! These are assumed to have dimension micrometer ( 10^-6 m ). This is due to micrometers being the default option for the majority of neuronal morphology formats, and dimensions are omitted here to facilitate reading and writing of morphologies in NeuroML. +\n +:param x: x coordinate of the point. Note: no dimension used, see description of **point3DWithDiam** for details. +:type x: none +:param y: y coordinate of the ppoint. Note: no dimension used, see description of **point3DWithDiam** for details. +:type y: none +:param z: z coordinate of the ppoint. Note: no dimension used, see description of **point3DWithDiam** for details. +:type z: none +:param diameter: Diameter of the ppoint. Note: no dimension used, see description of **point3DWithDiam** for details. +:type diameter: none + + + + + + + + + + + + + + + A method to describe a group of **segment** s in a **morphology** , e. g. soma_group, dendrite_group, axon_group. While a name is useful to describe the group, the **neuroLexId** attribute can be used to explicitly specify the meaning of the group, e. g. sao1044911821 for 'Neuronal Cell Body', sao1211023249 for 'Dendrite'. The **segment** s in this group can be specified as: a list of individual **member** segments; a **path** , all of the segments along which should be included; a **subTree** of the **cell** to include; other segmentGroups to **include** ( so all segments from those get included here ). An **inhomogeneousParameter** can be defined on the region of the cell specified by this group ( see **variableParameter** for usage ). + + + + + + + + + + + + + + + + + + + + + An inhomogeneous parameter specified across the **segmentGroup** ( see **variableParameter** for usage ). + + + + + + + + + + + + + + + + Allowed metrics for InhomogeneousParam + + + + + + + + What to do at the proximal point when creating an inhomogeneous parameter + + + + + + + + + + + What to do at the distal point when creating an inhomogeneous parameter + + + + + + + + + + + A single identified **segment** which is part of the **segmentGroup** + + + + + + + + + + + Include all members of another **segmentGroup** in this group + + + + + + + + + + + Include all the **segment** s between those specified by **from** and **to** , inclusive + + + + + + + + + + + + + + Include all the **segment** s distal to that specified by **from** in the **segmentGroup** + + + + + + + + + + + + + + + + + + + + + + + + The biophysical properties of the **cell** , including the **membraneProperties** and the **intracellularProperties** + + + + + + + + + + + + + + + The biophysical properties of the **cell** , including the **membraneProperties2CaPools** and the **intracellularProperties2CaPools** for a cell with two Ca pools + + + + + + + + + + + + + + + Properties specific to the membrane, such as the **populations** of channels, **channelDensities,** **specificCapacitance,** etc. + + + + + + + + + + + + + + + + + + + + + + + + + Variant of membraneProperties with 2 independent Ca pools + + + + + + + + + + + + + + Membrane potential at which to emit a spiking event. Note, usually the spiking event will not be emitted again until the membrane potential has fallen below this value and rises again to cross it in a positive direction +\n +:param value: +:type value: voltage + + + + + + + + + + + + + Capacitance per unit area +\n +:param value: +:type value: specificCapacitance + + + + + + + + + + + + + Explicitly set initial membrane potential for the cell +\n +:param value: +:type value: voltage + + + + + + + + + + + + + The resistivity, or specific axial resistance, of the cytoplasm +\n +:param value: +:type value: resistivity + + + + + + + + + + + + + Population of a **number** of ohmic ion channels. These each produce a conductance **channelg** across a reversal potential **erev,** giving a total current **i.** Note that active membrane currents are more frequently specified as a density over an area of the **cell** using **channelDensity** +\n +:param number: The number of channels present. This will be multiplied by the time varying conductance of the individual ion channel ( which extends **baseIonChannel** ) to produce the total conductance +:type number: none +:param erev: The reversal potential of the current produced +:type erev: voltage + + + + + + + + + + + + + + + + + + + + + + + + Specifies a time varying ohmic conductance density, which is distributed on a region of the **cell.** The conductance density of the channel is not uniform, but is set using the **variableParameter** . Note, there is no dynamical description of this in LEMS yet, as this type only makes sense for multicompartmental cells. A ComponentType for this needs to be present to enable export of NeuroML 2 multicompartmental cells via LEMS/jNeuroML to NEURON +\n +:param erev: The reversal potential of the current produced +:type erev: voltage + + + + + + + + + + + + + + + + + + + + Specifies a time varying conductance density, which is distributed on a region of the **cell,** and whose reversal potential is calculated from the Nernst equation. Hard coded for Ca only!. The conductance density of the channel is not uniform, but is set using the **variableParameter** . Note, there is no dynamical description of this in LEMS yet, as this type only makes sense for multicompartmental cells. A ComponentType for this needs to be present to enable export of NeuroML 2 multicompartmental cells via LEMS/jNeuroML to NEURON + + + + + + + + + + + + + + + + + + Specifies a time varying conductance density, which is distributed on a region of the **cell,** and whose current is calculated from the Goldman-Hodgkin-Katz equation. Hard coded for Ca only!. The conductance density of the channel is not uniform, but is set using the **variableParameter** . Note, there is no dynamical description of this in LEMS yet, as this type only makes sense for multicompartmental cells. A ComponentType for this needs to be present to enable export of NeuroML 2 multicompartmental cells via LEMS/jNeuroML to NEURON + + + + + + + + + + + + + + + + + + Specifies a time varying ohmic conductance density, **gDensity,** which is distributed on an area of the **cell** ( specified in **membraneProperties** ) with fixed reversal potential **erev** producing a current density **iDensity** +\n +:param erev: The reversal potential of the current produced +:type erev: voltage +:param condDensity: +:type condDensity: conductanceDensity + + + + + + + + + + + + + + + + + + + + + + + + Same as **channelDensity** , but with a **vShift** parameter to change voltage activation of gates. The exact usage of **vShift** in expressions for rates is determined by the individual gates. +\n +:param vShift: +:type vShift: voltage +:param erev: The reversal potential of the current produced +:type erev: voltage +:param condDensity: +:type condDensity: conductanceDensity + + + + + + + + + + + + Specifies a time varying conductance density, **gDensity,** which is distributed on an area of the **cell,** producing a current density **iDensity** and whose reversal potential is calculated from the Nernst equation. Hard coded for Ca only! See https://github.com/OpenSourceBrain/ghk-nernst. +\n +:param condDensity: +:type condDensity: conductanceDensity + + + + + + + + + + + + + + + + + + + + + + + This component is similar to the original component type **channelDensityNernst** but it is changed in order to have a reversal potential that depends on a second independent Ca++ pool ( ca2 ). See https://github.com/OpenSourceBrain/ghk-nernst. +\n +:param condDensity: +:type condDensity: conductanceDensity + + + + + + + + + + + + Specifies a time varying conductance density, **gDensity,** which is distributed on an area of the cell, producing a current density **iDensity** and whose reversal potential is calculated from the Goldman Hodgkin Katz equation. Hard coded for Ca only! See https://github.com/OpenSourceBrain/ghk-nernst. +\n +:param permeability: +:type permeability: permeability + + + + + + + + + + + + + + + + + + + + Time varying conductance density, **gDensity,** which is distributed on an area of the cell, producing a current density **iDensity.** Modified version of Jaffe et al. 1994 ( used also in Lawrence et al. 2006 ). See https://github.com/OpenSourceBrain/ghk-nernst. +\n +:param condDensity: +:type condDensity: conductanceDensity + + + + + + + + + + + + + + + + + + + + + Specifies a **parameter** ( e. g. condDensity ) which can vary its value across a **segmentGroup.** The value is calculated from **value** attribute of the **inhomogeneousValue** subelement. This element is normally a child of **channelDensityNonUniform** , **channelDensityNonUniformNernst** or **channelDensityNonUniformGHK** and is used to calculate the value of the conductance, etc. which will vary on different parts of the cell. The **segmentGroup** specified here needs to define an **inhomogeneousParameter** ( referenced from **inhomogeneousParameter** in the **inhomogeneousValue** ), which calculates a **variable** ( e. g. p ) varying across the cell ( e. g. based on the path length from soma ), which is then used in the **value** attribute of the **inhomogeneousValue** ( so for example condDensity = f( p ) ) + + + + + + + + + + + Specifies the **value** of an **inhomogeneousParameter.** For usage see **variableParameter** + + + + + + + + + + + + + Description of a chemical species identified by **ion,** which has internal, **concentration,** and external, **extConcentration** values for its concentration +\n +:param initialConcentration: +:type initialConcentration: concentration +:param initialExtConcentration: +:type initialExtConcentration: concentration + + + + + + + + + + + + + + + + + + + + + + + + + + + Biophysical properties related to the intracellular space within the **cell** , such as the **resistivity** and the list of ionic **species** present. **caConc** and **caConcExt** are explicitly exposed here to facilitate accessing these values from other Components, even though **caConcExt** is clearly not an intracellular property + + + + + + + + + + + + + + Variant of intracellularProperties with 2 independent Ca pools + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Generates a constant current pulse of a certain **amplitude** for a specified **duration** after a **delay.** Scaled by **weight,** if set +\n +:param delay: Delay before change in current. Current is zero prior to this. +:type delay: time +:param duration: Duration for holding current at amplitude. Current is zero after delay + duration. +:type duration: time +:param amplitude: Amplitude of current pulse +:type amplitude: current + + + + + + + + + + + + + + Dimensionless equivalent of **pulseGenerator** . Generates a constant current pulse of a certain **amplitude** for a specified **duration** after a **delay.** Scaled by **weight,** if set +\n +:param delay: Delay before change in current. Current is zero prior to this. +:type delay: time +:param duration: Duration for holding current at amplitude. Current is zero after delay + duration. +:type duration: time +:param amplitude: Amplitude of current pulse +:type amplitude: none + + + + + + + + + + + + + + Generates a sinusoidally varying current after a time **delay,** for a fixed **duration.** The **period** and maximum **amplitude** of the current can be set as well as the **phase** at which to start. Scaled by **weight,** if set +\n +:param phase: Phase ( between 0 and 2*pi ) at which to start the varying current ( i. e. at time given by delay ) +:type phase: none +:param delay: Delay before change in current. Current is zero prior to this. +:type delay: time +:param duration: Duration for holding current at amplitude. Current is zero after delay + duration. +:type duration: time +:param amplitude: Maximum amplitude of current +:type amplitude: current +:param period: Time period of oscillation +:type period: time + + + + + + + + + + + + + + + + Dimensionless equivalent of **sineGenerator** . Generates a sinusoidally varying current after a time **delay,** for a fixed **duration.** The **period** and maximum **amplitude** of the current can be set as well as the **phase** at which to start. Scaled by **weight,** if set +\n +:param phase: Phase ( between 0 and 2*pi ) at which to start the varying current ( i. e. at time given by delay ) +:type phase: none +:param delay: Delay before change in current. Current is zero prior to this. +:type delay: time +:param duration: Duration for holding current at amplitude. Current is zero after delay + duration. +:type duration: time +:param amplitude: Maximum amplitude of current +:type amplitude: none +:param period: Time period of oscillation +:type period: time + + + + + + + + + + + + + + + + Generates a ramping current after a time **delay,** for a fixed **duration.** During this time the current steadily changes from **startAmplitude** to **finishAmplitude.** Scaled by **weight,** if set +\n +:param delay: Delay before change in current. Current is baselineAmplitude prior to this. +:type delay: time +:param duration: Duration for holding current at amplitude. Current is baselineAmplitude after delay + duration. +:type duration: time +:param startAmplitude: Amplitude of linearly varying current at time delay +:type startAmplitude: current +:param finishAmplitude: Amplitude of linearly varying current at time delay + duration +:type finishAmplitude: current +:param baselineAmplitude: Amplitude of current before time delay, and after time delay + duration +:type baselineAmplitude: current + + + + + + + + + + + + + + + + Dimensionless equivalent of **rampGenerator** . Generates a ramping current after a time **delay,** for a fixed **duration.** During this time the dimensionless current steadily changes from **startAmplitude** to **finishAmplitude.** Scaled by **weight,** if set +\n +:param delay: Delay before change in current. Current is baselineAmplitude prior to this. +:type delay: time +:param duration: Duration for holding current at amplitude. Current is baselineAmplitude after delay + duration. +:type duration: time +:param startAmplitude: Amplitude of linearly varying current at time delay +:type startAmplitude: none +:param finishAmplitude: Amplitude of linearly varying current at time delay + duration +:type finishAmplitude: none +:param baselineAmplitude: Amplitude of current before time delay, and after time delay + duration +:type baselineAmplitude: none + + + + + + + + + + + + + + + + Generates a current which is the sum of all its child **basePointCurrent** element, e. g. can be a combination of **pulseGenerator** , **sineGenerator** elements producing a single **i.** Scaled by **weight,** if set + + + + + + + + + + + + + + + Generates a current which is the sum of all its child **basePointCurrentDL** elements, e. g. can be a combination of **pulseGeneratorDL** , **sineGeneratorDL** elements producing a single **i.** Scaled by **weight,** if set + + + + + + + + + + + + + + + Voltage clamp. Applies a variable current **i** to try to keep parent at **targetVoltage.** Not yet fully tested!!! Consider using voltageClampTriple!! +\n +:param delay: Delay before change in current. Current is zero prior to this. +:type delay: time +:param duration: Duration for attempting to keep parent at targetVoltage. Current is zero after delay + duration. +:type duration: time +:param targetVoltage: Current will be applied to try to get parent to this target voltage +:type targetVoltage: voltage +:param simpleSeriesResistance: Current will be calculated by the difference in voltage between the target and parent, divided by this value +:type simpleSeriesResistance: resistance + + + + + + + + + + + + + + + Voltage clamp with 3 clamp levels. Applies a variable current **i** ( through **simpleSeriesResistance** ) to try to keep parent cell at **conditioningVoltage** until time **delay,** **testingVoltage** until **delay** + **duration,** and **returnVoltage** afterwards. Only enabled if **active** = 1. +\n +:param active: Whether the voltage clamp is active ( 1 ) or inactive ( 0 ). +:type active: none +:param delay: Delay before switching from conditioningVoltage to testingVoltage. +:type delay: time +:param duration: Duration to hold at testingVoltage. +:type duration: time +:param conditioningVoltage: Target voltage before time delay +:type conditioningVoltage: voltage +:param testingVoltage: Target voltage between times delay and delay + duration +:type testingVoltage: voltage +:param returnVoltage: Target voltage after time duration +:type returnVoltage: voltage +:param simpleSeriesResistance: Current will be calculated by the difference in voltage between the target and parent, divided by this value +:type simpleSeriesResistance: resistance + + + + + + + + + + + + + + + + + + Emits a single spike at the specified **time** +\n +:param time: Time at which to emit one spike event +:type time: time + + + + + + + + + + + + Set of spike ComponentTypes, each emitting one spike at a certain time. Can be used to feed a predetermined spike train into a cell + + + + + + + + + + + + + Spike array connected to a single **synapse,** producing a current triggered by each **spike** in the array. + + + + + + + + + + + + + + + Simple generator of spikes at a regular interval set by **period** +\n +:param period: Time between spikes. The first spike will be emitted after this time. +:type period: time + + + + + + + + + + + + Generator of spikes with a random interspike interval of at least **minISI** and at most **maxISI** +\n +:param maxISI: Maximum interspike interval +:type maxISI: time +:param minISI: Minimum interspike interval +:type minISI: time + + + + + + + + + + + + + Generator of spikes whose ISI is distributed according to an exponential PDF with scale: 1 / **averageRate** +\n +:param averageRate: The average rate at which spikes are emitted +:type averageRate: per_time + + + + + + + + + + + + Generator of spikes whose ISI distribution is the maximum entropy distribution over [ **minimumISI,** +infinity ) with mean: 1 / **averageRate** +\n +:param minimumISI: The minimum interspike interval +:type minimumISI: time +:param averageRate: The average rate at which spikes are emitted +:type averageRate: per_time + + + + + + + + + + + + Poisson spike generator firing at **averageRate,** which is connected to single **synapse** that is triggered every time a spike is generated, producing an input current. See also **transientPoissonFiringSynapse** . +\n +:param averageRate: The average rate at which spikes are emitted +:type averageRate: per_time + + + + + + + + + + + + + + Poisson spike generator firing at **averageRate** after a **delay** and for a **duration,** connected to single **synapse** that is triggered every time a spike is generated, providing an input current. Similar to ComponentType **poissonFiringSynapse** . +\n +:param averageRate: +:type averageRate: per_time +:param delay: +:type delay: time +:param duration: +:type duration: time + + + + + + + + + + + + + + + + + + + Network containing: **population** s ( potentially of type **populationList** , and so specifying a list of cell **location** s ); **projection** s ( with lists of **connection** s ) and/or **explicitConnection** s; and **inputList** s ( with lists of **input** s ) and/or **explicitInput** s. Note: often in NeuroML this will be of type **networkWithTemperature** if there are temperature dependent elements ( e. g. ion channels ). + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Initial attempt to specify 3D region for placing cells. Work in progress. . . + + + + + + + + + + + + + + + A population of components, with just one parameter for the **size,** i. e. number of components to create. Note: quite often this is used with type= **populationList** which means the size is determined by the number of **instance** s ( with **location** s ) in the list. The **size** attribute is still set, and there will be a validation error if this does not match the number in the list. +\n +:param size: Number of instances of this Component to create when the population is instantiated +:type size: none + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Specifies a single instance of a component in a **population** ( placed at **location** ). + + + + + + + + + + + + + + + + + + + + Specifies the ( x, y, z ) location of a single **instance** of a component in a **population** +\n +:param x: +:type x: none +:param y: +:type y: none +:param z: +:type z: none + + + + + + + + + + + + + + + + + + + + + + + + + Explicit event connection between named components, which gets processed via a new instance of a **synapse** component which is created on the target component + + + + + + + + + + + + + + + Base for projection (set of synaptic connections) between two populations + + + + + + + + + + + Projection from one population, **presynapticPopulation** to another, **postsynapticPopulation,** through **synapse.** Contains lists of **connection** or **connectionWD** elements. + + + + + + + + + + + + + + + Base of all synaptic connections (chemical/electrical/analog, etc.) inside projections + + + + + + + + + + + Base of all synaptic connections with preCellId, postSegmentId, etc. + Note: this is not the best name for these attributes, since Id is superfluous, hence BaseConnectionNewFormat + + + + + + + + + + + + + + + Base of all synaptic connections with preCell, postSegment, etc. + See BaseConnectionOldFormat + + + + + + + + + + + + + + + Event connection directly between named components, which gets processed via a new instance of a **synapse** component which is created on the target component. Normally contained inside a **projection** element. + + + + + + + + + + Event connection between named components, which gets processed via a new instance of a synapse component which is created on the target component, includes setting of **weight** and **delay** for the synaptic connection +\n +:param weight: +:type weight: none +:param delay: +:type delay: time + + + + + + + + + + + + + A projection between **presynapticPopulation** to another **postsynapticPopulation** through gap junctions. + + + + + + + + + + + + + + + To enable connections between populations through gap junctions. + + + + + + + + + + + To enable connections between populations through gap junctions. Populations need to be of type **populationList** and contain **instance** and **location** elements. + + + + + + + + + To enable connections between populations through gap junctions. Populations need to be of type **populationList** and contain **instance** and **location** elements. Includes setting of **weight** for the connection +\n +:param weight: +:type weight: none + + + + + + + + + + + + A projection between **presynapticPopulation** and **postsynapticPopulation** through components **preComponent** at the start and **postComponent** at the end of a **continuousConnection** or **continuousConnectionInstance** . Can be used for analog synapses. + + + + + + + + + + + + + + + An instance of a connection in a **continuousProjection** between **presynapticPopulation** to another **postsynapticPopulation** through a **preComponent** at the start and **postComponent** at the end. Can be used for analog synapses. + + + + + + + + + + + + An instance of a connection in a **continuousProjection** between **presynapticPopulation** to another **postsynapticPopulation** through a **preComponent** at the start and **postComponent** at the end. Populations need to be of type **populationList** and contain **instance** and **location** elements. Can be used for analog synapses. + + + + + + + + + An instance of a connection in a **continuousProjection** between **presynapticPopulation** to another **postsynapticPopulation** through a **preComponent** at the start and **postComponent** at the end. Populations need to be of type **populationList** and contain **instance** and **location** elements. Can be used for analog synapses. Includes setting of **weight** for the connection +\n +:param weight: +:type weight: none + + + + + + + + + + + + An explicit input ( anything which extends **basePointCurrent** ) to a target cell in a population + + + + + + + + + + + + + An explicit list of **input** s to a **population.** + + + + + + + + + + + + + + + + Specifies a single input to a **target,** optionally giving the **segmentId** ( default 0 ) and **fractionAlong** the segment ( default 0. 5 ). + + + + + + + + + + + + + + Specifies input lists. Can set **weight** to scale individual inputs. +\n +:param weight: +:type weight: none + + + + + + + + + + + + + + + Base type of any PyNN standard cell model. Note: membrane potential **v** has dimensions voltage, but all other parameters are dimensionless. This is to facilitate translation to and from PyNN scripts in Python, where these parameters have implicit units, see http://neuralensemble.org/trac/PyNN/wiki/StandardModels +\n +:param cm: +:type cm: none +:param i_offset: +:type i_offset: none +:param tau_syn_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_E: none +:param tau_syn_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_I: none +:param v_init: +:type v_init: none + + + + + + + + + + + + + + + + Base type of any PyNN standard integrate and fire model +\n +:param tau_refrac: +:type tau_refrac: none +:param v_thresh: +:type v_thresh: none +:param tau_m: +:type tau_m: none +:param v_rest: +:type v_rest: none +:param v_reset: +:type v_reset: none +:param cm: +:type cm: none +:param i_offset: +:type i_offset: none +:param tau_syn_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_E: none +:param tau_syn_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_I: none +:param v_init: +:type v_init: none + + + + + + + + + + + + + + + + Base type of conductance based PyNN IaF cell models +\n +:param e_rev_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type e_rev_E: none +:param e_rev_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type e_rev_I: none +:param tau_refrac: +:type tau_refrac: none +:param v_thresh: +:type v_thresh: none +:param tau_m: +:type tau_m: none +:param v_rest: +:type v_rest: none +:param v_reset: +:type v_reset: none +:param cm: +:type cm: none +:param i_offset: +:type i_offset: none +:param tau_syn_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_E: none +:param tau_syn_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_I: none +:param v_init: +:type v_init: none + + + + + + + + + + + + + Leaky integrate and fire model with fixed threshold and alpha-function-shaped post-synaptic current +\n +:param tau_refrac: +:type tau_refrac: none +:param v_thresh: +:type v_thresh: none +:param tau_m: +:type tau_m: none +:param v_rest: +:type v_rest: none +:param v_reset: +:type v_reset: none +:param cm: +:type cm: none +:param i_offset: +:type i_offset: none +:param tau_syn_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_E: none +:param tau_syn_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_I: none +:param v_init: +:type v_init: none + + + + + + + + + + + Leaky integrate and fire model with fixed threshold and decaying-exponential post-synaptic current +\n +:param tau_refrac: +:type tau_refrac: none +:param v_thresh: +:type v_thresh: none +:param tau_m: +:type tau_m: none +:param v_rest: +:type v_rest: none +:param v_reset: +:type v_reset: none +:param cm: +:type cm: none +:param i_offset: +:type i_offset: none +:param tau_syn_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_E: none +:param tau_syn_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_I: none +:param v_init: +:type v_init: none + + + + + + + + + + + Leaky integrate and fire model with fixed threshold and alpha-function-shaped post-synaptic conductance +\n +:param e_rev_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type e_rev_E: none +:param e_rev_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type e_rev_I: none +:param tau_refrac: +:type tau_refrac: none +:param v_thresh: +:type v_thresh: none +:param tau_m: +:type tau_m: none +:param v_rest: +:type v_rest: none +:param v_reset: +:type v_reset: none +:param cm: +:type cm: none +:param i_offset: +:type i_offset: none +:param tau_syn_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_E: none +:param tau_syn_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_I: none +:param v_init: +:type v_init: none + + + + + + + + + + + Leaky integrate and fire model with fixed threshold and exponentially-decaying post-synaptic conductance +\n +:param e_rev_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type e_rev_E: none +:param e_rev_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type e_rev_I: none +:param tau_refrac: +:type tau_refrac: none +:param v_thresh: +:type v_thresh: none +:param tau_m: +:type tau_m: none +:param v_rest: +:type v_rest: none +:param v_reset: +:type v_reset: none +:param cm: +:type cm: none +:param i_offset: +:type i_offset: none +:param tau_syn_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_E: none +:param tau_syn_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_I: none +:param v_init: +:type v_init: none + + + + + + + + + + + Adaptive exponential integrate and fire neuron according to Brette R and Gerstner W ( 2005 ) with exponentially-decaying post-synaptic conductance +\n +:param v_spike: +:type v_spike: none +:param delta_T: +:type delta_T: none +:param tau_w: +:type tau_w: none +:param a: +:type a: none +:param b: +:type b: none +:param e_rev_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type e_rev_E: none +:param e_rev_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type e_rev_I: none +:param tau_refrac: +:type tau_refrac: none +:param v_thresh: +:type v_thresh: none +:param tau_m: +:type tau_m: none +:param v_rest: +:type v_rest: none +:param v_reset: +:type v_reset: none +:param cm: +:type cm: none +:param i_offset: +:type i_offset: none +:param tau_syn_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_E: none +:param tau_syn_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_I: none +:param v_init: +:type v_init: none + + + + + + + + + + + + + + + + Adaptive exponential integrate and fire neuron according to Brette R and Gerstner W ( 2005 ) with alpha-function-shaped post-synaptic conductance +\n +:param v_spike: +:type v_spike: none +:param delta_T: +:type delta_T: none +:param tau_w: +:type tau_w: none +:param a: +:type a: none +:param b: +:type b: none +:param e_rev_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type e_rev_E: none +:param e_rev_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type e_rev_I: none +:param tau_refrac: +:type tau_refrac: none +:param v_thresh: +:type v_thresh: none +:param tau_m: +:type tau_m: none +:param v_rest: +:type v_rest: none +:param v_reset: +:type v_reset: none +:param cm: +:type cm: none +:param i_offset: +:type i_offset: none +:param tau_syn_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_E: none +:param tau_syn_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_I: none +:param v_init: +:type v_init: none + + + + + + + + + + + Single-compartment Hodgkin-Huxley-type neuron with transient sodium and delayed-rectifier potassium currents using the ion channel models from Traub. +\n +:param gbar_K: +:type gbar_K: none +:param gbar_Na: +:type gbar_Na: none +:param g_leak: +:type g_leak: none +:param e_rev_K: +:type e_rev_K: none +:param e_rev_Na: +:type e_rev_Na: none +:param e_rev_leak: +:type e_rev_leak: none +:param v_offset: +:type v_offset: none +:param e_rev_E: +:type e_rev_E: none +:param e_rev_I: +:type e_rev_I: none +:param cm: +:type cm: none +:param i_offset: +:type i_offset: none +:param tau_syn_E: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_E: none +:param tau_syn_I: This parameter is never used in the NeuroML2 description of this cell! Any synapse producing a current can be placed on this cell +:type tau_syn_I: none +:param v_init: +:type v_init: none + + + + + + + + + + + + + + + + + + + + Base type for all PyNN synapses. Note, the current **I** produced is dimensionless, but it requires a membrane potential **v** with dimension voltage +\n +:param tau_syn: +:type tau_syn: none + + + + + + + + + + + + Conductance based synapse with instantaneous rise and single exponential decay ( with time constant tau_syn ) +\n +:param e_rev: +:type e_rev: none +:param tau_syn: +:type tau_syn: none + + + + + + + + + + + + Alpha synapse: rise time and decay time are both tau_syn. Conductance based synapse. +\n +:param e_rev: +:type e_rev: none +:param tau_syn: +:type tau_syn: none + + + + + + + + + + + + Current based synapse with instantaneous rise and single exponential decay ( with time constant tau_syn ) +\n +:param tau_syn: +:type tau_syn: none + + + + + + + + + + + + Alpha synapse: rise time and decay time are both tau_syn. Current based synapse. +\n +:param tau_syn: +:type tau_syn: none + + + + + + + + + + + + Spike source, generating spikes according to a Poisson process. +\n +:param start: +:type start: time +:param duration: +:type duration: time +:param rate: +:type rate: per_time + + + + + + + + + + + + + + + + + + Base element without ID specified *yet*, e.g. for an element with a particular requirement on its id which does not comply with NmlId (e.g. Segment needs nonNegativeInteger). + + + + + Anything which can have a unique (within its parent) id, which must be an integer zero or greater. + + + + + + + + + + Anything which can have a unique (within its parent) id of the form NmlId (spaceless combination of letters, numbers and underscore). + + + + + + + + + + Elements which can stand alone and be referenced by id, e.g. cell, morphology. + + + + + + + + + + + + + + + + From 67e0d6b573d7d269b1f7861f90310be63f05fb61 Mon Sep 17 00:00:00 2001 From: "Ankur Sinha (Ankur Sinha Gmail)" Date: Tue, 1 Oct 2024 17:23:13 +0100 Subject: [PATCH 2/8] chore: copy over schema --- neuroml/nml/NeuroML_v2.3.2.xsd | 41 +++++++++++++++++++++++++--------- 1 file changed, 30 insertions(+), 11 deletions(-) diff --git a/neuroml/nml/NeuroML_v2.3.2.xsd b/neuroml/nml/NeuroML_v2.3.2.xsd index 741f1e8..996bf5c 100644 --- a/neuroml/nml/NeuroML_v2.3.2.xsd +++ b/neuroml/nml/NeuroML_v2.3.2.xsd @@ -1,4 +1,4 @@ - + @@ -262,6 +262,17 @@ + + + A new Component based on a new defined ComponentType. + + + + + + + + LEMS Exposure (ComponentType property) @@ -476,6 +487,7 @@ + @@ -587,6 +599,7 @@ Various types of concentration model which are defined in NeuroML 2. This list will be expanded... + @@ -1060,6 +1073,20 @@ + + + Base for any model of an **ion** concentration which changes with time. Internal ( **concentration** ) and external ( **extConcentration** ) values for the concentration of the ion are given. + + + + + + + + + + + Model of an intracellular buffering mechanism for **ion** ( currently hard Coded to be calcium, due to requirement for **iCa** ) which has a baseline level **restingConc** and tends to this value with time course **decayConstant.** The ion is assumed to occupy a shell inside the membrane of thickness **shellThickness.** @@ -1074,11 +1101,7 @@ - - - - - + @@ -1099,11 +1122,7 @@ - - - - - + From 23425edec2fd2b414f0fa3d62f3621e834dbe430 Mon Sep 17 00:00:00 2001 From: "Ankur Sinha (Ankur Sinha Gmail)" Date: Tue, 1 Oct 2024 17:23:28 +0100 Subject: [PATCH 3/8] chore(nml): regen --- neuroml/nml/nml.py | 3375 +++++++++++++++++++++++++------------------- 1 file changed, 1940 insertions(+), 1435 deletions(-) diff --git a/neuroml/nml/nml.py b/neuroml/nml/nml.py index b5ea5db..1fd72df 100644 --- a/neuroml/nml/nml.py +++ b/neuroml/nml/nml.py @@ -2,7 +2,7 @@ # -*- coding: utf-8 -*- # -# Generated Fri Sep 13 14:23:30 2024 by generateDS.py version 2.44.1. +# Generated Tue Oct 1 17:21:18 2024 by generateDS.py version 2.44.1. # Python 3.11.10 (main, Sep 9 2024, 00:00:00) [GCC 14.2.1 20240801 (Red Hat 14.2.1-1)] # # Command line options: @@ -13,10 +13,10 @@ # ('--custom-imports-template', 'gds_imports-template.py') # # Command line arguments: -# NeuroML_v2.3.1.xsd +# NeuroML_v2.3.2.xsd # # Command line: -# /home/asinha/.local/share/virtualenvs/neuroml-311-dev/bin/generateDS -o "nml.py" --use-getter-setter="none" --user-methods="helper_methods.py" --export="write validate" --custom-imports-template="gds_imports-template.py" NeuroML_v2.3.1.xsd +# /home/asinha/.local/share/virtualenvs/neuroml-311-dev/bin/generateDS -o "nml.py" --use-getter-setter="none" --user-methods="helper_methods.py" --export="write validate" --custom-imports-template="gds_imports-template.py" NeuroML_v2.3.2.xsd # # Current working directory (os.getcwd()): # nml @@ -30676,38 +30676,12 @@ def _buildChildren( # end class BaseSynapse -class FixedFactorConcentrationModel(Standalone): - """FixedFactorConcentrationModel -- Model of buffering of concentration of an ion ( currently hard coded to be calcium, due to requirement for **iCa** ) which has a baseline level **restingConc** and tends to this value with time course **decayConstant.** A fixed factor **rho** is used to scale the incoming current *independently of the size of the compartment* to produce a concentration change. - \n - :param restingConc: - :type restingConc: concentration - :param decayConstant: - :type decayConstant: time - :param rho: - :type rho: rho_factor - - """ +class ConcentrationModel(Standalone): + """ConcentrationModel -- Base for any model of an **ion** concentration which changes with time. Internal ( **concentration** ) and external ( **extConcentration** ) values for the concentration of the ion are given.""" __hash__ = GeneratedsSuper.__hash__ member_data_items_ = [ MemberSpec_("ion", "NmlId", 0, 0, {"use": "required", "name": "ion"}), - MemberSpec_( - "resting_conc", - "Nml2Quantity_concentration", - 0, - 0, - {"use": "required", "name": "resting_conc"}, - ), - MemberSpec_( - "decay_constant", - "Nml2Quantity_time", - 0, - 0, - {"use": "required", "name": "decay_constant"}, - ), - MemberSpec_( - "rho", "Nml2Quantity_rhoFactor", 0, 0, {"use": "required", "name": "rho"} - ), ] subclass = None superclass = Standalone @@ -30720,448 +30694,6 @@ def __init__( properties: "list of Property(s) (optional)" = None, annotation: "a Annotation (optional)" = None, ion: "a NmlId (required)" = None, - resting_conc: "a Nml2Quantity_concentration (required)" = None, - decay_constant: "a Nml2Quantity_time (required)" = None, - rho: "a Nml2Quantity_rhoFactor (required)" = None, - gds_collector_=None, - **kwargs_, - ): - self.gds_collector_ = gds_collector_ - self.gds_elementtree_node_ = None - self.original_tagname_ = None - self.parent_object_ = kwargs_.get("parent_object_") - self.ns_prefix_ = None - super(globals().get("FixedFactorConcentrationModel"), self).__init__( - id, metaid, notes, properties, annotation, **kwargs_ - ) - self.ion = _cast(None, ion) - self.ion_nsprefix_ = None - self.resting_conc = _cast(None, resting_conc) - self.resting_conc_nsprefix_ = None - self.decay_constant = _cast(None, decay_constant) - self.decay_constant_nsprefix_ = None - self.rho = _cast(None, rho) - self.rho_nsprefix_ = None - - def factory(*args_, **kwargs_): - if CurrentSubclassModule_ is not None: - subclass = getSubclassFromModule_( - CurrentSubclassModule_, FixedFactorConcentrationModel - ) - if subclass is not None: - return subclass(*args_, **kwargs_) - if FixedFactorConcentrationModel.subclass: - return FixedFactorConcentrationModel.subclass(*args_, **kwargs_) - else: - return FixedFactorConcentrationModel(*args_, **kwargs_) - - factory = staticmethod(factory) - - def validate_NmlId(self, value): - # Validate type NmlId, a restriction on xs:string. - if ( - value is not None - and Validate_simpletypes_ - and self.gds_collector_ is not None - ): - if not isinstance(value, str): - lineno = self.gds_get_node_lineno_() - self.gds_collector_.add_message( - 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' - % { - "value": value, - "lineno": lineno, - } - ) - return False - if not self.gds_validate_simple_patterns( - self.validate_NmlId_patterns_, value - ): - self.gds_collector_.add_message( - 'Value "%s" does not match xsd pattern restrictions: %s' - % ( - encode_str_2_3(value), - self.validate_NmlId_patterns_, - ) - ) - - validate_NmlId_patterns_ = [["^([a-zA-Z_][a-zA-Z0-9_]*)$"]] - - def validate_Nml2Quantity_concentration(self, value): - # Validate type Nml2Quantity_concentration, a restriction on xs:string. - if ( - value is not None - and Validate_simpletypes_ - and self.gds_collector_ is not None - ): - if not isinstance(value, str): - lineno = self.gds_get_node_lineno_() - self.gds_collector_.add_message( - 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' - % { - "value": value, - "lineno": lineno, - } - ) - return False - if not self.gds_validate_simple_patterns( - self.validate_Nml2Quantity_concentration_patterns_, value - ): - self.gds_collector_.add_message( - 'Value "%s" does not match xsd pattern restrictions: %s' - % ( - encode_str_2_3(value), - self.validate_Nml2Quantity_concentration_patterns_, - ) - ) - - validate_Nml2Quantity_concentration_patterns_ = [ - ["^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(mol_per_m3|mol_per_cm3|M|mM))$"] - ] - - def validate_Nml2Quantity_time(self, value): - # Validate type Nml2Quantity_time, a restriction on xs:string. - if ( - value is not None - and Validate_simpletypes_ - and self.gds_collector_ is not None - ): - if not isinstance(value, str): - lineno = self.gds_get_node_lineno_() - self.gds_collector_.add_message( - 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' - % { - "value": value, - "lineno": lineno, - } - ) - return False - if not self.gds_validate_simple_patterns( - self.validate_Nml2Quantity_time_patterns_, value - ): - self.gds_collector_.add_message( - 'Value "%s" does not match xsd pattern restrictions: %s' - % ( - encode_str_2_3(value), - self.validate_Nml2Quantity_time_patterns_, - ) - ) - - validate_Nml2Quantity_time_patterns_ = [ - ["^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(s|ms))$"] - ] - - def validate_Nml2Quantity_rhoFactor(self, value): - # Validate type Nml2Quantity_rhoFactor, a restriction on xs:string. - if ( - value is not None - and Validate_simpletypes_ - and self.gds_collector_ is not None - ): - if not isinstance(value, str): - lineno = self.gds_get_node_lineno_() - self.gds_collector_.add_message( - 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' - % { - "value": value, - "lineno": lineno, - } - ) - return False - if not self.gds_validate_simple_patterns( - self.validate_Nml2Quantity_rhoFactor_patterns_, value - ): - self.gds_collector_.add_message( - 'Value "%s" does not match xsd pattern restrictions: %s' - % ( - encode_str_2_3(value), - self.validate_Nml2Quantity_rhoFactor_patterns_, - ) - ) - - validate_Nml2Quantity_rhoFactor_patterns_ = [ - [ - "^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(mol_per_m_per_A_per_s|mol_per_cm_per_uA_per_ms))$" - ] - ] - - def has__content(self): - if super(FixedFactorConcentrationModel, self).has__content(): - return True - else: - return False - - def export( - self, - outfile, - level, - namespaceprefix_="", - namespacedef_="", - name_="FixedFactorConcentrationModel", - pretty_print=True, - ): - imported_ns_def_ = GenerateDSNamespaceDefs_.get("FixedFactorConcentrationModel") - if imported_ns_def_ is not None: - namespacedef_ = imported_ns_def_ - if pretty_print: - eol_ = "\n" - else: - eol_ = "" - if ( - self.original_tagname_ is not None - and name_ == "FixedFactorConcentrationModel" - ): - name_ = self.original_tagname_ - if UseCapturedNS_ and self.ns_prefix_: - namespaceprefix_ = self.ns_prefix_ + ":" - showIndent(outfile, level, pretty_print) - outfile.write( - "<%s%s%s" - % ( - namespaceprefix_, - name_, - namespacedef_ and " " + namespacedef_ or "", - ) - ) - already_processed = set() - self._exportAttributes( - outfile, - level, - already_processed, - namespaceprefix_, - name_="FixedFactorConcentrationModel", - ) - if self.has__content(): - outfile.write(">%s" % (eol_,)) - self._exportChildren( - outfile, - level + 1, - namespaceprefix_, - namespacedef_, - name_="FixedFactorConcentrationModel", - pretty_print=pretty_print, - ) - showIndent(outfile, level, pretty_print) - outfile.write("%s" % (namespaceprefix_, name_, eol_)) - else: - outfile.write("/>%s" % (eol_,)) - - def _exportAttributes( - self, - outfile, - level, - already_processed, - namespaceprefix_="", - name_="FixedFactorConcentrationModel", - ): - super(FixedFactorConcentrationModel, self)._exportAttributes( - outfile, - level, - already_processed, - namespaceprefix_, - name_="FixedFactorConcentrationModel", - ) - if self.ion is not None and "ion" not in already_processed: - already_processed.add("ion") - outfile.write( - " ion=%s" - % ( - self.gds_encode( - self.gds_format_string(quote_attrib(self.ion), input_name="ion") - ), - ) - ) - if self.resting_conc is not None and "resting_conc" not in already_processed: - already_processed.add("resting_conc") - outfile.write( - " restingConc=%s" - % ( - self.gds_encode( - self.gds_format_string( - quote_attrib(self.resting_conc), input_name="restingConc" - ) - ), - ) - ) - if ( - self.decay_constant is not None - and "decay_constant" not in already_processed - ): - already_processed.add("decay_constant") - outfile.write( - " decayConstant=%s" - % ( - self.gds_encode( - self.gds_format_string( - quote_attrib(self.decay_constant), - input_name="decayConstant", - ) - ), - ) - ) - if self.rho is not None and "rho" not in already_processed: - already_processed.add("rho") - outfile.write( - " rho=%s" - % ( - self.gds_encode( - self.gds_format_string(quote_attrib(self.rho), input_name="rho") - ), - ) - ) - - def _exportChildren( - self, - outfile, - level, - namespaceprefix_="", - namespacedef_="", - name_="FixedFactorConcentrationModel", - fromsubclass_=False, - pretty_print=True, - ): - super(FixedFactorConcentrationModel, self)._exportChildren( - outfile, - level, - namespaceprefix_, - namespacedef_, - name_, - True, - pretty_print=pretty_print, - ) - - def validate_(self, gds_collector, recursive=False): - self.gds_collector_ = gds_collector - message_count = len(self.gds_collector_.get_messages()) - # validate simple type attributes - self.gds_validate_defined_ST_(self.validate_NmlId, self.ion, "ion") - self.gds_check_cardinality_(self.ion, "ion", required=True) - self.gds_validate_defined_ST_( - self.validate_Nml2Quantity_concentration, self.resting_conc, "resting_conc" - ) - self.gds_check_cardinality_(self.resting_conc, "resting_conc", required=True) - self.gds_validate_defined_ST_( - self.validate_Nml2Quantity_time, self.decay_constant, "decay_constant" - ) - self.gds_check_cardinality_( - self.decay_constant, "decay_constant", required=True - ) - self.gds_validate_defined_ST_( - self.validate_Nml2Quantity_rhoFactor, self.rho, "rho" - ) - self.gds_check_cardinality_(self.rho, "rho", required=True) - # validate simple type children - # validate complex type children - if recursive: - pass - return message_count == len(self.gds_collector_.get_messages()) - - def build(self, node, gds_collector_=None): - self.gds_collector_ = gds_collector_ - if SaveElementTreeNode: - self.gds_elementtree_node_ = node - already_processed = set() - self.ns_prefix_ = node.prefix - self._buildAttributes(node, node.attrib, already_processed) - for child in node: - nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] - self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) - return self - - def _buildAttributes(self, node, attrs, already_processed): - value = find_attr_value_("ion", node) - if value is not None and "ion" not in already_processed: - already_processed.add("ion") - self.ion = value - self.validate_NmlId(self.ion) # validate type NmlId - value = find_attr_value_("restingConc", node) - if value is not None and "restingConc" not in already_processed: - already_processed.add("restingConc") - self.resting_conc = value - self.validate_Nml2Quantity_concentration( - self.resting_conc - ) # validate type Nml2Quantity_concentration - value = find_attr_value_("decayConstant", node) - if value is not None and "decayConstant" not in already_processed: - already_processed.add("decayConstant") - self.decay_constant = value - self.validate_Nml2Quantity_time( - self.decay_constant - ) # validate type Nml2Quantity_time - value = find_attr_value_("rho", node) - if value is not None and "rho" not in already_processed: - already_processed.add("rho") - self.rho = value - self.validate_Nml2Quantity_rhoFactor( - self.rho - ) # validate type Nml2Quantity_rhoFactor - super(FixedFactorConcentrationModel, self)._buildAttributes( - node, attrs, already_processed - ) - - def _buildChildren( - self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None - ): - super(FixedFactorConcentrationModel, self)._buildChildren( - child_, node, nodeName_, True - ) - pass - - -# end class FixedFactorConcentrationModel - - -class DecayingPoolConcentrationModel(Standalone): - """DecayingPoolConcentrationModel -- Model of an intracellular buffering mechanism for **ion** ( currently hard Coded to be calcium, due to requirement for **iCa** ) which has a baseline level **restingConc** and tends to this value with time course **decayConstant.** The ion is assumed to occupy a shell inside the membrane of thickness **shellThickness.** - \n - :param restingConc: - :type restingConc: concentration - :param decayConstant: - :type decayConstant: time - :param shellThickness: - :type shellThickness: length - - """ - - __hash__ = GeneratedsSuper.__hash__ - member_data_items_ = [ - MemberSpec_("ion", "NmlId", 0, 0, {"use": "required", "name": "ion"}), - MemberSpec_( - "resting_conc", - "Nml2Quantity_concentration", - 0, - 0, - {"use": "required", "name": "resting_conc"}, - ), - MemberSpec_( - "decay_constant", - "Nml2Quantity_time", - 0, - 0, - {"use": "required", "name": "decay_constant"}, - ), - MemberSpec_( - "shell_thickness", - "Nml2Quantity_length", - 0, - 0, - {"use": "required", "name": "shell_thickness"}, - ), - ] - subclass = None - superclass = Standalone - - def __init__( - self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - ion: "a NmlId (required)" = None, - resting_conc: "a Nml2Quantity_concentration (required)" = None, - decay_constant: "a Nml2Quantity_time (required)" = None, - shell_thickness: "a Nml2Quantity_length (required)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -31171,30 +30703,24 @@ def __init__( self.original_tagname_ = None self.parent_object_ = kwargs_.get("parent_object_") self.ns_prefix_ = None - super(globals().get("DecayingPoolConcentrationModel"), self).__init__( + super(globals().get("ConcentrationModel"), self).__init__( id, metaid, notes, properties, annotation, extensiontype_, **kwargs_ ) self.ion = _cast(None, ion) self.ion_nsprefix_ = None - self.resting_conc = _cast(None, resting_conc) - self.resting_conc_nsprefix_ = None - self.decay_constant = _cast(None, decay_constant) - self.decay_constant_nsprefix_ = None - self.shell_thickness = _cast(None, shell_thickness) - self.shell_thickness_nsprefix_ = None self.extensiontype_ = extensiontype_ def factory(*args_, **kwargs_): if CurrentSubclassModule_ is not None: subclass = getSubclassFromModule_( - CurrentSubclassModule_, DecayingPoolConcentrationModel + CurrentSubclassModule_, ConcentrationModel ) if subclass is not None: return subclass(*args_, **kwargs_) - if DecayingPoolConcentrationModel.subclass: - return DecayingPoolConcentrationModel.subclass(*args_, **kwargs_) + if ConcentrationModel.subclass: + return ConcentrationModel.subclass(*args_, **kwargs_) else: - return DecayingPoolConcentrationModel(*args_, **kwargs_) + return ConcentrationModel(*args_, **kwargs_) factory = staticmethod(factory) @@ -31228,104 +30754,8 @@ def validate_NmlId(self, value): validate_NmlId_patterns_ = [["^([a-zA-Z_][a-zA-Z0-9_]*)$"]] - def validate_Nml2Quantity_concentration(self, value): - # Validate type Nml2Quantity_concentration, a restriction on xs:string. - if ( - value is not None - and Validate_simpletypes_ - and self.gds_collector_ is not None - ): - if not isinstance(value, str): - lineno = self.gds_get_node_lineno_() - self.gds_collector_.add_message( - 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' - % { - "value": value, - "lineno": lineno, - } - ) - return False - if not self.gds_validate_simple_patterns( - self.validate_Nml2Quantity_concentration_patterns_, value - ): - self.gds_collector_.add_message( - 'Value "%s" does not match xsd pattern restrictions: %s' - % ( - encode_str_2_3(value), - self.validate_Nml2Quantity_concentration_patterns_, - ) - ) - - validate_Nml2Quantity_concentration_patterns_ = [ - ["^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(mol_per_m3|mol_per_cm3|M|mM))$"] - ] - - def validate_Nml2Quantity_time(self, value): - # Validate type Nml2Quantity_time, a restriction on xs:string. - if ( - value is not None - and Validate_simpletypes_ - and self.gds_collector_ is not None - ): - if not isinstance(value, str): - lineno = self.gds_get_node_lineno_() - self.gds_collector_.add_message( - 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' - % { - "value": value, - "lineno": lineno, - } - ) - return False - if not self.gds_validate_simple_patterns( - self.validate_Nml2Quantity_time_patterns_, value - ): - self.gds_collector_.add_message( - 'Value "%s" does not match xsd pattern restrictions: %s' - % ( - encode_str_2_3(value), - self.validate_Nml2Quantity_time_patterns_, - ) - ) - - validate_Nml2Quantity_time_patterns_ = [ - ["^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(s|ms))$"] - ] - - def validate_Nml2Quantity_length(self, value): - # Validate type Nml2Quantity_length, a restriction on xs:string. - if ( - value is not None - and Validate_simpletypes_ - and self.gds_collector_ is not None - ): - if not isinstance(value, str): - lineno = self.gds_get_node_lineno_() - self.gds_collector_.add_message( - 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' - % { - "value": value, - "lineno": lineno, - } - ) - return False - if not self.gds_validate_simple_patterns( - self.validate_Nml2Quantity_length_patterns_, value - ): - self.gds_collector_.add_message( - 'Value "%s" does not match xsd pattern restrictions: %s' - % ( - encode_str_2_3(value), - self.validate_Nml2Quantity_length_patterns_, - ) - ) - - validate_Nml2Quantity_length_patterns_ = [ - ["^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(m|cm|um))$"] - ] - def has__content(self): - if super(DecayingPoolConcentrationModel, self).has__content(): + if super(ConcentrationModel, self).has__content(): return True else: return False @@ -31336,22 +30766,17 @@ def export( level, namespaceprefix_="", namespacedef_="", - name_="DecayingPoolConcentrationModel", + name_="ConcentrationModel", pretty_print=True, ): - imported_ns_def_ = GenerateDSNamespaceDefs_.get( - "DecayingPoolConcentrationModel" - ) + imported_ns_def_ = GenerateDSNamespaceDefs_.get("ConcentrationModel") if imported_ns_def_ is not None: namespacedef_ = imported_ns_def_ if pretty_print: eol_ = "\n" else: eol_ = "" - if ( - self.original_tagname_ is not None - and name_ == "DecayingPoolConcentrationModel" - ): + if self.original_tagname_ is not None and name_ == "ConcentrationModel": name_ = self.original_tagname_ if UseCapturedNS_ and self.ns_prefix_: namespaceprefix_ = self.ns_prefix_ + ":" @@ -31370,7 +30795,7 @@ def export( level, already_processed, namespaceprefix_, - name_="DecayingPoolConcentrationModel", + name_="ConcentrationModel", ) if self.has__content(): outfile.write(">%s" % (eol_,)) @@ -31379,7 +30804,7 @@ def export( level + 1, namespaceprefix_, namespacedef_, - name_="DecayingPoolConcentrationModel", + name_="ConcentrationModel", pretty_print=pretty_print, ) showIndent(outfile, level, pretty_print) @@ -31393,14 +30818,14 @@ def _exportAttributes( level, already_processed, namespaceprefix_="", - name_="DecayingPoolConcentrationModel", + name_="ConcentrationModel", ): - super(DecayingPoolConcentrationModel, self)._exportAttributes( + super(ConcentrationModel, self)._exportAttributes( outfile, level, already_processed, namespaceprefix_, - name_="DecayingPoolConcentrationModel", + name_="ConcentrationModel", ) if self.ion is not None and "ion" not in already_processed: already_processed.add("ion") @@ -31412,50 +30837,6 @@ def _exportAttributes( ), ) ) - if self.resting_conc is not None and "resting_conc" not in already_processed: - already_processed.add("resting_conc") - outfile.write( - " restingConc=%s" - % ( - self.gds_encode( - self.gds_format_string( - quote_attrib(self.resting_conc), input_name="restingConc" - ) - ), - ) - ) - if ( - self.decay_constant is not None - and "decay_constant" not in already_processed - ): - already_processed.add("decay_constant") - outfile.write( - " decayConstant=%s" - % ( - self.gds_encode( - self.gds_format_string( - quote_attrib(self.decay_constant), - input_name="decayConstant", - ) - ), - ) - ) - if ( - self.shell_thickness is not None - and "shell_thickness" not in already_processed - ): - already_processed.add("shell_thickness") - outfile.write( - " shellThickness=%s" - % ( - self.gds_encode( - self.gds_format_string( - quote_attrib(self.shell_thickness), - input_name="shellThickness", - ) - ), - ) - ) if self.extensiontype_ is not None and "xsi:type" not in already_processed: already_processed.add("xsi:type") outfile.write(' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"') @@ -31475,11 +30856,11 @@ def _exportChildren( level, namespaceprefix_="", namespacedef_="", - name_="DecayingPoolConcentrationModel", + name_="ConcentrationModel", fromsubclass_=False, pretty_print=True, ): - super(DecayingPoolConcentrationModel, self)._exportChildren( + super(ConcentrationModel, self)._exportChildren( outfile, level, namespaceprefix_, @@ -31495,22 +30876,6 @@ def validate_(self, gds_collector, recursive=False): # validate simple type attributes self.gds_validate_defined_ST_(self.validate_NmlId, self.ion, "ion") self.gds_check_cardinality_(self.ion, "ion", required=True) - self.gds_validate_defined_ST_( - self.validate_Nml2Quantity_concentration, self.resting_conc, "resting_conc" - ) - self.gds_check_cardinality_(self.resting_conc, "resting_conc", required=True) - self.gds_validate_defined_ST_( - self.validate_Nml2Quantity_time, self.decay_constant, "decay_constant" - ) - self.gds_check_cardinality_( - self.decay_constant, "decay_constant", required=True - ) - self.gds_validate_defined_ST_( - self.validate_Nml2Quantity_length, self.shell_thickness, "shell_thickness" - ) - self.gds_check_cardinality_( - self.shell_thickness, "shell_thickness", required=True - ) # validate simple type children # validate complex type children if recursive: @@ -31535,45 +30900,20 @@ def _buildAttributes(self, node, attrs, already_processed): already_processed.add("ion") self.ion = value self.validate_NmlId(self.ion) # validate type NmlId - value = find_attr_value_("restingConc", node) - if value is not None and "restingConc" not in already_processed: - already_processed.add("restingConc") - self.resting_conc = value - self.validate_Nml2Quantity_concentration( - self.resting_conc - ) # validate type Nml2Quantity_concentration - value = find_attr_value_("decayConstant", node) - if value is not None and "decayConstant" not in already_processed: - already_processed.add("decayConstant") - self.decay_constant = value - self.validate_Nml2Quantity_time( - self.decay_constant - ) # validate type Nml2Quantity_time - value = find_attr_value_("shellThickness", node) - if value is not None and "shellThickness" not in already_processed: - already_processed.add("shellThickness") - self.shell_thickness = value - self.validate_Nml2Quantity_length( - self.shell_thickness - ) # validate type Nml2Quantity_length value = find_attr_value_("xsi:type", node) if value is not None and "xsi:type" not in already_processed: already_processed.add("xsi:type") self.extensiontype_ = value - super(DecayingPoolConcentrationModel, self)._buildAttributes( - node, attrs, already_processed - ) + super(ConcentrationModel, self)._buildAttributes(node, attrs, already_processed) def _buildChildren( self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None ): - super(DecayingPoolConcentrationModel, self)._buildChildren( - child_, node, nodeName_, True - ) + super(ConcentrationModel, self)._buildChildren(child_, node, nodeName_, True) pass -# end class DecayingPoolConcentrationModel +# end class ConcentrationModel class HHTime(BaseWithoutId): @@ -39102,6 +38442,19 @@ class NeuroMLDocument(Standalone): }, None, ), + MemberSpec_( + "concentration_model", + "ConcentrationModel", + 1, + 1, + { + "maxOccurs": "unbounded", + "minOccurs": "0", + "name": "concentrationModel", + "type": "ConcentrationModel", + }, + None, + ), MemberSpec_( "decaying_pool_concentration_models", "DecayingPoolConcentrationModel", @@ -39882,6 +39235,19 @@ class NeuroMLDocument(Standalone): }, None, ), + MemberSpec_( + "Component", + "Component", + 1, + 1, + { + "maxOccurs": "unbounded", + "minOccurs": "0", + "name": "Component", + "type": "Component", + }, + None, + ), ] subclass = None superclass = Standalone @@ -39901,6 +39267,7 @@ def __init__( ion_channel_hhs: "list of IonChannelHH(s) (optional)" = None, ion_channel_v_shifts: "list of IonChannelVShift(s) (optional)" = None, ion_channel_kses: "list of IonChannelKS(s) (optional)" = None, + concentration_model: "list of ConcentrationModel(s) (optional)" = None, decaying_pool_concentration_models: "list of DecayingPoolConcentrationModel(s) (optional)" = None, fixed_factor_concentration_models: "list of FixedFactorConcentrationModel(s) (optional)" = None, alpha_current_synapses: "list of AlphaCurrentSynapse(s) (optional)" = None, @@ -39961,6 +39328,7 @@ def __init__( SpikeSourcePoisson: "list of SpikeSourcePoisson(s) (optional)" = None, networks: "list of Network(s) (optional)" = None, ComponentType: "list of ComponentType(s) (optional)" = None, + Component: "list of Component(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -40012,6 +39380,11 @@ def __init__( else: self.ion_channel_kses = ion_channel_kses self.ion_channel_kses_nsprefix_ = None + if concentration_model is None: + self.concentration_model = [] + else: + self.concentration_model = concentration_model + self.concentration_model_nsprefix_ = None if decaying_pool_concentration_models is None: self.decaying_pool_concentration_models = [] else: @@ -40312,6 +39685,11 @@ def __init__( else: self.ComponentType = ComponentType self.ComponentType_nsprefix_ = None + if Component is None: + self.Component = [] + else: + self.Component = Component + self.Component_nsprefix_ = None def factory(*args_, **kwargs_): if CurrentSubclassModule_ is not None: @@ -40335,6 +39713,7 @@ def has__content(self): or self.ion_channel_hhs or self.ion_channel_v_shifts or self.ion_channel_kses + or self.concentration_model or self.decaying_pool_concentration_models or self.fixed_factor_concentration_models or self.alpha_current_synapses @@ -40395,6 +39774,7 @@ def has__content(self): or self.SpikeSourcePoisson or self.networks or self.ComponentType + or self.Component or super(NeuroMLDocument, self).has__content() ): return True @@ -40596,6 +39976,20 @@ def _exportChildren( name_="ionChannelKS", pretty_print=pretty_print, ) + for concentrationModel_ in self.concentration_model: + namespaceprefix_ = ( + self.concentration_model_nsprefix_ + ":" + if (UseCapturedNS_ and self.concentration_model_nsprefix_) + else "" + ) + concentrationModel_.export( + outfile, + level, + namespaceprefix_, + namespacedef_="", + name_="concentrationModel", + pretty_print=pretty_print, + ) for decayingPoolConcentrationModel_ in self.decaying_pool_concentration_models: namespaceprefix_ = ( self.decaying_pool_concentration_models_nsprefix_ + ":" @@ -41438,6 +40832,20 @@ def _exportChildren( name_="ComponentType", pretty_print=pretty_print, ) + for Component_ in self.Component: + namespaceprefix_ = ( + self.Component_nsprefix_ + ":" + if (UseCapturedNS_ and self.Component_nsprefix_) + else "" + ) + Component_.export( + outfile, + level, + namespaceprefix_, + namespacedef_="", + name_="Component", + pretty_print=pretty_print, + ) def validate_(self, gds_collector, recursive=False): self.gds_collector_ = gds_collector @@ -41478,6 +40886,12 @@ def validate_(self, gds_collector, recursive=False): self.gds_check_cardinality_( self.ion_channel_kses, "ion_channel_kses", min_occurs=0, max_occurs=9999999 ) + self.gds_check_cardinality_( + self.concentration_model, + "concentration_model", + min_occurs=0, + max_occurs=9999999, + ) self.gds_check_cardinality_( self.decaying_pool_concentration_models, "decaying_pool_concentration_models", @@ -41751,6 +41165,9 @@ def validate_(self, gds_collector, recursive=False): self.gds_check_cardinality_( self.ComponentType, "ComponentType", min_occurs=0, max_occurs=9999999 ) + self.gds_check_cardinality_( + self.Component, "Component", min_occurs=0, max_occurs=9999999 + ) if recursive: for item in self.includes: item.validate_(gds_collector, recursive=True) @@ -41768,6 +41185,8 @@ def validate_(self, gds_collector, recursive=False): item.validate_(gds_collector, recursive=True) for item in self.ion_channel_kses: item.validate_(gds_collector, recursive=True) + for item in self.concentration_model: + item.validate_(gds_collector, recursive=True) for item in self.decaying_pool_concentration_models: item.validate_(gds_collector, recursive=True) for item in self.fixed_factor_concentration_models: @@ -41888,6 +41307,8 @@ def validate_(self, gds_collector, recursive=False): item.validate_(gds_collector, recursive=True) for item in self.ComponentType: item.validate_(gds_collector, recursive=True) + for item in self.Component: + item.validate_(gds_collector, recursive=True) return message_count == len(self.gds_collector_.get_messages()) def build(self, node, gds_collector_=None): @@ -41950,6 +41371,12 @@ def _buildChildren( obj_.build(child_, gds_collector_=gds_collector_) self.ion_channel_kses.append(obj_) obj_.original_tagname_ = "ionChannelKS" + elif nodeName_ == "concentrationModel": + class_obj_ = self.get_class_obj_(child_, ConcentrationModel) + obj_ = class_obj_.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.concentration_model.append(obj_) + obj_.original_tagname_ = "concentrationModel" elif nodeName_ == "decayingPoolConcentrationModel": class_obj_ = self.get_class_obj_(child_, DecayingPoolConcentrationModel) obj_ = class_obj_.factory(parent_object_=self) @@ -42258,6 +41685,11 @@ def _buildChildren( obj_.build(child_, gds_collector_=gds_collector_) self.ComponentType.append(obj_) obj_.original_tagname_ = "ComponentType" + elif nodeName_ == "Component": + obj_ = Component.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.Component.append(obj_) + obj_.original_tagname_ = "Component" super(NeuroMLDocument, self)._buildChildren(child_, node, nodeName_, True) def summary(self, show_includes=True, show_non_network=True): @@ -43037,45 +42469,261 @@ def _buildAttributes(self, node, attrs, already_processed): if value is not None and "description" not in already_processed: already_processed.add("description") self.description = value - value = find_attr_value_("xsi:type", node) - if value is not None and "xsi:type" not in already_processed: - already_processed.add("xsi:type") - self.extensiontype_ = value - super(NamedDimensionalType, self)._buildAttributes( - node, attrs, already_processed - ) + value = find_attr_value_("xsi:type", node) + if value is not None and "xsi:type" not in already_processed: + already_processed.add("xsi:type") + self.extensiontype_ = value + super(NamedDimensionalType, self)._buildAttributes( + node, attrs, already_processed + ) + + def _buildChildren( + self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None + ): + super(NamedDimensionalType, self)._buildChildren(child_, node, nodeName_, True) + pass + + +# end class NamedDimensionalType + + +class Exposure(BaseWithoutId): + """Exposure -- LEMS Exposure (ComponentType property)""" + + __hash__ = GeneratedsSuper.__hash__ + member_data_items_ = [ + MemberSpec_("name", "xs:string", 0, 0, {"use": "required", "name": "name"}), + MemberSpec_( + "dimension", "xs:string", 0, 0, {"use": "required", "name": "dimension"} + ), + MemberSpec_( + "description", "xs:string", 0, 1, {"use": "optional", "name": "description"} + ), + ] + subclass = None + superclass = BaseWithoutId + + def __init__( + self, + name: "a string (required)" = None, + dimension: "a string (required)" = None, + description: "a string (optional)" = None, + gds_collector_=None, + **kwargs_, + ): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get("parent_object_") + self.ns_prefix_ = None + super(globals().get("Exposure"), self).__init__(**kwargs_) + self.name = _cast(None, name) + self.name_nsprefix_ = None + self.dimension = _cast(None, dimension) + self.dimension_nsprefix_ = None + self.description = _cast(None, description) + self.description_nsprefix_ = None + + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_(CurrentSubclassModule_, Exposure) + if subclass is not None: + return subclass(*args_, **kwargs_) + if Exposure.subclass: + return Exposure.subclass(*args_, **kwargs_) + else: + return Exposure(*args_, **kwargs_) + + factory = staticmethod(factory) + + def has__content(self): + if super(Exposure, self).has__content(): + return True + else: + return False + + def export( + self, + outfile, + level, + namespaceprefix_="", + namespacedef_="", + name_="Exposure", + pretty_print=True, + ): + imported_ns_def_ = GenerateDSNamespaceDefs_.get("Exposure") + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = "\n" + else: + eol_ = "" + if self.original_tagname_ is not None and name_ == "Exposure": + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ":" + showIndent(outfile, level, pretty_print) + outfile.write( + "<%s%s%s" + % ( + namespaceprefix_, + name_, + namespacedef_ and " " + namespacedef_ or "", + ) + ) + already_processed = set() + self._exportAttributes( + outfile, level, already_processed, namespaceprefix_, name_="Exposure" + ) + if self.has__content(): + outfile.write(">%s" % (eol_,)) + self._exportChildren( + outfile, + level + 1, + namespaceprefix_, + namespacedef_, + name_="Exposure", + pretty_print=pretty_print, + ) + outfile.write("%s" % (namespaceprefix_, name_, eol_)) + else: + outfile.write("/>%s" % (eol_,)) + + def _exportAttributes( + self, outfile, level, already_processed, namespaceprefix_="", name_="Exposure" + ): + super(Exposure, self)._exportAttributes( + outfile, level, already_processed, namespaceprefix_, name_="Exposure" + ) + if self.name is not None and "name" not in already_processed: + already_processed.add("name") + outfile.write( + " name=%s" + % ( + self.gds_encode( + self.gds_format_string( + quote_attrib(self.name), input_name="name" + ) + ), + ) + ) + if self.dimension is not None and "dimension" not in already_processed: + already_processed.add("dimension") + outfile.write( + " dimension=%s" + % ( + self.gds_encode( + self.gds_format_string( + quote_attrib(self.dimension), input_name="dimension" + ) + ), + ) + ) + if self.description is not None and "description" not in already_processed: + already_processed.add("description") + outfile.write( + " description=%s" + % ( + self.gds_encode( + self.gds_format_string( + quote_attrib(self.description), input_name="description" + ) + ), + ) + ) + + def _exportChildren( + self, + outfile, + level, + namespaceprefix_="", + namespacedef_="", + name_="Exposure", + fromsubclass_=False, + pretty_print=True, + ): + super(Exposure, self)._exportChildren( + outfile, + level, + namespaceprefix_, + namespacedef_, + name_, + True, + pretty_print=pretty_print, + ) + pass + + def validate_(self, gds_collector, recursive=False): + self.gds_collector_ = gds_collector + message_count = len(self.gds_collector_.get_messages()) + # validate simple type attributes + self.gds_validate_builtin_ST_(self.gds_validate_string, self.name, "name") + self.gds_check_cardinality_(self.name, "name", required=True) + self.gds_validate_builtin_ST_( + self.gds_validate_string, self.dimension, "dimension" + ) + self.gds_check_cardinality_(self.dimension, "dimension", required=True) + self.gds_validate_builtin_ST_( + self.gds_validate_string, self.description, "description" + ) + self.gds_check_cardinality_(self.description, "description", required=False) + # validate simple type children + # validate complex type children + if recursive: + pass + return message_count == len(self.gds_collector_.get_messages()) + + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self._buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + + def _buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_("name", node) + if value is not None and "name" not in already_processed: + already_processed.add("name") + self.name = value + value = find_attr_value_("dimension", node) + if value is not None and "dimension" not in already_processed: + already_processed.add("dimension") + self.dimension = value + value = find_attr_value_("description", node) + if value is not None and "description" not in already_processed: + already_processed.add("description") + self.description = value + super(Exposure, self)._buildAttributes(node, attrs, already_processed) def _buildChildren( self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None ): - super(NamedDimensionalType, self)._buildChildren(child_, node, nodeName_, True) + super(Exposure, self)._buildChildren(child_, node, nodeName_, True) pass -# end class NamedDimensionalType +# end class Exposure -class Exposure(BaseWithoutId): - """Exposure -- LEMS Exposure (ComponentType property)""" +class Component(Base): + """Component -- A new Component based on a new defined ComponentType.""" __hash__ = GeneratedsSuper.__hash__ member_data_items_ = [ - MemberSpec_("name", "xs:string", 0, 0, {"use": "required", "name": "name"}), - MemberSpec_( - "dimension", "xs:string", 0, 0, {"use": "required", "name": "dimension"} - ), - MemberSpec_( - "description", "xs:string", 0, 1, {"use": "optional", "name": "description"} - ), + MemberSpec_("type", "NmlId", 0, 0, {"use": "required", "name": "type"}), ] subclass = None - superclass = BaseWithoutId + superclass = Base def __init__( self, - name: "a string (required)" = None, - dimension: "a string (required)" = None, - description: "a string (optional)" = None, + id: "a NmlId (required)" = None, + type: "a NmlId (required)" = None, gds_collector_=None, **kwargs_, ): @@ -43084,28 +42732,55 @@ def __init__( self.original_tagname_ = None self.parent_object_ = kwargs_.get("parent_object_") self.ns_prefix_ = None - super(globals().get("Exposure"), self).__init__(**kwargs_) - self.name = _cast(None, name) - self.name_nsprefix_ = None - self.dimension = _cast(None, dimension) - self.dimension_nsprefix_ = None - self.description = _cast(None, description) - self.description_nsprefix_ = None + super(globals().get("Component"), self).__init__(id, **kwargs_) + self.type = _cast(None, type) + self.type_nsprefix_ = None + self.anyAttributes_ = {} def factory(*args_, **kwargs_): if CurrentSubclassModule_ is not None: - subclass = getSubclassFromModule_(CurrentSubclassModule_, Exposure) + subclass = getSubclassFromModule_(CurrentSubclassModule_, Component) if subclass is not None: return subclass(*args_, **kwargs_) - if Exposure.subclass: - return Exposure.subclass(*args_, **kwargs_) + if Component.subclass: + return Component.subclass(*args_, **kwargs_) else: - return Exposure(*args_, **kwargs_) + return Component(*args_, **kwargs_) factory = staticmethod(factory) + def validate_NmlId(self, value): + # Validate type NmlId, a restriction on xs:string. + if ( + value is not None + and Validate_simpletypes_ + and self.gds_collector_ is not None + ): + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message( + 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' + % { + "value": value, + "lineno": lineno, + } + ) + return False + if not self.gds_validate_simple_patterns( + self.validate_NmlId_patterns_, value + ): + self.gds_collector_.add_message( + 'Value "%s" does not match xsd pattern restrictions: %s' + % ( + encode_str_2_3(value), + self.validate_NmlId_patterns_, + ) + ) + + validate_NmlId_patterns_ = [["^([a-zA-Z_][a-zA-Z0-9_]*)$"]] + def has__content(self): - if super(Exposure, self).has__content(): + if super(Component, self).has__content(): return True else: return False @@ -43116,17 +42791,17 @@ def export( level, namespaceprefix_="", namespacedef_="", - name_="Exposure", + name_="Component", pretty_print=True, ): - imported_ns_def_ = GenerateDSNamespaceDefs_.get("Exposure") + imported_ns_def_ = GenerateDSNamespaceDefs_.get("Component") if imported_ns_def_ is not None: namespacedef_ = imported_ns_def_ if pretty_print: eol_ = "\n" else: eol_ = "" - if self.original_tagname_ is not None and name_ == "Exposure": + if self.original_tagname_ is not None and name_ == "Component": name_ = self.original_tagname_ if UseCapturedNS_ and self.ns_prefix_: namespaceprefix_ = self.ns_prefix_ + ":" @@ -43141,7 +42816,7 @@ def export( ) already_processed = set() self._exportAttributes( - outfile, level, already_processed, namespaceprefix_, name_="Exposure" + outfile, level, already_processed, namespaceprefix_, name_="Component" ) if self.has__content(): outfile.write(">%s" % (eol_,)) @@ -43150,7 +42825,7 @@ def export( level + 1, namespaceprefix_, namespacedef_, - name_="Exposure", + name_="Component", pretty_print=pretty_print, ) outfile.write("%s" % (namespaceprefix_, name_, eol_)) @@ -43158,43 +42833,80 @@ def export( outfile.write("/>%s" % (eol_,)) def _exportAttributes( - self, outfile, level, already_processed, namespaceprefix_="", name_="Exposure" - ): - super(Exposure, self)._exportAttributes( - outfile, level, already_processed, namespaceprefix_, name_="Exposure" - ) - if self.name is not None and "name" not in already_processed: - already_processed.add("name") - outfile.write( - " name=%s" - % ( - self.gds_encode( - self.gds_format_string( - quote_attrib(self.name), input_name="name" + self, outfile, level, already_processed, namespaceprefix_="", name_="Component" + ): + unique_counter = 0 + for name, value in self.anyAttributes_.items(): + xsinamespaceprefix = "xsi" + xsinamespace1 = "http://www.w3.org/2001/XMLSchema-instance" + xsinamespace2 = "{%s}" % (xsinamespace1,) + if name.startswith(xsinamespace2): + name1 = name[len(xsinamespace2) :] + name2 = "%s:%s" % ( + xsinamespaceprefix, + name1, + ) + if name2 not in already_processed: + already_processed.add(name2) + outfile.write( + " %s=%s" + % ( + name2, + quote_attrib(value), ) - ), - ) - ) - if self.dimension is not None and "dimension" not in already_processed: - already_processed.add("dimension") - outfile.write( - " dimension=%s" - % ( - self.gds_encode( - self.gds_format_string( - quote_attrib(self.dimension), input_name="dimension" + ) + else: + mo = re_.match(Namespace_extract_pat_, name) + if mo is not None: + namespace, name = mo.group(1, 2) + if name not in already_processed: + already_processed.add(name) + if namespace == "http://www.w3.org/XML/1998/namespace": + outfile.write( + " %s=%s" + % ( + name, + quote_attrib(value), + ) + ) + else: + unique_counter += 1 + outfile.write( + ' xmlns:%d="%s"' + % ( + unique_counter, + namespace, + ) + ) + outfile.write( + " %d:%s=%s" + % ( + unique_counter, + name, + quote_attrib(value), + ) + ) + else: + if name not in already_processed: + already_processed.add(name) + outfile.write( + " %s=%s" + % ( + name, + quote_attrib(value), + ) ) - ), - ) - ) - if self.description is not None and "description" not in already_processed: - already_processed.add("description") + super(Component, self)._exportAttributes( + outfile, level, already_processed, namespaceprefix_, name_="Component" + ) + if self.type is not None and "type" not in already_processed: + already_processed.add("type") outfile.write( - " description=%s" + " type=%s" % ( self.gds_encode( self.gds_format_string( - quote_attrib(self.description), input_name="description" + quote_attrib(self.type), input_name="type" ) ), ) @@ -43206,11 +42918,11 @@ def _exportChildren( level, namespaceprefix_="", namespacedef_="", - name_="Exposure", + name_="Component", fromsubclass_=False, pretty_print=True, ): - super(Exposure, self)._exportChildren( + super(Component, self)._exportChildren( outfile, level, namespaceprefix_, @@ -43225,16 +42937,8 @@ def validate_(self, gds_collector, recursive=False): self.gds_collector_ = gds_collector message_count = len(self.gds_collector_.get_messages()) # validate simple type attributes - self.gds_validate_builtin_ST_(self.gds_validate_string, self.name, "name") - self.gds_check_cardinality_(self.name, "name", required=True) - self.gds_validate_builtin_ST_( - self.gds_validate_string, self.dimension, "dimension" - ) - self.gds_check_cardinality_(self.dimension, "dimension", required=True) - self.gds_validate_builtin_ST_( - self.gds_validate_string, self.description, "description" - ) - self.gds_check_cardinality_(self.description, "description", required=False) + self.gds_validate_defined_ST_(self.validate_NmlId, self.type, "type") + self.gds_check_cardinality_(self.type, "type", required=True) # validate simple type children # validate complex type children if recursive: @@ -43254,28 +42958,25 @@ def build(self, node, gds_collector_=None): return self def _buildAttributes(self, node, attrs, already_processed): - value = find_attr_value_("name", node) - if value is not None and "name" not in already_processed: - already_processed.add("name") - self.name = value - value = find_attr_value_("dimension", node) - if value is not None and "dimension" not in already_processed: - already_processed.add("dimension") - self.dimension = value - value = find_attr_value_("description", node) - if value is not None and "description" not in already_processed: - already_processed.add("description") - self.description = value - super(Exposure, self)._buildAttributes(node, attrs, already_processed) + value = find_attr_value_("type", node) + if value is not None and "type" not in already_processed: + already_processed.add("type") + self.type = value + self.validate_NmlId(self.type) # validate type NmlId + self.anyAttributes_ = {} + for name, value in attrs.items(): + if name not in already_processed: + self.anyAttributes_[name] = value + super(Component, self)._buildAttributes(node, attrs, already_processed) def _buildChildren( self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None ): - super(Exposure, self)._buildChildren(child_, node, nodeName_, True) + super(Component, self)._buildChildren(child_, node, nodeName_, True) pass -# end class Exposure +# end class Component class Constant(BaseWithoutId): @@ -47163,212 +46864,6 @@ def _buildChildren( # end class IntracellularProperties2CaPools -class ConcentrationModel_D(DecayingPoolConcentrationModel): - __hash__ = GeneratedsSuper.__hash__ - member_data_items_ = [ - MemberSpec_("type", "xs:string", 0, 0, {"use": "required", "name": "type"}), - ] - subclass = None - superclass = DecayingPoolConcentrationModel - - def __init__( - self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - ion: "a NmlId (required)" = None, - resting_conc: "a Nml2Quantity_concentration (required)" = None, - decay_constant: "a Nml2Quantity_time (required)" = None, - shell_thickness: "a Nml2Quantity_length (required)" = None, - type: "a string (required)" = "decayingPoolConcentrationModel", - gds_collector_=None, - **kwargs_, - ): - self.gds_collector_ = gds_collector_ - self.gds_elementtree_node_ = None - self.original_tagname_ = None - self.parent_object_ = kwargs_.get("parent_object_") - self.ns_prefix_ = None - super(globals().get("ConcentrationModel_D"), self).__init__( - id, - metaid, - notes, - properties, - annotation, - ion, - resting_conc, - decay_constant, - shell_thickness, - **kwargs_, - ) - self.type = _cast(None, type) - self.type_nsprefix_ = None - - def factory(*args_, **kwargs_): - if CurrentSubclassModule_ is not None: - subclass = getSubclassFromModule_( - CurrentSubclassModule_, ConcentrationModel_D - ) - if subclass is not None: - return subclass(*args_, **kwargs_) - if ConcentrationModel_D.subclass: - return ConcentrationModel_D.subclass(*args_, **kwargs_) - else: - return ConcentrationModel_D(*args_, **kwargs_) - - factory = staticmethod(factory) - - def has__content(self): - if super(ConcentrationModel_D, self).has__content(): - return True - else: - return False - - def export( - self, - outfile, - level, - namespaceprefix_="", - namespacedef_="", - name_="ConcentrationModel_D", - pretty_print=True, - ): - imported_ns_def_ = GenerateDSNamespaceDefs_.get("ConcentrationModel_D") - if imported_ns_def_ is not None: - namespacedef_ = imported_ns_def_ - if pretty_print: - eol_ = "\n" - else: - eol_ = "" - if self.original_tagname_ is not None and name_ == "ConcentrationModel_D": - name_ = self.original_tagname_ - if UseCapturedNS_ and self.ns_prefix_: - namespaceprefix_ = self.ns_prefix_ + ":" - showIndent(outfile, level, pretty_print) - outfile.write( - "<%s%s%s" - % ( - namespaceprefix_, - name_, - namespacedef_ and " " + namespacedef_ or "", - ) - ) - already_processed = set() - self._exportAttributes( - outfile, - level, - already_processed, - namespaceprefix_, - name_="ConcentrationModel_D", - ) - if self.has__content(): - outfile.write(">%s" % (eol_,)) - self._exportChildren( - outfile, - level + 1, - namespaceprefix_, - namespacedef_, - name_="ConcentrationModel_D", - pretty_print=pretty_print, - ) - showIndent(outfile, level, pretty_print) - outfile.write("%s" % (namespaceprefix_, name_, eol_)) - else: - outfile.write("/>%s" % (eol_,)) - - def _exportAttributes( - self, - outfile, - level, - already_processed, - namespaceprefix_="", - name_="ConcentrationModel_D", - ): - super(ConcentrationModel_D, self)._exportAttributes( - outfile, - level, - already_processed, - namespaceprefix_, - name_="ConcentrationModel_D", - ) - if self.type is not None and "type" not in already_processed: - already_processed.add("type") - outfile.write( - " type=%s" - % ( - self.gds_encode( - self.gds_format_string( - quote_attrib(self.type), input_name="type" - ) - ), - ) - ) - - def _exportChildren( - self, - outfile, - level, - namespaceprefix_="", - namespacedef_="", - name_="ConcentrationModel_D", - fromsubclass_=False, - pretty_print=True, - ): - super(ConcentrationModel_D, self)._exportChildren( - outfile, - level, - namespaceprefix_, - namespacedef_, - name_, - True, - pretty_print=pretty_print, - ) - - def validate_(self, gds_collector, recursive=False): - self.gds_collector_ = gds_collector - message_count = len(self.gds_collector_.get_messages()) - # validate simple type attributes - self.gds_validate_builtin_ST_(self.gds_validate_string, self.type, "type") - self.gds_check_cardinality_(self.type, "type", required=True) - # validate simple type children - # validate complex type children - if recursive: - pass - return message_count == len(self.gds_collector_.get_messages()) - - def build(self, node, gds_collector_=None): - self.gds_collector_ = gds_collector_ - if SaveElementTreeNode: - self.gds_elementtree_node_ = node - already_processed = set() - self.ns_prefix_ = node.prefix - self._buildAttributes(node, node.attrib, already_processed) - for child in node: - nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] - self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) - return self - - def _buildAttributes(self, node, attrs, already_processed): - value = find_attr_value_("type", node) - if value is not None and "type" not in already_processed: - already_processed.add("type") - self.type = value - super(ConcentrationModel_D, self)._buildAttributes( - node, attrs, already_processed - ) - - def _buildChildren( - self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None - ): - super(ConcentrationModel_D, self)._buildChildren(child_, node, nodeName_, True) - pass - - -# end class ConcentrationModel_D - - class ChannelDensityNernstCa2(ChannelDensityNernst): """ChannelDensityNernstCa2 -- This component is similar to the original component type **channelDensityNernst** but it is changed in order to have a reversal potential that depends on a second independent Ca++ pool ( ca2 ). See https://github.com/OpenSourceBrain/ghk-nernst. \n @@ -53744,14 +53239,409 @@ def _exportAttributes( level, already_processed, namespaceprefix_="", - name_="LinearGradedSynapse", + name_="LinearGradedSynapse", + ): + super(LinearGradedSynapse, self)._exportAttributes( + outfile, + level, + already_processed, + namespaceprefix_, + name_="LinearGradedSynapse", + ) + if self.conductance is not None and "conductance" not in already_processed: + already_processed.add("conductance") + outfile.write( + " conductance=%s" + % ( + self.gds_encode( + self.gds_format_string( + quote_attrib(self.conductance), input_name="conductance" + ) + ), + ) + ) + + def _exportChildren( + self, + outfile, + level, + namespaceprefix_="", + namespacedef_="", + name_="LinearGradedSynapse", + fromsubclass_=False, + pretty_print=True, + ): + super(LinearGradedSynapse, self)._exportChildren( + outfile, + level, + namespaceprefix_, + namespacedef_, + name_, + True, + pretty_print=pretty_print, + ) + + def validate_(self, gds_collector, recursive=False): + self.gds_collector_ = gds_collector + message_count = len(self.gds_collector_.get_messages()) + # validate simple type attributes + self.gds_validate_defined_ST_( + self.validate_Nml2Quantity_conductance, self.conductance, "conductance" + ) + self.gds_check_cardinality_(self.conductance, "conductance", required=True) + # validate simple type children + # validate complex type children + if recursive: + pass + return message_count == len(self.gds_collector_.get_messages()) + + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self._buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + + def _buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_("conductance", node) + if value is not None and "conductance" not in already_processed: + already_processed.add("conductance") + self.conductance = value + self.validate_Nml2Quantity_conductance( + self.conductance + ) # validate type Nml2Quantity_conductance + super(LinearGradedSynapse, self)._buildAttributes( + node, attrs, already_processed + ) + + def _buildChildren( + self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None + ): + super(LinearGradedSynapse, self)._buildChildren(child_, node, nodeName_, True) + pass + + +# end class LinearGradedSynapse + + +class SilentSynapse(BaseSynapse): + """SilentSynapse -- Dummy synapse which emits no current. Used as presynaptic endpoint for analog synaptic connection.""" + + __hash__ = GeneratedsSuper.__hash__ + member_data_items_ = [] + subclass = None + superclass = BaseSynapse + + def __init__( + self, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + gds_collector_=None, + **kwargs_, + ): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get("parent_object_") + self.ns_prefix_ = None + super(globals().get("SilentSynapse"), self).__init__( + id, metaid, notes, properties, annotation, neuro_lex_id, **kwargs_ + ) + + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_(CurrentSubclassModule_, SilentSynapse) + if subclass is not None: + return subclass(*args_, **kwargs_) + if SilentSynapse.subclass: + return SilentSynapse.subclass(*args_, **kwargs_) + else: + return SilentSynapse(*args_, **kwargs_) + + factory = staticmethod(factory) + + def has__content(self): + if super(SilentSynapse, self).has__content(): + return True + else: + return False + + def export( + self, + outfile, + level, + namespaceprefix_="", + namespacedef_="", + name_="SilentSynapse", + pretty_print=True, + ): + imported_ns_def_ = GenerateDSNamespaceDefs_.get("SilentSynapse") + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = "\n" + else: + eol_ = "" + if self.original_tagname_ is not None and name_ == "SilentSynapse": + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ":" + showIndent(outfile, level, pretty_print) + outfile.write( + "<%s%s%s" + % ( + namespaceprefix_, + name_, + namespacedef_ and " " + namespacedef_ or "", + ) + ) + already_processed = set() + self._exportAttributes( + outfile, level, already_processed, namespaceprefix_, name_="SilentSynapse" + ) + if self.has__content(): + outfile.write(">%s" % (eol_,)) + self._exportChildren( + outfile, + level + 1, + namespaceprefix_, + namespacedef_, + name_="SilentSynapse", + pretty_print=pretty_print, + ) + showIndent(outfile, level, pretty_print) + outfile.write("%s" % (namespaceprefix_, name_, eol_)) + else: + outfile.write("/>%s" % (eol_,)) + + def _exportAttributes( + self, + outfile, + level, + already_processed, + namespaceprefix_="", + name_="SilentSynapse", + ): + super(SilentSynapse, self)._exportAttributes( + outfile, level, already_processed, namespaceprefix_, name_="SilentSynapse" + ) + + def _exportChildren( + self, + outfile, + level, + namespaceprefix_="", + namespacedef_="", + name_="SilentSynapse", + fromsubclass_=False, + pretty_print=True, + ): + super(SilentSynapse, self)._exportChildren( + outfile, + level, + namespaceprefix_, + namespacedef_, + name_, + True, + pretty_print=pretty_print, + ) + + def validate_(self, gds_collector, recursive=False): + self.gds_collector_ = gds_collector + message_count = len(self.gds_collector_.get_messages()) + # validate simple type attributes + # validate simple type children + # validate complex type children + if recursive: + pass + return message_count == len(self.gds_collector_.get_messages()) + + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self._buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + + def _buildAttributes(self, node, attrs, already_processed): + super(SilentSynapse, self)._buildAttributes(node, attrs, already_processed) + + def _buildChildren( + self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None + ): + super(SilentSynapse, self)._buildChildren(child_, node, nodeName_, True) + pass + + +# end class SilentSynapse + + +class GapJunction(BaseSynapse): + """GapJunction -- Gap junction/single electrical connection + \n + :param conductance: + :type conductance: conductance + + """ + + __hash__ = GeneratedsSuper.__hash__ + member_data_items_ = [ + MemberSpec_( + "conductance", + "Nml2Quantity_conductance", + 0, + 0, + {"use": "required", "name": "conductance"}, + ), + ] + subclass = None + superclass = BaseSynapse + + def __init__( + self, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + conductance: "a Nml2Quantity_conductance (required)" = None, + gds_collector_=None, + **kwargs_, + ): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get("parent_object_") + self.ns_prefix_ = None + super(globals().get("GapJunction"), self).__init__( + id, metaid, notes, properties, annotation, neuro_lex_id, **kwargs_ + ) + self.conductance = _cast(None, conductance) + self.conductance_nsprefix_ = None + + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_(CurrentSubclassModule_, GapJunction) + if subclass is not None: + return subclass(*args_, **kwargs_) + if GapJunction.subclass: + return GapJunction.subclass(*args_, **kwargs_) + else: + return GapJunction(*args_, **kwargs_) + + factory = staticmethod(factory) + + def validate_Nml2Quantity_conductance(self, value): + # Validate type Nml2Quantity_conductance, a restriction on xs:string. + if ( + value is not None + and Validate_simpletypes_ + and self.gds_collector_ is not None + ): + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message( + 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' + % { + "value": value, + "lineno": lineno, + } + ) + return False + if not self.gds_validate_simple_patterns( + self.validate_Nml2Quantity_conductance_patterns_, value + ): + self.gds_collector_.add_message( + 'Value "%s" does not match xsd pattern restrictions: %s' + % ( + encode_str_2_3(value), + self.validate_Nml2Quantity_conductance_patterns_, + ) + ) + + validate_Nml2Quantity_conductance_patterns_ = [ + ["^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(S|mS|uS|nS|pS))$"] + ] + + def has__content(self): + if super(GapJunction, self).has__content(): + return True + else: + return False + + def export( + self, + outfile, + level, + namespaceprefix_="", + namespacedef_="", + name_="GapJunction", + pretty_print=True, + ): + imported_ns_def_ = GenerateDSNamespaceDefs_.get("GapJunction") + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = "\n" + else: + eol_ = "" + if self.original_tagname_ is not None and name_ == "GapJunction": + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ":" + showIndent(outfile, level, pretty_print) + outfile.write( + "<%s%s%s" + % ( + namespaceprefix_, + name_, + namespacedef_ and " " + namespacedef_ or "", + ) + ) + already_processed = set() + self._exportAttributes( + outfile, level, already_processed, namespaceprefix_, name_="GapJunction" + ) + if self.has__content(): + outfile.write(">%s" % (eol_,)) + self._exportChildren( + outfile, + level + 1, + namespaceprefix_, + namespacedef_, + name_="GapJunction", + pretty_print=pretty_print, + ) + showIndent(outfile, level, pretty_print) + outfile.write("%s" % (namespaceprefix_, name_, eol_)) + else: + outfile.write("/>%s" % (eol_,)) + + def _exportAttributes( + self, + outfile, + level, + already_processed, + namespaceprefix_="", + name_="GapJunction", ): - super(LinearGradedSynapse, self)._exportAttributes( - outfile, - level, - already_processed, - namespaceprefix_, - name_="LinearGradedSynapse", + super(GapJunction, self)._exportAttributes( + outfile, level, already_processed, namespaceprefix_, name_="GapJunction" ) if self.conductance is not None and "conductance" not in already_processed: already_processed.add("conductance") @@ -53772,11 +53662,11 @@ def _exportChildren( level, namespaceprefix_="", namespacedef_="", - name_="LinearGradedSynapse", + name_="GapJunction", fromsubclass_=False, pretty_print=True, ): - super(LinearGradedSynapse, self)._exportChildren( + super(GapJunction, self)._exportChildren( outfile, level, namespaceprefix_, @@ -53820,22 +53710,20 @@ def _buildAttributes(self, node, attrs, already_processed): self.validate_Nml2Quantity_conductance( self.conductance ) # validate type Nml2Quantity_conductance - super(LinearGradedSynapse, self)._buildAttributes( - node, attrs, already_processed - ) + super(GapJunction, self)._buildAttributes(node, attrs, already_processed) def _buildChildren( self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None ): - super(LinearGradedSynapse, self)._buildChildren(child_, node, nodeName_, True) + super(GapJunction, self)._buildChildren(child_, node, nodeName_, True) pass -# end class LinearGradedSynapse +# end class GapJunction -class SilentSynapse(BaseSynapse): - """SilentSynapse -- Dummy synapse which emits no current. Used as presynaptic endpoint for analog synaptic connection.""" +class BaseCurrentBasedSynapse(BaseSynapse): + """BaseCurrentBasedSynapse -- Synapse model which produces a synaptic current.""" __hash__ = GeneratedsSuper.__hash__ member_data_items_ = [] @@ -53850,6 +53738,7 @@ def __init__( properties: "list of Property(s) (optional)" = None, annotation: "a Annotation (optional)" = None, neuro_lex_id: "a NeuroLexId (optional)" = None, + extensiontype_=None, gds_collector_=None, **kwargs_, ): @@ -53858,24 +53747,34 @@ def __init__( self.original_tagname_ = None self.parent_object_ = kwargs_.get("parent_object_") self.ns_prefix_ = None - super(globals().get("SilentSynapse"), self).__init__( - id, metaid, notes, properties, annotation, neuro_lex_id, **kwargs_ + super(globals().get("BaseCurrentBasedSynapse"), self).__init__( + id, + metaid, + notes, + properties, + annotation, + neuro_lex_id, + extensiontype_, + **kwargs_, ) + self.extensiontype_ = extensiontype_ def factory(*args_, **kwargs_): if CurrentSubclassModule_ is not None: - subclass = getSubclassFromModule_(CurrentSubclassModule_, SilentSynapse) + subclass = getSubclassFromModule_( + CurrentSubclassModule_, BaseCurrentBasedSynapse + ) if subclass is not None: return subclass(*args_, **kwargs_) - if SilentSynapse.subclass: - return SilentSynapse.subclass(*args_, **kwargs_) + if BaseCurrentBasedSynapse.subclass: + return BaseCurrentBasedSynapse.subclass(*args_, **kwargs_) else: - return SilentSynapse(*args_, **kwargs_) + return BaseCurrentBasedSynapse(*args_, **kwargs_) factory = staticmethod(factory) def has__content(self): - if super(SilentSynapse, self).has__content(): + if super(BaseCurrentBasedSynapse, self).has__content(): return True else: return False @@ -53886,17 +53785,17 @@ def export( level, namespaceprefix_="", namespacedef_="", - name_="SilentSynapse", + name_="BaseCurrentBasedSynapse", pretty_print=True, ): - imported_ns_def_ = GenerateDSNamespaceDefs_.get("SilentSynapse") + imported_ns_def_ = GenerateDSNamespaceDefs_.get("BaseCurrentBasedSynapse") if imported_ns_def_ is not None: namespacedef_ = imported_ns_def_ if pretty_print: eol_ = "\n" else: eol_ = "" - if self.original_tagname_ is not None and name_ == "SilentSynapse": + if self.original_tagname_ is not None and name_ == "BaseCurrentBasedSynapse": name_ = self.original_tagname_ if UseCapturedNS_ and self.ns_prefix_: namespaceprefix_ = self.ns_prefix_ + ":" @@ -53911,7 +53810,11 @@ def export( ) already_processed = set() self._exportAttributes( - outfile, level, already_processed, namespaceprefix_, name_="SilentSynapse" + outfile, + level, + already_processed, + namespaceprefix_, + name_="BaseCurrentBasedSynapse", ) if self.has__content(): outfile.write(">%s" % (eol_,)) @@ -53920,7 +53823,7 @@ def export( level + 1, namespaceprefix_, namespacedef_, - name_="SilentSynapse", + name_="BaseCurrentBasedSynapse", pretty_print=pretty_print, ) showIndent(outfile, level, pretty_print) @@ -53934,11 +53837,27 @@ def _exportAttributes( level, already_processed, namespaceprefix_="", - name_="SilentSynapse", + name_="BaseCurrentBasedSynapse", ): - super(SilentSynapse, self)._exportAttributes( - outfile, level, already_processed, namespaceprefix_, name_="SilentSynapse" + super(BaseCurrentBasedSynapse, self)._exportAttributes( + outfile, + level, + already_processed, + namespaceprefix_, + name_="BaseCurrentBasedSynapse", ) + if self.extensiontype_ is not None and "xsi:type" not in already_processed: + already_processed.add("xsi:type") + outfile.write(' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"') + if ":" not in self.extensiontype_: + imported_ns_type_prefix_ = GenerateDSNamespaceTypePrefixes_.get( + self.extensiontype_, "" + ) + outfile.write( + ' xsi:type="%s%s"' % (imported_ns_type_prefix_, self.extensiontype_) + ) + else: + outfile.write(' xsi:type="%s"' % self.extensiontype_) def _exportChildren( self, @@ -53946,11 +53865,11 @@ def _exportChildren( level, namespaceprefix_="", namespacedef_="", - name_="SilentSynapse", + name_="BaseCurrentBasedSynapse", fromsubclass_=False, pretty_print=True, ): - super(SilentSynapse, self)._exportChildren( + super(BaseCurrentBasedSynapse, self)._exportChildren( outfile, level, namespaceprefix_, @@ -53983,36 +53902,31 @@ def build(self, node, gds_collector_=None): return self def _buildAttributes(self, node, attrs, already_processed): - super(SilentSynapse, self)._buildAttributes(node, attrs, already_processed) + value = find_attr_value_("xsi:type", node) + if value is not None and "xsi:type" not in already_processed: + already_processed.add("xsi:type") + self.extensiontype_ = value + super(BaseCurrentBasedSynapse, self)._buildAttributes( + node, attrs, already_processed + ) def _buildChildren( self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None ): - super(SilentSynapse, self)._buildChildren(child_, node, nodeName_, True) + super(BaseCurrentBasedSynapse, self)._buildChildren( + child_, node, nodeName_, True + ) pass -# end class SilentSynapse - +# end class BaseCurrentBasedSynapse -class GapJunction(BaseSynapse): - """GapJunction -- Gap junction/single electrical connection - \n - :param conductance: - :type conductance: conductance - """ +class BaseVoltageDepSynapse(BaseSynapse): + """BaseVoltageDepSynapse -- Base type for synapses with a dependence on membrane potential""" __hash__ = GeneratedsSuper.__hash__ - member_data_items_ = [ - MemberSpec_( - "conductance", - "Nml2Quantity_conductance", - 0, - 0, - {"use": "required", "name": "conductance"}, - ), - ] + member_data_items_ = [] subclass = None superclass = BaseSynapse @@ -54024,7 +53938,7 @@ def __init__( properties: "list of Property(s) (optional)" = None, annotation: "a Annotation (optional)" = None, neuro_lex_id: "a NeuroLexId (optional)" = None, - conductance: "a Nml2Quantity_conductance (required)" = None, + extensiontype_=None, gds_collector_=None, **kwargs_, ): @@ -54033,58 +53947,34 @@ def __init__( self.original_tagname_ = None self.parent_object_ = kwargs_.get("parent_object_") self.ns_prefix_ = None - super(globals().get("GapJunction"), self).__init__( - id, metaid, notes, properties, annotation, neuro_lex_id, **kwargs_ + super(globals().get("BaseVoltageDepSynapse"), self).__init__( + id, + metaid, + notes, + properties, + annotation, + neuro_lex_id, + extensiontype_, + **kwargs_, ) - self.conductance = _cast(None, conductance) - self.conductance_nsprefix_ = None + self.extensiontype_ = extensiontype_ def factory(*args_, **kwargs_): if CurrentSubclassModule_ is not None: - subclass = getSubclassFromModule_(CurrentSubclassModule_, GapJunction) + subclass = getSubclassFromModule_( + CurrentSubclassModule_, BaseVoltageDepSynapse + ) if subclass is not None: return subclass(*args_, **kwargs_) - if GapJunction.subclass: - return GapJunction.subclass(*args_, **kwargs_) + if BaseVoltageDepSynapse.subclass: + return BaseVoltageDepSynapse.subclass(*args_, **kwargs_) else: - return GapJunction(*args_, **kwargs_) + return BaseVoltageDepSynapse(*args_, **kwargs_) factory = staticmethod(factory) - def validate_Nml2Quantity_conductance(self, value): - # Validate type Nml2Quantity_conductance, a restriction on xs:string. - if ( - value is not None - and Validate_simpletypes_ - and self.gds_collector_ is not None - ): - if not isinstance(value, str): - lineno = self.gds_get_node_lineno_() - self.gds_collector_.add_message( - 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' - % { - "value": value, - "lineno": lineno, - } - ) - return False - if not self.gds_validate_simple_patterns( - self.validate_Nml2Quantity_conductance_patterns_, value - ): - self.gds_collector_.add_message( - 'Value "%s" does not match xsd pattern restrictions: %s' - % ( - encode_str_2_3(value), - self.validate_Nml2Quantity_conductance_patterns_, - ) - ) - - validate_Nml2Quantity_conductance_patterns_ = [ - ["^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(S|mS|uS|nS|pS))$"] - ] - def has__content(self): - if super(GapJunction, self).has__content(): + if super(BaseVoltageDepSynapse, self).has__content(): return True else: return False @@ -54095,17 +53985,17 @@ def export( level, namespaceprefix_="", namespacedef_="", - name_="GapJunction", + name_="BaseVoltageDepSynapse", pretty_print=True, ): - imported_ns_def_ = GenerateDSNamespaceDefs_.get("GapJunction") + imported_ns_def_ = GenerateDSNamespaceDefs_.get("BaseVoltageDepSynapse") if imported_ns_def_ is not None: namespacedef_ = imported_ns_def_ if pretty_print: eol_ = "\n" else: eol_ = "" - if self.original_tagname_ is not None and name_ == "GapJunction": + if self.original_tagname_ is not None and name_ == "BaseVoltageDepSynapse": name_ = self.original_tagname_ if UseCapturedNS_ and self.ns_prefix_: namespaceprefix_ = self.ns_prefix_ + ":" @@ -54120,7 +54010,11 @@ def export( ) already_processed = set() self._exportAttributes( - outfile, level, already_processed, namespaceprefix_, name_="GapJunction" + outfile, + level, + already_processed, + namespaceprefix_, + name_="BaseVoltageDepSynapse", ) if self.has__content(): outfile.write(">%s" % (eol_,)) @@ -54129,7 +54023,7 @@ def export( level + 1, namespaceprefix_, namespacedef_, - name_="GapJunction", + name_="BaseVoltageDepSynapse", pretty_print=pretty_print, ) showIndent(outfile, level, pretty_print) @@ -54143,23 +54037,27 @@ def _exportAttributes( level, already_processed, namespaceprefix_="", - name_="GapJunction", + name_="BaseVoltageDepSynapse", ): - super(GapJunction, self)._exportAttributes( - outfile, level, already_processed, namespaceprefix_, name_="GapJunction" + super(BaseVoltageDepSynapse, self)._exportAttributes( + outfile, + level, + already_processed, + namespaceprefix_, + name_="BaseVoltageDepSynapse", ) - if self.conductance is not None and "conductance" not in already_processed: - already_processed.add("conductance") - outfile.write( - " conductance=%s" - % ( - self.gds_encode( - self.gds_format_string( - quote_attrib(self.conductance), input_name="conductance" - ) - ), + if self.extensiontype_ is not None and "xsi:type" not in already_processed: + already_processed.add("xsi:type") + outfile.write(' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"') + if ":" not in self.extensiontype_: + imported_ns_type_prefix_ = GenerateDSNamespaceTypePrefixes_.get( + self.extensiontype_, "" ) - ) + outfile.write( + ' xsi:type="%s%s"' % (imported_ns_type_prefix_, self.extensiontype_) + ) + else: + outfile.write(' xsi:type="%s"' % self.extensiontype_) def _exportChildren( self, @@ -54167,11 +54065,11 @@ def _exportChildren( level, namespaceprefix_="", namespacedef_="", - name_="GapJunction", + name_="BaseVoltageDepSynapse", fromsubclass_=False, pretty_print=True, ): - super(GapJunction, self)._exportChildren( + super(BaseVoltageDepSynapse, self)._exportChildren( outfile, level, namespaceprefix_, @@ -54185,10 +54083,6 @@ def validate_(self, gds_collector, recursive=False): self.gds_collector_ = gds_collector message_count = len(self.gds_collector_.get_messages()) # validate simple type attributes - self.gds_validate_defined_ST_( - self.validate_Nml2Quantity_conductance, self.conductance, "conductance" - ) - self.gds_check_cardinality_(self.conductance, "conductance", required=True) # validate simple type children # validate complex type children if recursive: @@ -54208,32 +54102,58 @@ def build(self, node, gds_collector_=None): return self def _buildAttributes(self, node, attrs, already_processed): - value = find_attr_value_("conductance", node) - if value is not None and "conductance" not in already_processed: - already_processed.add("conductance") - self.conductance = value - self.validate_Nml2Quantity_conductance( - self.conductance - ) # validate type Nml2Quantity_conductance - super(GapJunction, self)._buildAttributes(node, attrs, already_processed) + value = find_attr_value_("xsi:type", node) + if value is not None and "xsi:type" not in already_processed: + already_processed.add("xsi:type") + self.extensiontype_ = value + super(BaseVoltageDepSynapse, self)._buildAttributes( + node, attrs, already_processed + ) def _buildChildren( self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None ): - super(GapJunction, self)._buildChildren(child_, node, nodeName_, True) + super(BaseVoltageDepSynapse, self)._buildChildren(child_, node, nodeName_, True) pass -# end class GapJunction +# end class BaseVoltageDepSynapse -class BaseCurrentBasedSynapse(BaseSynapse): - """BaseCurrentBasedSynapse -- Synapse model which produces a synaptic current.""" +class FixedFactorConcentrationModel(ConcentrationModel): + """FixedFactorConcentrationModel -- Model of buffering of concentration of an ion ( currently hard coded to be calcium, due to requirement for **iCa** ) which has a baseline level **restingConc** and tends to this value with time course **decayConstant.** A fixed factor **rho** is used to scale the incoming current *independently of the size of the compartment* to produce a concentration change. + \n + :param restingConc: + :type restingConc: concentration + :param decayConstant: + :type decayConstant: time + :param rho: + :type rho: rho_factor + + """ __hash__ = GeneratedsSuper.__hash__ - member_data_items_ = [] + member_data_items_ = [ + MemberSpec_( + "resting_conc", + "Nml2Quantity_concentration", + 0, + 0, + {"use": "required", "name": "resting_conc"}, + ), + MemberSpec_( + "decay_constant", + "Nml2Quantity_time", + 0, + 0, + {"use": "required", "name": "decay_constant"}, + ), + MemberSpec_( + "rho", "Nml2Quantity_rhoFactor", 0, 0, {"use": "required", "name": "rho"} + ), + ] subclass = None - superclass = BaseSynapse + superclass = ConcentrationModel def __init__( self, @@ -54242,8 +54162,10 @@ def __init__( notes: "a string (optional)" = None, properties: "list of Property(s) (optional)" = None, annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - extensiontype_=None, + ion: "a NmlId (required)" = None, + resting_conc: "a Nml2Quantity_concentration (required)" = None, + decay_constant: "a Nml2Quantity_time (required)" = None, + rho: "a Nml2Quantity_rhoFactor (required)" = None, gds_collector_=None, **kwargs_, ): @@ -54252,34 +54174,130 @@ def __init__( self.original_tagname_ = None self.parent_object_ = kwargs_.get("parent_object_") self.ns_prefix_ = None - super(globals().get("BaseCurrentBasedSynapse"), self).__init__( - id, - metaid, - notes, - properties, - annotation, - neuro_lex_id, - extensiontype_, - **kwargs_, + super(globals().get("FixedFactorConcentrationModel"), self).__init__( + id, metaid, notes, properties, annotation, ion, **kwargs_ ) - self.extensiontype_ = extensiontype_ + self.resting_conc = _cast(None, resting_conc) + self.resting_conc_nsprefix_ = None + self.decay_constant = _cast(None, decay_constant) + self.decay_constant_nsprefix_ = None + self.rho = _cast(None, rho) + self.rho_nsprefix_ = None def factory(*args_, **kwargs_): if CurrentSubclassModule_ is not None: subclass = getSubclassFromModule_( - CurrentSubclassModule_, BaseCurrentBasedSynapse + CurrentSubclassModule_, FixedFactorConcentrationModel ) if subclass is not None: return subclass(*args_, **kwargs_) - if BaseCurrentBasedSynapse.subclass: - return BaseCurrentBasedSynapse.subclass(*args_, **kwargs_) + if FixedFactorConcentrationModel.subclass: + return FixedFactorConcentrationModel.subclass(*args_, **kwargs_) else: - return BaseCurrentBasedSynapse(*args_, **kwargs_) + return FixedFactorConcentrationModel(*args_, **kwargs_) factory = staticmethod(factory) + def validate_Nml2Quantity_concentration(self, value): + # Validate type Nml2Quantity_concentration, a restriction on xs:string. + if ( + value is not None + and Validate_simpletypes_ + and self.gds_collector_ is not None + ): + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message( + 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' + % { + "value": value, + "lineno": lineno, + } + ) + return False + if not self.gds_validate_simple_patterns( + self.validate_Nml2Quantity_concentration_patterns_, value + ): + self.gds_collector_.add_message( + 'Value "%s" does not match xsd pattern restrictions: %s' + % ( + encode_str_2_3(value), + self.validate_Nml2Quantity_concentration_patterns_, + ) + ) + + validate_Nml2Quantity_concentration_patterns_ = [ + ["^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(mol_per_m3|mol_per_cm3|M|mM))$"] + ] + + def validate_Nml2Quantity_time(self, value): + # Validate type Nml2Quantity_time, a restriction on xs:string. + if ( + value is not None + and Validate_simpletypes_ + and self.gds_collector_ is not None + ): + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message( + 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' + % { + "value": value, + "lineno": lineno, + } + ) + return False + if not self.gds_validate_simple_patterns( + self.validate_Nml2Quantity_time_patterns_, value + ): + self.gds_collector_.add_message( + 'Value "%s" does not match xsd pattern restrictions: %s' + % ( + encode_str_2_3(value), + self.validate_Nml2Quantity_time_patterns_, + ) + ) + + validate_Nml2Quantity_time_patterns_ = [ + ["^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(s|ms))$"] + ] + + def validate_Nml2Quantity_rhoFactor(self, value): + # Validate type Nml2Quantity_rhoFactor, a restriction on xs:string. + if ( + value is not None + and Validate_simpletypes_ + and self.gds_collector_ is not None + ): + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message( + 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' + % { + "value": value, + "lineno": lineno, + } + ) + return False + if not self.gds_validate_simple_patterns( + self.validate_Nml2Quantity_rhoFactor_patterns_, value + ): + self.gds_collector_.add_message( + 'Value "%s" does not match xsd pattern restrictions: %s' + % ( + encode_str_2_3(value), + self.validate_Nml2Quantity_rhoFactor_patterns_, + ) + ) + + validate_Nml2Quantity_rhoFactor_patterns_ = [ + [ + "^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(mol_per_m_per_A_per_s|mol_per_cm_per_uA_per_ms))$" + ] + ] + def has__content(self): - if super(BaseCurrentBasedSynapse, self).has__content(): + if super(FixedFactorConcentrationModel, self).has__content(): return True else: return False @@ -54290,17 +54308,20 @@ def export( level, namespaceprefix_="", namespacedef_="", - name_="BaseCurrentBasedSynapse", + name_="FixedFactorConcentrationModel", pretty_print=True, ): - imported_ns_def_ = GenerateDSNamespaceDefs_.get("BaseCurrentBasedSynapse") + imported_ns_def_ = GenerateDSNamespaceDefs_.get("FixedFactorConcentrationModel") if imported_ns_def_ is not None: namespacedef_ = imported_ns_def_ if pretty_print: eol_ = "\n" else: eol_ = "" - if self.original_tagname_ is not None and name_ == "BaseCurrentBasedSynapse": + if ( + self.original_tagname_ is not None + and name_ == "FixedFactorConcentrationModel" + ): name_ = self.original_tagname_ if UseCapturedNS_ and self.ns_prefix_: namespaceprefix_ = self.ns_prefix_ + ":" @@ -54319,7 +54340,7 @@ def export( level, already_processed, namespaceprefix_, - name_="BaseCurrentBasedSynapse", + name_="FixedFactorConcentrationModel", ) if self.has__content(): outfile.write(">%s" % (eol_,)) @@ -54328,7 +54349,7 @@ def export( level + 1, namespaceprefix_, namespacedef_, - name_="BaseCurrentBasedSynapse", + name_="FixedFactorConcentrationModel", pretty_print=pretty_print, ) showIndent(outfile, level, pretty_print) @@ -54342,27 +54363,53 @@ def _exportAttributes( level, already_processed, namespaceprefix_="", - name_="BaseCurrentBasedSynapse", + name_="FixedFactorConcentrationModel", ): - super(BaseCurrentBasedSynapse, self)._exportAttributes( + super(FixedFactorConcentrationModel, self)._exportAttributes( outfile, level, already_processed, namespaceprefix_, - name_="BaseCurrentBasedSynapse", + name_="FixedFactorConcentrationModel", ) - if self.extensiontype_ is not None and "xsi:type" not in already_processed: - already_processed.add("xsi:type") - outfile.write(' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"') - if ":" not in self.extensiontype_: - imported_ns_type_prefix_ = GenerateDSNamespaceTypePrefixes_.get( - self.extensiontype_, "" + if self.resting_conc is not None and "resting_conc" not in already_processed: + already_processed.add("resting_conc") + outfile.write( + " restingConc=%s" + % ( + self.gds_encode( + self.gds_format_string( + quote_attrib(self.resting_conc), input_name="restingConc" + ) + ), ) - outfile.write( - ' xsi:type="%s%s"' % (imported_ns_type_prefix_, self.extensiontype_) + ) + if ( + self.decay_constant is not None + and "decay_constant" not in already_processed + ): + already_processed.add("decay_constant") + outfile.write( + " decayConstant=%s" + % ( + self.gds_encode( + self.gds_format_string( + quote_attrib(self.decay_constant), + input_name="decayConstant", + ) + ), ) - else: - outfile.write(' xsi:type="%s"' % self.extensiontype_) + ) + if self.rho is not None and "rho" not in already_processed: + already_processed.add("rho") + outfile.write( + " rho=%s" + % ( + self.gds_encode( + self.gds_format_string(quote_attrib(self.rho), input_name="rho") + ), + ) + ) def _exportChildren( self, @@ -54370,11 +54417,11 @@ def _exportChildren( level, namespaceprefix_="", namespacedef_="", - name_="BaseCurrentBasedSynapse", + name_="FixedFactorConcentrationModel", fromsubclass_=False, pretty_print=True, ): - super(BaseCurrentBasedSynapse, self)._exportChildren( + super(FixedFactorConcentrationModel, self)._exportChildren( outfile, level, namespaceprefix_, @@ -54388,6 +54435,20 @@ def validate_(self, gds_collector, recursive=False): self.gds_collector_ = gds_collector message_count = len(self.gds_collector_.get_messages()) # validate simple type attributes + self.gds_validate_defined_ST_( + self.validate_Nml2Quantity_concentration, self.resting_conc, "resting_conc" + ) + self.gds_check_cardinality_(self.resting_conc, "resting_conc", required=True) + self.gds_validate_defined_ST_( + self.validate_Nml2Quantity_time, self.decay_constant, "decay_constant" + ) + self.gds_check_cardinality_( + self.decay_constant, "decay_constant", required=True + ) + self.gds_validate_defined_ST_( + self.validate_Nml2Quantity_rhoFactor, self.rho, "rho" + ) + self.gds_check_cardinality_(self.rho, "rho", required=True) # validate simple type children # validate complex type children if recursive: @@ -54405,35 +54466,83 @@ def build(self, node, gds_collector_=None): nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) return self - - def _buildAttributes(self, node, attrs, already_processed): - value = find_attr_value_("xsi:type", node) - if value is not None and "xsi:type" not in already_processed: - already_processed.add("xsi:type") - self.extensiontype_ = value - super(BaseCurrentBasedSynapse, self)._buildAttributes( + + def _buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_("restingConc", node) + if value is not None and "restingConc" not in already_processed: + already_processed.add("restingConc") + self.resting_conc = value + self.validate_Nml2Quantity_concentration( + self.resting_conc + ) # validate type Nml2Quantity_concentration + value = find_attr_value_("decayConstant", node) + if value is not None and "decayConstant" not in already_processed: + already_processed.add("decayConstant") + self.decay_constant = value + self.validate_Nml2Quantity_time( + self.decay_constant + ) # validate type Nml2Quantity_time + value = find_attr_value_("rho", node) + if value is not None and "rho" not in already_processed: + already_processed.add("rho") + self.rho = value + self.validate_Nml2Quantity_rhoFactor( + self.rho + ) # validate type Nml2Quantity_rhoFactor + super(FixedFactorConcentrationModel, self)._buildAttributes( node, attrs, already_processed ) def _buildChildren( self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None ): - super(BaseCurrentBasedSynapse, self)._buildChildren( + super(FixedFactorConcentrationModel, self)._buildChildren( child_, node, nodeName_, True ) pass -# end class BaseCurrentBasedSynapse +# end class FixedFactorConcentrationModel -class BaseVoltageDepSynapse(BaseSynapse): - """BaseVoltageDepSynapse -- Base type for synapses with a dependence on membrane potential""" +class DecayingPoolConcentrationModel(ConcentrationModel): + """DecayingPoolConcentrationModel -- Model of an intracellular buffering mechanism for **ion** ( currently hard Coded to be calcium, due to requirement for **iCa** ) which has a baseline level **restingConc** and tends to this value with time course **decayConstant.** The ion is assumed to occupy a shell inside the membrane of thickness **shellThickness.** + \n + :param restingConc: + :type restingConc: concentration + :param decayConstant: + :type decayConstant: time + :param shellThickness: + :type shellThickness: length + + """ __hash__ = GeneratedsSuper.__hash__ - member_data_items_ = [] + member_data_items_ = [ + MemberSpec_( + "resting_conc", + "Nml2Quantity_concentration", + 0, + 0, + {"use": "required", "name": "resting_conc"}, + ), + MemberSpec_( + "decay_constant", + "Nml2Quantity_time", + 0, + 0, + {"use": "required", "name": "decay_constant"}, + ), + MemberSpec_( + "shell_thickness", + "Nml2Quantity_length", + 0, + 0, + {"use": "required", "name": "shell_thickness"}, + ), + ] subclass = None - superclass = BaseSynapse + superclass = ConcentrationModel def __init__( self, @@ -54442,7 +54551,10 @@ def __init__( notes: "a string (optional)" = None, properties: "list of Property(s) (optional)" = None, annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, + ion: "a NmlId (required)" = None, + resting_conc: "a Nml2Quantity_concentration (required)" = None, + decay_constant: "a Nml2Quantity_time (required)" = None, + shell_thickness: "a Nml2Quantity_length (required)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -54452,34 +54564,129 @@ def __init__( self.original_tagname_ = None self.parent_object_ = kwargs_.get("parent_object_") self.ns_prefix_ = None - super(globals().get("BaseVoltageDepSynapse"), self).__init__( - id, - metaid, - notes, - properties, - annotation, - neuro_lex_id, - extensiontype_, - **kwargs_, + super(globals().get("DecayingPoolConcentrationModel"), self).__init__( + id, metaid, notes, properties, annotation, ion, extensiontype_, **kwargs_ ) + self.resting_conc = _cast(None, resting_conc) + self.resting_conc_nsprefix_ = None + self.decay_constant = _cast(None, decay_constant) + self.decay_constant_nsprefix_ = None + self.shell_thickness = _cast(None, shell_thickness) + self.shell_thickness_nsprefix_ = None self.extensiontype_ = extensiontype_ def factory(*args_, **kwargs_): if CurrentSubclassModule_ is not None: subclass = getSubclassFromModule_( - CurrentSubclassModule_, BaseVoltageDepSynapse + CurrentSubclassModule_, DecayingPoolConcentrationModel ) if subclass is not None: return subclass(*args_, **kwargs_) - if BaseVoltageDepSynapse.subclass: - return BaseVoltageDepSynapse.subclass(*args_, **kwargs_) + if DecayingPoolConcentrationModel.subclass: + return DecayingPoolConcentrationModel.subclass(*args_, **kwargs_) else: - return BaseVoltageDepSynapse(*args_, **kwargs_) + return DecayingPoolConcentrationModel(*args_, **kwargs_) factory = staticmethod(factory) + def validate_Nml2Quantity_concentration(self, value): + # Validate type Nml2Quantity_concentration, a restriction on xs:string. + if ( + value is not None + and Validate_simpletypes_ + and self.gds_collector_ is not None + ): + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message( + 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' + % { + "value": value, + "lineno": lineno, + } + ) + return False + if not self.gds_validate_simple_patterns( + self.validate_Nml2Quantity_concentration_patterns_, value + ): + self.gds_collector_.add_message( + 'Value "%s" does not match xsd pattern restrictions: %s' + % ( + encode_str_2_3(value), + self.validate_Nml2Quantity_concentration_patterns_, + ) + ) + + validate_Nml2Quantity_concentration_patterns_ = [ + ["^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(mol_per_m3|mol_per_cm3|M|mM))$"] + ] + + def validate_Nml2Quantity_time(self, value): + # Validate type Nml2Quantity_time, a restriction on xs:string. + if ( + value is not None + and Validate_simpletypes_ + and self.gds_collector_ is not None + ): + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message( + 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' + % { + "value": value, + "lineno": lineno, + } + ) + return False + if not self.gds_validate_simple_patterns( + self.validate_Nml2Quantity_time_patterns_, value + ): + self.gds_collector_.add_message( + 'Value "%s" does not match xsd pattern restrictions: %s' + % ( + encode_str_2_3(value), + self.validate_Nml2Quantity_time_patterns_, + ) + ) + + validate_Nml2Quantity_time_patterns_ = [ + ["^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(s|ms))$"] + ] + + def validate_Nml2Quantity_length(self, value): + # Validate type Nml2Quantity_length, a restriction on xs:string. + if ( + value is not None + and Validate_simpletypes_ + and self.gds_collector_ is not None + ): + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message( + 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' + % { + "value": value, + "lineno": lineno, + } + ) + return False + if not self.gds_validate_simple_patterns( + self.validate_Nml2Quantity_length_patterns_, value + ): + self.gds_collector_.add_message( + 'Value "%s" does not match xsd pattern restrictions: %s' + % ( + encode_str_2_3(value), + self.validate_Nml2Quantity_length_patterns_, + ) + ) + + validate_Nml2Quantity_length_patterns_ = [ + ["^(-?([0-9]*(\\.[0-9]+)?)([eE]-?[0-9]+)?[\\s]*(m|cm|um))$"] + ] + def has__content(self): - if super(BaseVoltageDepSynapse, self).has__content(): + if super(DecayingPoolConcentrationModel, self).has__content(): return True else: return False @@ -54490,17 +54697,22 @@ def export( level, namespaceprefix_="", namespacedef_="", - name_="BaseVoltageDepSynapse", + name_="DecayingPoolConcentrationModel", pretty_print=True, ): - imported_ns_def_ = GenerateDSNamespaceDefs_.get("BaseVoltageDepSynapse") + imported_ns_def_ = GenerateDSNamespaceDefs_.get( + "DecayingPoolConcentrationModel" + ) if imported_ns_def_ is not None: namespacedef_ = imported_ns_def_ if pretty_print: eol_ = "\n" else: eol_ = "" - if self.original_tagname_ is not None and name_ == "BaseVoltageDepSynapse": + if ( + self.original_tagname_ is not None + and name_ == "DecayingPoolConcentrationModel" + ): name_ = self.original_tagname_ if UseCapturedNS_ and self.ns_prefix_: namespaceprefix_ = self.ns_prefix_ + ":" @@ -54519,7 +54731,7 @@ def export( level, already_processed, namespaceprefix_, - name_="BaseVoltageDepSynapse", + name_="DecayingPoolConcentrationModel", ) if self.has__content(): outfile.write(">%s" % (eol_,)) @@ -54528,7 +54740,7 @@ def export( level + 1, namespaceprefix_, namespacedef_, - name_="BaseVoltageDepSynapse", + name_="DecayingPoolConcentrationModel", pretty_print=pretty_print, ) showIndent(outfile, level, pretty_print) @@ -54542,15 +54754,59 @@ def _exportAttributes( level, already_processed, namespaceprefix_="", - name_="BaseVoltageDepSynapse", + name_="DecayingPoolConcentrationModel", ): - super(BaseVoltageDepSynapse, self)._exportAttributes( + super(DecayingPoolConcentrationModel, self)._exportAttributes( outfile, level, already_processed, namespaceprefix_, - name_="BaseVoltageDepSynapse", + name_="DecayingPoolConcentrationModel", ) + if self.resting_conc is not None and "resting_conc" not in already_processed: + already_processed.add("resting_conc") + outfile.write( + " restingConc=%s" + % ( + self.gds_encode( + self.gds_format_string( + quote_attrib(self.resting_conc), input_name="restingConc" + ) + ), + ) + ) + if ( + self.decay_constant is not None + and "decay_constant" not in already_processed + ): + already_processed.add("decay_constant") + outfile.write( + " decayConstant=%s" + % ( + self.gds_encode( + self.gds_format_string( + quote_attrib(self.decay_constant), + input_name="decayConstant", + ) + ), + ) + ) + if ( + self.shell_thickness is not None + and "shell_thickness" not in already_processed + ): + already_processed.add("shell_thickness") + outfile.write( + " shellThickness=%s" + % ( + self.gds_encode( + self.gds_format_string( + quote_attrib(self.shell_thickness), + input_name="shellThickness", + ) + ), + ) + ) if self.extensiontype_ is not None and "xsi:type" not in already_processed: already_processed.add("xsi:type") outfile.write(' xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"') @@ -54570,11 +54826,11 @@ def _exportChildren( level, namespaceprefix_="", namespacedef_="", - name_="BaseVoltageDepSynapse", + name_="DecayingPoolConcentrationModel", fromsubclass_=False, pretty_print=True, ): - super(BaseVoltageDepSynapse, self)._exportChildren( + super(DecayingPoolConcentrationModel, self)._exportChildren( outfile, level, namespaceprefix_, @@ -54588,6 +54844,22 @@ def validate_(self, gds_collector, recursive=False): self.gds_collector_ = gds_collector message_count = len(self.gds_collector_.get_messages()) # validate simple type attributes + self.gds_validate_defined_ST_( + self.validate_Nml2Quantity_concentration, self.resting_conc, "resting_conc" + ) + self.gds_check_cardinality_(self.resting_conc, "resting_conc", required=True) + self.gds_validate_defined_ST_( + self.validate_Nml2Quantity_time, self.decay_constant, "decay_constant" + ) + self.gds_check_cardinality_( + self.decay_constant, "decay_constant", required=True + ) + self.gds_validate_defined_ST_( + self.validate_Nml2Quantity_length, self.shell_thickness, "shell_thickness" + ) + self.gds_check_cardinality_( + self.shell_thickness, "shell_thickness", required=True + ) # validate simple type children # validate complex type children if recursive: @@ -54607,22 +54879,45 @@ def build(self, node, gds_collector_=None): return self def _buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_("restingConc", node) + if value is not None and "restingConc" not in already_processed: + already_processed.add("restingConc") + self.resting_conc = value + self.validate_Nml2Quantity_concentration( + self.resting_conc + ) # validate type Nml2Quantity_concentration + value = find_attr_value_("decayConstant", node) + if value is not None and "decayConstant" not in already_processed: + already_processed.add("decayConstant") + self.decay_constant = value + self.validate_Nml2Quantity_time( + self.decay_constant + ) # validate type Nml2Quantity_time + value = find_attr_value_("shellThickness", node) + if value is not None and "shellThickness" not in already_processed: + already_processed.add("shellThickness") + self.shell_thickness = value + self.validate_Nml2Quantity_length( + self.shell_thickness + ) # validate type Nml2Quantity_length value = find_attr_value_("xsi:type", node) if value is not None and "xsi:type" not in already_processed: already_processed.add("xsi:type") self.extensiontype_ = value - super(BaseVoltageDepSynapse, self)._buildAttributes( + super(DecayingPoolConcentrationModel, self)._buildAttributes( node, attrs, already_processed ) def _buildChildren( self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None ): - super(BaseVoltageDepSynapse, self)._buildChildren(child_, node, nodeName_, True) + super(DecayingPoolConcentrationModel, self)._buildChildren( + child_, node, nodeName_, True + ) pass -# end class BaseVoltageDepSynapse +# end class DecayingPoolConcentrationModel class IonChannel(IonChannelScalable): @@ -59350,6 +59645,212 @@ def __str__(self): # end class Connection +class ConcentrationModel_D(DecayingPoolConcentrationModel): + __hash__ = GeneratedsSuper.__hash__ + member_data_items_ = [ + MemberSpec_("type", "xs:string", 0, 0, {"use": "required", "name": "type"}), + ] + subclass = None + superclass = DecayingPoolConcentrationModel + + def __init__( + self, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + ion: "a NmlId (required)" = None, + resting_conc: "a Nml2Quantity_concentration (required)" = None, + decay_constant: "a Nml2Quantity_time (required)" = None, + shell_thickness: "a Nml2Quantity_length (required)" = None, + type: "a string (required)" = "decayingPoolConcentrationModel", + gds_collector_=None, + **kwargs_, + ): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get("parent_object_") + self.ns_prefix_ = None + super(globals().get("ConcentrationModel_D"), self).__init__( + id, + metaid, + notes, + properties, + annotation, + ion, + resting_conc, + decay_constant, + shell_thickness, + **kwargs_, + ) + self.type = _cast(None, type) + self.type_nsprefix_ = None + + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, ConcentrationModel_D + ) + if subclass is not None: + return subclass(*args_, **kwargs_) + if ConcentrationModel_D.subclass: + return ConcentrationModel_D.subclass(*args_, **kwargs_) + else: + return ConcentrationModel_D(*args_, **kwargs_) + + factory = staticmethod(factory) + + def has__content(self): + if super(ConcentrationModel_D, self).has__content(): + return True + else: + return False + + def export( + self, + outfile, + level, + namespaceprefix_="", + namespacedef_="", + name_="ConcentrationModel_D", + pretty_print=True, + ): + imported_ns_def_ = GenerateDSNamespaceDefs_.get("ConcentrationModel_D") + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = "\n" + else: + eol_ = "" + if self.original_tagname_ is not None and name_ == "ConcentrationModel_D": + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ":" + showIndent(outfile, level, pretty_print) + outfile.write( + "<%s%s%s" + % ( + namespaceprefix_, + name_, + namespacedef_ and " " + namespacedef_ or "", + ) + ) + already_processed = set() + self._exportAttributes( + outfile, + level, + already_processed, + namespaceprefix_, + name_="ConcentrationModel_D", + ) + if self.has__content(): + outfile.write(">%s" % (eol_,)) + self._exportChildren( + outfile, + level + 1, + namespaceprefix_, + namespacedef_, + name_="ConcentrationModel_D", + pretty_print=pretty_print, + ) + showIndent(outfile, level, pretty_print) + outfile.write("%s" % (namespaceprefix_, name_, eol_)) + else: + outfile.write("/>%s" % (eol_,)) + + def _exportAttributes( + self, + outfile, + level, + already_processed, + namespaceprefix_="", + name_="ConcentrationModel_D", + ): + super(ConcentrationModel_D, self)._exportAttributes( + outfile, + level, + already_processed, + namespaceprefix_, + name_="ConcentrationModel_D", + ) + if self.type is not None and "type" not in already_processed: + already_processed.add("type") + outfile.write( + " type=%s" + % ( + self.gds_encode( + self.gds_format_string( + quote_attrib(self.type), input_name="type" + ) + ), + ) + ) + + def _exportChildren( + self, + outfile, + level, + namespaceprefix_="", + namespacedef_="", + name_="ConcentrationModel_D", + fromsubclass_=False, + pretty_print=True, + ): + super(ConcentrationModel_D, self)._exportChildren( + outfile, + level, + namespaceprefix_, + namespacedef_, + name_, + True, + pretty_print=pretty_print, + ) + + def validate_(self, gds_collector, recursive=False): + self.gds_collector_ = gds_collector + message_count = len(self.gds_collector_.get_messages()) + # validate simple type attributes + self.gds_validate_builtin_ST_(self.gds_validate_string, self.type, "type") + self.gds_check_cardinality_(self.type, "type", required=True) + # validate simple type children + # validate complex type children + if recursive: + pass + return message_count == len(self.gds_collector_.get_messages()) + + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self._buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + + def _buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_("type", node) + if value is not None and "type" not in already_processed: + already_processed.add("type") + self.type = value + super(ConcentrationModel_D, self)._buildAttributes( + node, attrs, already_processed + ) + + def _buildChildren( + self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None + ): + super(ConcentrationModel_D, self)._buildChildren(child_, node, nodeName_, True) + pass + + +# end class ConcentrationModel_D + + class Cell2CaPools(Cell): """Cell2CaPools -- Variant of cell with two independent Ca2+ pools. Cell with **segment** s specified in a **morphology** element along with details on its **biophysicalProperties** . NOTE: this can only be correctly simulated using jLEMS when there is a single segment in the cell, and **v** of this cell represents the membrane potential in that isopotential segment.""" @@ -67820,243 +68321,245 @@ def main(): # simpleTypes are marked "ST" and complexTypes "CT". NamespaceToDefMappings_ = { "http://www.neuroml.org/schema/neuroml2": [ - ("NmlId", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_none", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_voltage", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_length", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_resistance", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_resistivity", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_conductance", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_conductanceDensity", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_permeability", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_time", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_pertime", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_capacitance", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_specificCapacitance", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_concentration", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_current", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_currentDensity", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_temperature", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_rhoFactor", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2Quantity_conductancePerVoltage", "NeuroML_v2.3.1.xsd", "ST"), - ("MetaId", "NeuroML_v2.3.1.xsd", "ST"), - ("NeuroLexId", "NeuroML_v2.3.1.xsd", "ST"), - ("Nml2PopulationReferencePath", "NeuroML_v2.3.1.xsd", "ST"), - ("NonNegativeInteger", "NeuroML_v2.3.1.xsd", "ST"), - ("PositiveInteger", "NeuroML_v2.3.1.xsd", "ST"), - ("DoubleGreaterThanZero", "NeuroML_v2.3.1.xsd", "ST"), - ("ZeroOrOne", "NeuroML_v2.3.1.xsd", "ST"), - ("Notes", "NeuroML_v2.3.1.xsd", "ST"), - ("TrueOrFalse", "NeuroML_v2.3.1.xsd", "ST"), - ("ZeroToOne", "NeuroML_v2.3.1.xsd", "ST"), - ("channelTypes", "NeuroML_v2.3.1.xsd", "ST"), - ("gateTypes", "NeuroML_v2.3.1.xsd", "ST"), - ("BlockTypes", "NeuroML_v2.3.1.xsd", "ST"), - ("PlasticityTypes", "NeuroML_v2.3.1.xsd", "ST"), - ("Metric", "NeuroML_v2.3.1.xsd", "ST"), - ("networkTypes", "NeuroML_v2.3.1.xsd", "ST"), - ("allowedSpaces", "NeuroML_v2.3.1.xsd", "ST"), - ("populationTypes", "NeuroML_v2.3.1.xsd", "ST"), - ("Property", "NeuroML_v2.3.1.xsd", "CT"), - ("Annotation", "NeuroML_v2.3.1.xsd", "CT"), - ("ComponentType", "NeuroML_v2.3.1.xsd", "CT"), - ("Constant", "NeuroML_v2.3.1.xsd", "CT"), - ("Exposure", "NeuroML_v2.3.1.xsd", "CT"), - ("NamedDimensionalType", "NeuroML_v2.3.1.xsd", "CT"), - ("NamedDimensionalVariable", "NeuroML_v2.3.1.xsd", "CT"), - ("Parameter", "NeuroML_v2.3.1.xsd", "CT"), - ("DerivedParameter", "NeuroML_v2.3.1.xsd", "CT"), - ("LEMS_Property", "NeuroML_v2.3.1.xsd", "CT"), - ("Requirement", "NeuroML_v2.3.1.xsd", "CT"), - ("InstanceRequirement", "NeuroML_v2.3.1.xsd", "CT"), - ("Dynamics", "NeuroML_v2.3.1.xsd", "CT"), - ("DerivedVariable", "NeuroML_v2.3.1.xsd", "CT"), - ("StateVariable", "NeuroML_v2.3.1.xsd", "CT"), - ("ConditionalDerivedVariable", "NeuroML_v2.3.1.xsd", "CT"), - ("Case", "NeuroML_v2.3.1.xsd", "CT"), - ("TimeDerivative", "NeuroML_v2.3.1.xsd", "CT"), - ("OnStart", "NeuroML_v2.3.1.xsd", "CT"), - ("StateAssignment", "NeuroML_v2.3.1.xsd", "CT"), - ("OnEvent", "NeuroML_v2.3.1.xsd", "CT"), - ("EventOut", "NeuroML_v2.3.1.xsd", "CT"), - ("OnCondition", "NeuroML_v2.3.1.xsd", "CT"), - ("Transition", "NeuroML_v2.3.1.xsd", "CT"), - ("Regime", "NeuroML_v2.3.1.xsd", "CT"), - ("OnEntry", "NeuroML_v2.3.1.xsd", "CT"), - ("NeuroMLDocument", "NeuroML_v2.3.1.xsd", "CT"), - ("IncludeType", "NeuroML_v2.3.1.xsd", "CT"), - ("IonChannelScalable", "NeuroML_v2.3.1.xsd", "CT"), - ("IonChannelKS", "NeuroML_v2.3.1.xsd", "CT"), - ("IonChannel", "NeuroML_v2.3.1.xsd", "CT"), - ("IonChannelHH", "NeuroML_v2.3.1.xsd", "CT"), - ("IonChannelVShift", "NeuroML_v2.3.1.xsd", "CT"), - ("Q10ConductanceScaling", "NeuroML_v2.3.1.xsd", "CT"), - ("ClosedState", "NeuroML_v2.3.1.xsd", "CT"), - ("OpenState", "NeuroML_v2.3.1.xsd", "CT"), - ("ForwardTransition", "NeuroML_v2.3.1.xsd", "CT"), - ("ReverseTransition", "NeuroML_v2.3.1.xsd", "CT"), - ("TauInfTransition", "NeuroML_v2.3.1.xsd", "CT"), - ("GateKS", "NeuroML_v2.3.1.xsd", "CT"), - ("GateHHUndetermined", "NeuroML_v2.3.1.xsd", "CT"), - ("GateHHRates", "NeuroML_v2.3.1.xsd", "CT"), - ("GateHHTauInf", "NeuroML_v2.3.1.xsd", "CT"), - ("GateHHRatesTauInf", "NeuroML_v2.3.1.xsd", "CT"), - ("GateHHRatesTau", "NeuroML_v2.3.1.xsd", "CT"), - ("GateHHRatesInf", "NeuroML_v2.3.1.xsd", "CT"), - ("GateHHInstantaneous", "NeuroML_v2.3.1.xsd", "CT"), - ("GateFractional", "NeuroML_v2.3.1.xsd", "CT"), - ("GateFractionalSubgate", "NeuroML_v2.3.1.xsd", "CT"), - ("Q10Settings", "NeuroML_v2.3.1.xsd", "CT"), - ("HHRate", "NeuroML_v2.3.1.xsd", "CT"), - ("HHVariable", "NeuroML_v2.3.1.xsd", "CT"), - ("HHTime", "NeuroML_v2.3.1.xsd", "CT"), - ("DecayingPoolConcentrationModel", "NeuroML_v2.3.1.xsd", "CT"), - ("FixedFactorConcentrationModel", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseVoltageDepSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseCurrentBasedSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseConductanceBasedSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseConductanceBasedSynapseTwo", "NeuroML_v2.3.1.xsd", "CT"), - ("GapJunction", "NeuroML_v2.3.1.xsd", "CT"), - ("SilentSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("LinearGradedSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("GradedSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("AlphaCurrentSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("AlphaSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("ExpOneSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("ExpTwoSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("ExpThreeSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("DoubleSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("BlockingPlasticSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("BlockMechanism", "NeuroML_v2.3.1.xsd", "CT"), - ("PlasticityMechanism", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseCell", "NeuroML_v2.3.1.xsd", "CT"), - ("IafTauCell", "NeuroML_v2.3.1.xsd", "CT"), - ("IafTauRefCell", "NeuroML_v2.3.1.xsd", "CT"), - ("IafCell", "NeuroML_v2.3.1.xsd", "CT"), - ("IafRefCell", "NeuroML_v2.3.1.xsd", "CT"), - ("IzhikevichCell", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseCellMembPotCap", "NeuroML_v2.3.1.xsd", "CT"), - ("Izhikevich2007Cell", "NeuroML_v2.3.1.xsd", "CT"), - ("AdExIaFCell", "NeuroML_v2.3.1.xsd", "CT"), - ("FitzHughNagumoCell", "NeuroML_v2.3.1.xsd", "CT"), - ("FitzHughNagumo1969Cell", "NeuroML_v2.3.1.xsd", "CT"), - ("PinskyRinzelCA3Cell", "NeuroML_v2.3.1.xsd", "CT"), - ("HindmarshRose1984Cell", "NeuroML_v2.3.1.xsd", "CT"), - ("Cell", "NeuroML_v2.3.1.xsd", "CT"), - ("Cell2CaPools", "NeuroML_v2.3.1.xsd", "CT"), - ("Morphology", "NeuroML_v2.3.1.xsd", "CT"), - ("Segment", "NeuroML_v2.3.1.xsd", "CT"), - ("SegmentParent", "NeuroML_v2.3.1.xsd", "CT"), - ("Point3DWithDiam", "NeuroML_v2.3.1.xsd", "CT"), - ("SegmentGroup", "NeuroML_v2.3.1.xsd", "CT"), - ("InhomogeneousParameter", "NeuroML_v2.3.1.xsd", "CT"), - ("ProximalDetails", "NeuroML_v2.3.1.xsd", "CT"), - ("DistalDetails", "NeuroML_v2.3.1.xsd", "CT"), - ("Member", "NeuroML_v2.3.1.xsd", "CT"), - ("Include", "NeuroML_v2.3.1.xsd", "CT"), - ("Path", "NeuroML_v2.3.1.xsd", "CT"), - ("SubTree", "NeuroML_v2.3.1.xsd", "CT"), - ("SegmentEndPoint", "NeuroML_v2.3.1.xsd", "CT"), - ("BiophysicalProperties", "NeuroML_v2.3.1.xsd", "CT"), - ("BiophysicalProperties2CaPools", "NeuroML_v2.3.1.xsd", "CT"), - ("MembraneProperties", "NeuroML_v2.3.1.xsd", "CT"), - ("MembraneProperties2CaPools", "NeuroML_v2.3.1.xsd", "CT"), - ("SpikeThresh", "NeuroML_v2.3.1.xsd", "CT"), - ("SpecificCapacitance", "NeuroML_v2.3.1.xsd", "CT"), - ("InitMembPotential", "NeuroML_v2.3.1.xsd", "CT"), - ("Resistivity", "NeuroML_v2.3.1.xsd", "CT"), - ("ChannelPopulation", "NeuroML_v2.3.1.xsd", "CT"), - ("ChannelDensityNonUniform", "NeuroML_v2.3.1.xsd", "CT"), - ("ChannelDensityNonUniformNernst", "NeuroML_v2.3.1.xsd", "CT"), - ("ChannelDensityNonUniformGHK", "NeuroML_v2.3.1.xsd", "CT"), - ("ChannelDensity", "NeuroML_v2.3.1.xsd", "CT"), - ("ChannelDensityVShift", "NeuroML_v2.3.1.xsd", "CT"), - ("ChannelDensityNernst", "NeuroML_v2.3.1.xsd", "CT"), - ("ChannelDensityNernstCa2", "NeuroML_v2.3.1.xsd", "CT"), - ("ChannelDensityGHK", "NeuroML_v2.3.1.xsd", "CT"), - ("ChannelDensityGHK2", "NeuroML_v2.3.1.xsd", "CT"), - ("VariableParameter", "NeuroML_v2.3.1.xsd", "CT"), - ("InhomogeneousValue", "NeuroML_v2.3.1.xsd", "CT"), - ("Species", "NeuroML_v2.3.1.xsd", "CT"), - ("ConcentrationModel_D", "NeuroML_v2.3.1.xsd", "CT"), - ("IntracellularProperties", "NeuroML_v2.3.1.xsd", "CT"), - ("IntracellularProperties2CaPools", "NeuroML_v2.3.1.xsd", "CT"), - ("ExtracellularProperties", "NeuroML_v2.3.1.xsd", "CT"), - ("ExtracellularPropertiesLocal", "NeuroML_v2.3.1.xsd", "CT"), - ("ReactionScheme", "NeuroML_v2.3.1.xsd", "CT"), - ("PulseGenerator", "NeuroML_v2.3.1.xsd", "CT"), - ("PulseGeneratorDL", "NeuroML_v2.3.1.xsd", "CT"), - ("SineGenerator", "NeuroML_v2.3.1.xsd", "CT"), - ("SineGeneratorDL", "NeuroML_v2.3.1.xsd", "CT"), - ("RampGenerator", "NeuroML_v2.3.1.xsd", "CT"), - ("RampGeneratorDL", "NeuroML_v2.3.1.xsd", "CT"), - ("CompoundInput", "NeuroML_v2.3.1.xsd", "CT"), - ("CompoundInputDL", "NeuroML_v2.3.1.xsd", "CT"), - ("VoltageClamp", "NeuroML_v2.3.1.xsd", "CT"), - ("VoltageClampTriple", "NeuroML_v2.3.1.xsd", "CT"), - ("Spike", "NeuroML_v2.3.1.xsd", "CT"), - ("SpikeArray", "NeuroML_v2.3.1.xsd", "CT"), - ("TimedSynapticInput", "NeuroML_v2.3.1.xsd", "CT"), - ("SpikeGenerator", "NeuroML_v2.3.1.xsd", "CT"), - ("SpikeGeneratorRandom", "NeuroML_v2.3.1.xsd", "CT"), - ("SpikeGeneratorPoisson", "NeuroML_v2.3.1.xsd", "CT"), - ("SpikeGeneratorRefPoisson", "NeuroML_v2.3.1.xsd", "CT"), - ("PoissonFiringSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("TransientPoissonFiringSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("Network", "NeuroML_v2.3.1.xsd", "CT"), - ("Space", "NeuroML_v2.3.1.xsd", "CT"), - ("SpaceStructure", "NeuroML_v2.3.1.xsd", "CT"), - ("Region", "NeuroML_v2.3.1.xsd", "CT"), - ("Population", "NeuroML_v2.3.1.xsd", "CT"), - ("Layout", "NeuroML_v2.3.1.xsd", "CT"), - ("UnstructuredLayout", "NeuroML_v2.3.1.xsd", "CT"), - ("RandomLayout", "NeuroML_v2.3.1.xsd", "CT"), - ("GridLayout", "NeuroML_v2.3.1.xsd", "CT"), - ("Instance", "NeuroML_v2.3.1.xsd", "CT"), - ("Location", "NeuroML_v2.3.1.xsd", "CT"), - ("CellSet", "NeuroML_v2.3.1.xsd", "CT"), - ("SynapticConnection", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseProjection", "NeuroML_v2.3.1.xsd", "CT"), - ("Projection", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseConnection", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseConnectionOldFormat", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseConnectionNewFormat", "NeuroML_v2.3.1.xsd", "CT"), - ("Connection", "NeuroML_v2.3.1.xsd", "CT"), - ("ConnectionWD", "NeuroML_v2.3.1.xsd", "CT"), - ("ElectricalProjection", "NeuroML_v2.3.1.xsd", "CT"), - ("ElectricalConnection", "NeuroML_v2.3.1.xsd", "CT"), - ("ElectricalConnectionInstance", "NeuroML_v2.3.1.xsd", "CT"), - ("ElectricalConnectionInstanceW", "NeuroML_v2.3.1.xsd", "CT"), - ("ContinuousProjection", "NeuroML_v2.3.1.xsd", "CT"), - ("ContinuousConnection", "NeuroML_v2.3.1.xsd", "CT"), - ("ContinuousConnectionInstance", "NeuroML_v2.3.1.xsd", "CT"), - ("ContinuousConnectionInstanceW", "NeuroML_v2.3.1.xsd", "CT"), - ("ExplicitInput", "NeuroML_v2.3.1.xsd", "CT"), - ("InputList", "NeuroML_v2.3.1.xsd", "CT"), - ("Input", "NeuroML_v2.3.1.xsd", "CT"), - ("InputW", "NeuroML_v2.3.1.xsd", "CT"), - ("basePyNNCell", "NeuroML_v2.3.1.xsd", "CT"), - ("basePyNNIaFCell", "NeuroML_v2.3.1.xsd", "CT"), - ("basePyNNIaFCondCell", "NeuroML_v2.3.1.xsd", "CT"), - ("IF_curr_alpha", "NeuroML_v2.3.1.xsd", "CT"), - ("IF_curr_exp", "NeuroML_v2.3.1.xsd", "CT"), - ("IF_cond_alpha", "NeuroML_v2.3.1.xsd", "CT"), - ("IF_cond_exp", "NeuroML_v2.3.1.xsd", "CT"), - ("EIF_cond_exp_isfa_ista", "NeuroML_v2.3.1.xsd", "CT"), - ("EIF_cond_alpha_isfa_ista", "NeuroML_v2.3.1.xsd", "CT"), - ("HH_cond_exp", "NeuroML_v2.3.1.xsd", "CT"), - ("BasePynnSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("ExpCondSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("AlphaCondSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("ExpCurrSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("AlphaCurrSynapse", "NeuroML_v2.3.1.xsd", "CT"), - ("SpikeSourcePoisson", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseWithoutId", "NeuroML_v2.3.1.xsd", "CT"), - ("BaseNonNegativeIntegerId", "NeuroML_v2.3.1.xsd", "CT"), - ("Base", "NeuroML_v2.3.1.xsd", "CT"), - ("Standalone", "NeuroML_v2.3.1.xsd", "CT"), + ("NmlId", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_none", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_voltage", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_length", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_resistance", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_resistivity", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_conductance", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_conductanceDensity", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_permeability", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_time", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_pertime", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_capacitance", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_specificCapacitance", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_concentration", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_current", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_currentDensity", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_temperature", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_rhoFactor", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2Quantity_conductancePerVoltage", "NeuroML_v2.3.2.xsd", "ST"), + ("MetaId", "NeuroML_v2.3.2.xsd", "ST"), + ("NeuroLexId", "NeuroML_v2.3.2.xsd", "ST"), + ("Nml2PopulationReferencePath", "NeuroML_v2.3.2.xsd", "ST"), + ("NonNegativeInteger", "NeuroML_v2.3.2.xsd", "ST"), + ("PositiveInteger", "NeuroML_v2.3.2.xsd", "ST"), + ("DoubleGreaterThanZero", "NeuroML_v2.3.2.xsd", "ST"), + ("ZeroOrOne", "NeuroML_v2.3.2.xsd", "ST"), + ("Notes", "NeuroML_v2.3.2.xsd", "ST"), + ("TrueOrFalse", "NeuroML_v2.3.2.xsd", "ST"), + ("ZeroToOne", "NeuroML_v2.3.2.xsd", "ST"), + ("channelTypes", "NeuroML_v2.3.2.xsd", "ST"), + ("gateTypes", "NeuroML_v2.3.2.xsd", "ST"), + ("BlockTypes", "NeuroML_v2.3.2.xsd", "ST"), + ("PlasticityTypes", "NeuroML_v2.3.2.xsd", "ST"), + ("Metric", "NeuroML_v2.3.2.xsd", "ST"), + ("networkTypes", "NeuroML_v2.3.2.xsd", "ST"), + ("allowedSpaces", "NeuroML_v2.3.2.xsd", "ST"), + ("populationTypes", "NeuroML_v2.3.2.xsd", "ST"), + ("Property", "NeuroML_v2.3.2.xsd", "CT"), + ("Annotation", "NeuroML_v2.3.2.xsd", "CT"), + ("ComponentType", "NeuroML_v2.3.2.xsd", "CT"), + ("Constant", "NeuroML_v2.3.2.xsd", "CT"), + ("Component", "NeuroML_v2.3.2.xsd", "CT"), + ("Exposure", "NeuroML_v2.3.2.xsd", "CT"), + ("NamedDimensionalType", "NeuroML_v2.3.2.xsd", "CT"), + ("NamedDimensionalVariable", "NeuroML_v2.3.2.xsd", "CT"), + ("Parameter", "NeuroML_v2.3.2.xsd", "CT"), + ("DerivedParameter", "NeuroML_v2.3.2.xsd", "CT"), + ("LEMS_Property", "NeuroML_v2.3.2.xsd", "CT"), + ("Requirement", "NeuroML_v2.3.2.xsd", "CT"), + ("InstanceRequirement", "NeuroML_v2.3.2.xsd", "CT"), + ("Dynamics", "NeuroML_v2.3.2.xsd", "CT"), + ("DerivedVariable", "NeuroML_v2.3.2.xsd", "CT"), + ("StateVariable", "NeuroML_v2.3.2.xsd", "CT"), + ("ConditionalDerivedVariable", "NeuroML_v2.3.2.xsd", "CT"), + ("Case", "NeuroML_v2.3.2.xsd", "CT"), + ("TimeDerivative", "NeuroML_v2.3.2.xsd", "CT"), + ("OnStart", "NeuroML_v2.3.2.xsd", "CT"), + ("StateAssignment", "NeuroML_v2.3.2.xsd", "CT"), + ("OnEvent", "NeuroML_v2.3.2.xsd", "CT"), + ("EventOut", "NeuroML_v2.3.2.xsd", "CT"), + ("OnCondition", "NeuroML_v2.3.2.xsd", "CT"), + ("Transition", "NeuroML_v2.3.2.xsd", "CT"), + ("Regime", "NeuroML_v2.3.2.xsd", "CT"), + ("OnEntry", "NeuroML_v2.3.2.xsd", "CT"), + ("NeuroMLDocument", "NeuroML_v2.3.2.xsd", "CT"), + ("IncludeType", "NeuroML_v2.3.2.xsd", "CT"), + ("IonChannelScalable", "NeuroML_v2.3.2.xsd", "CT"), + ("IonChannelKS", "NeuroML_v2.3.2.xsd", "CT"), + ("IonChannel", "NeuroML_v2.3.2.xsd", "CT"), + ("IonChannelHH", "NeuroML_v2.3.2.xsd", "CT"), + ("IonChannelVShift", "NeuroML_v2.3.2.xsd", "CT"), + ("Q10ConductanceScaling", "NeuroML_v2.3.2.xsd", "CT"), + ("ClosedState", "NeuroML_v2.3.2.xsd", "CT"), + ("OpenState", "NeuroML_v2.3.2.xsd", "CT"), + ("ForwardTransition", "NeuroML_v2.3.2.xsd", "CT"), + ("ReverseTransition", "NeuroML_v2.3.2.xsd", "CT"), + ("TauInfTransition", "NeuroML_v2.3.2.xsd", "CT"), + ("GateKS", "NeuroML_v2.3.2.xsd", "CT"), + ("GateHHUndetermined", "NeuroML_v2.3.2.xsd", "CT"), + ("GateHHRates", "NeuroML_v2.3.2.xsd", "CT"), + ("GateHHTauInf", "NeuroML_v2.3.2.xsd", "CT"), + ("GateHHRatesTauInf", "NeuroML_v2.3.2.xsd", "CT"), + ("GateHHRatesTau", "NeuroML_v2.3.2.xsd", "CT"), + ("GateHHRatesInf", "NeuroML_v2.3.2.xsd", "CT"), + ("GateHHInstantaneous", "NeuroML_v2.3.2.xsd", "CT"), + ("GateFractional", "NeuroML_v2.3.2.xsd", "CT"), + ("GateFractionalSubgate", "NeuroML_v2.3.2.xsd", "CT"), + ("Q10Settings", "NeuroML_v2.3.2.xsd", "CT"), + ("HHRate", "NeuroML_v2.3.2.xsd", "CT"), + ("HHVariable", "NeuroML_v2.3.2.xsd", "CT"), + ("HHTime", "NeuroML_v2.3.2.xsd", "CT"), + ("ConcentrationModel", "NeuroML_v2.3.2.xsd", "CT"), + ("DecayingPoolConcentrationModel", "NeuroML_v2.3.2.xsd", "CT"), + ("FixedFactorConcentrationModel", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseVoltageDepSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseCurrentBasedSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseConductanceBasedSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseConductanceBasedSynapseTwo", "NeuroML_v2.3.2.xsd", "CT"), + ("GapJunction", "NeuroML_v2.3.2.xsd", "CT"), + ("SilentSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("LinearGradedSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("GradedSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("AlphaCurrentSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("AlphaSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("ExpOneSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("ExpTwoSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("ExpThreeSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("DoubleSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("BlockingPlasticSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("BlockMechanism", "NeuroML_v2.3.2.xsd", "CT"), + ("PlasticityMechanism", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseCell", "NeuroML_v2.3.2.xsd", "CT"), + ("IafTauCell", "NeuroML_v2.3.2.xsd", "CT"), + ("IafTauRefCell", "NeuroML_v2.3.2.xsd", "CT"), + ("IafCell", "NeuroML_v2.3.2.xsd", "CT"), + ("IafRefCell", "NeuroML_v2.3.2.xsd", "CT"), + ("IzhikevichCell", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseCellMembPotCap", "NeuroML_v2.3.2.xsd", "CT"), + ("Izhikevich2007Cell", "NeuroML_v2.3.2.xsd", "CT"), + ("AdExIaFCell", "NeuroML_v2.3.2.xsd", "CT"), + ("FitzHughNagumoCell", "NeuroML_v2.3.2.xsd", "CT"), + ("FitzHughNagumo1969Cell", "NeuroML_v2.3.2.xsd", "CT"), + ("PinskyRinzelCA3Cell", "NeuroML_v2.3.2.xsd", "CT"), + ("HindmarshRose1984Cell", "NeuroML_v2.3.2.xsd", "CT"), + ("Cell", "NeuroML_v2.3.2.xsd", "CT"), + ("Cell2CaPools", "NeuroML_v2.3.2.xsd", "CT"), + ("Morphology", "NeuroML_v2.3.2.xsd", "CT"), + ("Segment", "NeuroML_v2.3.2.xsd", "CT"), + ("SegmentParent", "NeuroML_v2.3.2.xsd", "CT"), + ("Point3DWithDiam", "NeuroML_v2.3.2.xsd", "CT"), + ("SegmentGroup", "NeuroML_v2.3.2.xsd", "CT"), + ("InhomogeneousParameter", "NeuroML_v2.3.2.xsd", "CT"), + ("ProximalDetails", "NeuroML_v2.3.2.xsd", "CT"), + ("DistalDetails", "NeuroML_v2.3.2.xsd", "CT"), + ("Member", "NeuroML_v2.3.2.xsd", "CT"), + ("Include", "NeuroML_v2.3.2.xsd", "CT"), + ("Path", "NeuroML_v2.3.2.xsd", "CT"), + ("SubTree", "NeuroML_v2.3.2.xsd", "CT"), + ("SegmentEndPoint", "NeuroML_v2.3.2.xsd", "CT"), + ("BiophysicalProperties", "NeuroML_v2.3.2.xsd", "CT"), + ("BiophysicalProperties2CaPools", "NeuroML_v2.3.2.xsd", "CT"), + ("MembraneProperties", "NeuroML_v2.3.2.xsd", "CT"), + ("MembraneProperties2CaPools", "NeuroML_v2.3.2.xsd", "CT"), + ("SpikeThresh", "NeuroML_v2.3.2.xsd", "CT"), + ("SpecificCapacitance", "NeuroML_v2.3.2.xsd", "CT"), + ("InitMembPotential", "NeuroML_v2.3.2.xsd", "CT"), + ("Resistivity", "NeuroML_v2.3.2.xsd", "CT"), + ("ChannelPopulation", "NeuroML_v2.3.2.xsd", "CT"), + ("ChannelDensityNonUniform", "NeuroML_v2.3.2.xsd", "CT"), + ("ChannelDensityNonUniformNernst", "NeuroML_v2.3.2.xsd", "CT"), + ("ChannelDensityNonUniformGHK", "NeuroML_v2.3.2.xsd", "CT"), + ("ChannelDensity", "NeuroML_v2.3.2.xsd", "CT"), + ("ChannelDensityVShift", "NeuroML_v2.3.2.xsd", "CT"), + ("ChannelDensityNernst", "NeuroML_v2.3.2.xsd", "CT"), + ("ChannelDensityNernstCa2", "NeuroML_v2.3.2.xsd", "CT"), + ("ChannelDensityGHK", "NeuroML_v2.3.2.xsd", "CT"), + ("ChannelDensityGHK2", "NeuroML_v2.3.2.xsd", "CT"), + ("VariableParameter", "NeuroML_v2.3.2.xsd", "CT"), + ("InhomogeneousValue", "NeuroML_v2.3.2.xsd", "CT"), + ("Species", "NeuroML_v2.3.2.xsd", "CT"), + ("ConcentrationModel_D", "NeuroML_v2.3.2.xsd", "CT"), + ("IntracellularProperties", "NeuroML_v2.3.2.xsd", "CT"), + ("IntracellularProperties2CaPools", "NeuroML_v2.3.2.xsd", "CT"), + ("ExtracellularProperties", "NeuroML_v2.3.2.xsd", "CT"), + ("ExtracellularPropertiesLocal", "NeuroML_v2.3.2.xsd", "CT"), + ("ReactionScheme", "NeuroML_v2.3.2.xsd", "CT"), + ("PulseGenerator", "NeuroML_v2.3.2.xsd", "CT"), + ("PulseGeneratorDL", "NeuroML_v2.3.2.xsd", "CT"), + ("SineGenerator", "NeuroML_v2.3.2.xsd", "CT"), + ("SineGeneratorDL", "NeuroML_v2.3.2.xsd", "CT"), + ("RampGenerator", "NeuroML_v2.3.2.xsd", "CT"), + ("RampGeneratorDL", "NeuroML_v2.3.2.xsd", "CT"), + ("CompoundInput", "NeuroML_v2.3.2.xsd", "CT"), + ("CompoundInputDL", "NeuroML_v2.3.2.xsd", "CT"), + ("VoltageClamp", "NeuroML_v2.3.2.xsd", "CT"), + ("VoltageClampTriple", "NeuroML_v2.3.2.xsd", "CT"), + ("Spike", "NeuroML_v2.3.2.xsd", "CT"), + ("SpikeArray", "NeuroML_v2.3.2.xsd", "CT"), + ("TimedSynapticInput", "NeuroML_v2.3.2.xsd", "CT"), + ("SpikeGenerator", "NeuroML_v2.3.2.xsd", "CT"), + ("SpikeGeneratorRandom", "NeuroML_v2.3.2.xsd", "CT"), + ("SpikeGeneratorPoisson", "NeuroML_v2.3.2.xsd", "CT"), + ("SpikeGeneratorRefPoisson", "NeuroML_v2.3.2.xsd", "CT"), + ("PoissonFiringSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("TransientPoissonFiringSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("Network", "NeuroML_v2.3.2.xsd", "CT"), + ("Space", "NeuroML_v2.3.2.xsd", "CT"), + ("SpaceStructure", "NeuroML_v2.3.2.xsd", "CT"), + ("Region", "NeuroML_v2.3.2.xsd", "CT"), + ("Population", "NeuroML_v2.3.2.xsd", "CT"), + ("Layout", "NeuroML_v2.3.2.xsd", "CT"), + ("UnstructuredLayout", "NeuroML_v2.3.2.xsd", "CT"), + ("RandomLayout", "NeuroML_v2.3.2.xsd", "CT"), + ("GridLayout", "NeuroML_v2.3.2.xsd", "CT"), + ("Instance", "NeuroML_v2.3.2.xsd", "CT"), + ("Location", "NeuroML_v2.3.2.xsd", "CT"), + ("CellSet", "NeuroML_v2.3.2.xsd", "CT"), + ("SynapticConnection", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseProjection", "NeuroML_v2.3.2.xsd", "CT"), + ("Projection", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseConnection", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseConnectionOldFormat", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseConnectionNewFormat", "NeuroML_v2.3.2.xsd", "CT"), + ("Connection", "NeuroML_v2.3.2.xsd", "CT"), + ("ConnectionWD", "NeuroML_v2.3.2.xsd", "CT"), + ("ElectricalProjection", "NeuroML_v2.3.2.xsd", "CT"), + ("ElectricalConnection", "NeuroML_v2.3.2.xsd", "CT"), + ("ElectricalConnectionInstance", "NeuroML_v2.3.2.xsd", "CT"), + ("ElectricalConnectionInstanceW", "NeuroML_v2.3.2.xsd", "CT"), + ("ContinuousProjection", "NeuroML_v2.3.2.xsd", "CT"), + ("ContinuousConnection", "NeuroML_v2.3.2.xsd", "CT"), + ("ContinuousConnectionInstance", "NeuroML_v2.3.2.xsd", "CT"), + ("ContinuousConnectionInstanceW", "NeuroML_v2.3.2.xsd", "CT"), + ("ExplicitInput", "NeuroML_v2.3.2.xsd", "CT"), + ("InputList", "NeuroML_v2.3.2.xsd", "CT"), + ("Input", "NeuroML_v2.3.2.xsd", "CT"), + ("InputW", "NeuroML_v2.3.2.xsd", "CT"), + ("basePyNNCell", "NeuroML_v2.3.2.xsd", "CT"), + ("basePyNNIaFCell", "NeuroML_v2.3.2.xsd", "CT"), + ("basePyNNIaFCondCell", "NeuroML_v2.3.2.xsd", "CT"), + ("IF_curr_alpha", "NeuroML_v2.3.2.xsd", "CT"), + ("IF_curr_exp", "NeuroML_v2.3.2.xsd", "CT"), + ("IF_cond_alpha", "NeuroML_v2.3.2.xsd", "CT"), + ("IF_cond_exp", "NeuroML_v2.3.2.xsd", "CT"), + ("EIF_cond_exp_isfa_ista", "NeuroML_v2.3.2.xsd", "CT"), + ("EIF_cond_alpha_isfa_ista", "NeuroML_v2.3.2.xsd", "CT"), + ("HH_cond_exp", "NeuroML_v2.3.2.xsd", "CT"), + ("BasePynnSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("ExpCondSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("AlphaCondSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("ExpCurrSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("AlphaCurrSynapse", "NeuroML_v2.3.2.xsd", "CT"), + ("SpikeSourcePoisson", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseWithoutId", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseNonNegativeIntegerId", "NeuroML_v2.3.2.xsd", "CT"), + ("Base", "NeuroML_v2.3.2.xsd", "CT"), + ("Standalone", "NeuroML_v2.3.2.xsd", "CT"), ] } @@ -68101,9 +68604,11 @@ def main(): "ChannelDensityVShift", "ChannelPopulation", "ClosedState", + "Component", "ComponentType", "CompoundInput", "CompoundInputDL", + "ConcentrationModel", "ConcentrationModel_D", "ConditionalDerivedVariable", "Connection", From afbcace247cec5a6be9b3e64bd20c155bd429765 Mon Sep 17 00:00:00 2001 From: "Ankur Sinha (Ankur Sinha Gmail)" Date: Wed, 2 Oct 2024 14:19:06 +0100 Subject: [PATCH 4/8] chore: regen --- neuroml/nml/NeuroML_v2.3.2.xsd | 26 +- neuroml/nml/nml.py | 3905 +++++++++++++++----------------- 2 files changed, 1891 insertions(+), 2040 deletions(-) diff --git a/neuroml/nml/NeuroML_v2.3.2.xsd b/neuroml/nml/NeuroML_v2.3.2.xsd index 996bf5c..284683a 100644 --- a/neuroml/nml/NeuroML_v2.3.2.xsd +++ b/neuroml/nml/NeuroML_v2.3.2.xsd @@ -262,17 +262,6 @@ - - - A new Component based on a new defined ComponentType. - - - - - - - - LEMS Exposure (ComponentType property) @@ -487,7 +476,6 @@ - @@ -2128,6 +2116,7 @@ + @@ -2311,6 +2300,19 @@ + + + Base type for a current of density **iDensity** distributed on an area of a **cell** , flowing through the specified **ionChannel.** Instances of this ( normally **channelDensity** ) are specified in the **membraneProperties** of the **cell** . + + + + + + + + + + Specifies a time varying ohmic conductance density, **gDensity,** which is distributed on an area of the **cell** ( specified in **membraneProperties** ) with fixed reversal potential **erev** producing a current density **iDensity** diff --git a/neuroml/nml/nml.py b/neuroml/nml/nml.py index 1fd72df..5fb418b 100644 --- a/neuroml/nml/nml.py +++ b/neuroml/nml/nml.py @@ -2,7 +2,7 @@ # -*- coding: utf-8 -*- # -# Generated Tue Oct 1 17:21:18 2024 by generateDS.py version 2.44.1. +# Generated Wed Oct 2 12:35:48 2024 by generateDS.py version 2.44.1. # Python 3.11.10 (main, Sep 9 2024, 00:00:00) [GCC 14.2.1 20240801 (Red Hat 14.2.1-1)] # # Command line options: @@ -1354,17 +1354,17 @@ class ComponentType(GeneratedsSuper): def __init__( self, - name: "a string (required)" = None, - extends: "a string (optional)" = None, - description: "a string (optional)" = None, - Property: "list of Property(s) (optional)" = None, - Parameter: "list of Parameter(s) (optional)" = None, - DerivedParameter: "list of DerivedParameter(s) (optional)" = None, - Constant: "list of Constant(s) (optional)" = None, - Exposure: "list of Exposure(s) (optional)" = None, - Requirement: "list of Requirement(s) (optional)" = None, - InstanceRequirement: "list of InstanceRequirement(s) (optional)" = None, - Dynamics: "list of Dynamics(s) (optional)" = None, + name=None, + extends=None, + description=None, + Property=None, + Parameter=None, + DerivedParameter=None, + Constant=None, + Exposure=None, + Requirement=None, + InstanceRequirement=None, + Dynamics=None, gds_collector_=None, **kwargs_, ): @@ -1810,13 +1810,7 @@ class InstanceRequirement(GeneratedsSuper): subclass = None superclass = None - def __init__( - self, - name: "a string (required)" = None, - type: "a string (required)" = None, - gds_collector_=None, - **kwargs_, - ): + def __init__(self, name=None, type=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -2098,14 +2092,14 @@ class Dynamics(GeneratedsSuper): def __init__( self, - StateVariable: "list of StateVariable(s) (optional)" = None, - DerivedVariable: "list of DerivedVariable(s) (optional)" = None, - ConditionalDerivedVariable: "list of ConditionalDerivedVariable(s) (optional)" = None, - TimeDerivative: "list of TimeDerivative(s) (optional)" = None, - OnStart: "a OnStart (optional)" = None, - OnEvent: "list of OnEvent(s) (optional)" = None, - OnCondition: "list of OnCondition(s) (optional)" = None, - Regime: "list of Regime(s) (optional)" = None, + StateVariable=None, + DerivedVariable=None, + ConditionalDerivedVariable=None, + TimeDerivative=None, + OnStart=None, + OnEvent=None, + OnCondition=None, + Regime=None, gds_collector_=None, **kwargs_, ): @@ -2483,13 +2477,7 @@ class Case(GeneratedsSuper): subclass = None superclass = None - def __init__( - self, - condition: "a string (optional)" = None, - value: "a string (required)" = None, - gds_collector_=None, - **kwargs_, - ): + def __init__(self, condition=None, value=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -2663,13 +2651,7 @@ class TimeDerivative(GeneratedsSuper): subclass = None superclass = None - def __init__( - self, - variable: "a string (required)" = None, - value: "a string (required)" = None, - gds_collector_=None, - **kwargs_, - ): + def __init__(self, variable=None, value=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -2857,12 +2839,7 @@ class OnStart(GeneratedsSuper): subclass = None superclass = None - def __init__( - self, - StateAssignment: "list of StateAssignment(s) (required)" = None, - gds_collector_=None, - **kwargs_, - ): + def __init__(self, StateAssignment=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -3027,13 +3004,7 @@ class StateAssignment(GeneratedsSuper): subclass = None superclass = None - def __init__( - self, - variable: "a string (required)" = None, - value: "a string (required)" = None, - gds_collector_=None, - **kwargs_, - ): + def __init__(self, variable=None, value=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -3237,9 +3208,9 @@ class OnEvent(GeneratedsSuper): def __init__( self, - port: "a string (required)" = None, - StateAssignment: "list of StateAssignment(s) (optional)" = None, - EventOut: "list of EventOut(s) (optional)" = None, + port=None, + StateAssignment=None, + EventOut=None, gds_collector_=None, **kwargs_, ): @@ -3451,9 +3422,7 @@ class EventOut(GeneratedsSuper): subclass = None superclass = None - def __init__( - self, port: "a string (required)" = None, gds_collector_=None, **kwargs_ - ): + def __init__(self, port=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -3643,10 +3612,10 @@ class OnCondition(GeneratedsSuper): def __init__( self, - test: "a string (required)" = None, - StateAssignment: "list of StateAssignment(s) (optional)" = None, - EventOut: "list of EventOut(s) (optional)" = None, - Transition: "a Transition (optional)" = None, + test=None, + StateAssignment=None, + EventOut=None, + Transition=None, gds_collector_=None, **kwargs_, ): @@ -3889,9 +3858,7 @@ class Transition(GeneratedsSuper): subclass = None superclass = None - def __init__( - self, regime: "a string (required)" = None, gds_collector_=None, **kwargs_ - ): + def __init__(self, regime=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -4079,11 +4046,11 @@ class Regime(GeneratedsSuper): def __init__( self, - name: "a string (required)" = None, - initial: "a TrueOrFalse (optional)" = None, - TimeDerivative: "list of TimeDerivative(s) (optional)" = None, - OnEntry: "a OnEntry (optional)" = None, - OnCondition: "list of OnCondition(s) (optional)" = None, + name=None, + initial=None, + TimeDerivative=None, + OnEntry=None, + OnCondition=None, gds_collector_=None, **kwargs_, ): @@ -4381,12 +4348,7 @@ class OnEntry(GeneratedsSuper): subclass = None superclass = None - def __init__( - self, - StateAssignment: "list of StateAssignment(s) (required)" = None, - gds_collector_=None, - **kwargs_, - ): + def __init__(self, StateAssignment=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -4548,9 +4510,7 @@ class IncludeType(GeneratedsSuper): subclass = None superclass = None - def __init__( - self, href: "a anyURI (required)" = None, gds_collector_=None, **kwargs_ - ): + def __init__(self, href=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -4727,10 +4687,10 @@ class Q10Settings(GeneratedsSuper): def __init__( self, - type: "a NmlId (required)" = None, - fixed_q10: "a Nml2Quantity_none (optional)" = None, - q10_factor: "a Nml2Quantity_none (optional)" = None, - experimental_temp: "a Nml2Quantity_temperature (optional)" = None, + type=None, + fixed_q10=None, + q10_factor=None, + experimental_temp=None, gds_collector_=None, **kwargs_, ): @@ -5090,9 +5050,9 @@ class VariableParameter(GeneratedsSuper): def __init__( self, - parameter: "a string (required)" = None, - segment_groups: "a string (required)" = None, - inhomogeneous_value: "a InhomogeneousValue (optional)" = None, + parameter=None, + segment_groups=None, + inhomogeneous_value=None, gds_collector_=None, **kwargs_, ): @@ -5466,13 +5426,7 @@ class BaseNonNegativeIntegerId(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__( - self, - id: "a NmlId (required)" = None, - extensiontype_=None, - gds_collector_=None, - **kwargs_, - ): + def __init__(self, id=None, extensiontype_=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -5693,13 +5647,7 @@ class Base(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__( - self, - id: "a NmlId (required)" = None, - extensiontype_=None, - gds_collector_=None, - **kwargs_, - ): + def __init__(self, id=None, extensiontype_=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -5942,11 +5890,11 @@ class Standalone(Base): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -6303,14 +6251,14 @@ class SpikeSourcePoisson(Standalone): def __init__( self, - id: "a NonNegativeInteger (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - start: "a Nml2Quantity_time (required)" = None, - duration: "a Nml2Quantity_time (required)" = None, - rate: "a Nml2Quantity_pertime (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + start=None, + duration=None, + rate=None, gds_collector_=None, **kwargs_, ): @@ -6640,11 +6588,11 @@ class Input(BaseNonNegativeIntegerId): def __init__( self, - id: "a NonNegativeInteger (required)" = None, - target: "a Nml2PopulationReferencePath (required)" = None, - destination: "a NmlId (required)" = None, - segment_id: "a NonNegativeInteger (optional)" = None, - fraction_along: "a ZeroToOne (optional)" = None, + id=None, + target=None, + destination=None, + segment_id=None, + fraction_along=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -7089,11 +7037,11 @@ class InputList(Base): def __init__( self, - id: "a NonNegativeInteger (required)" = None, - populations: "a NmlId (required)" = None, - component: "a NmlId (required)" = None, - input: "list of Input(s) (optional)" = None, - input_ws: "list of InputW(s) (optional)" = None, + id=None, + populations=None, + component=None, + input=None, + input_ws=None, gds_collector_=None, **kwargs_, ): @@ -7454,12 +7402,7 @@ class ExplicitInput(BaseWithoutId): superclass = BaseWithoutId def __init__( - self, - target: "a Nml2PopulationReferencePath (required)" = None, - input: "a NmlId (required)" = None, - destination: "a NmlId (optional)" = None, - gds_collector_=None, - **kwargs_, + self, target=None, input=None, destination=None, gds_collector_=None, **kwargs_ ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -7821,8 +7764,8 @@ class BaseConnection(BaseNonNegativeIntegerId): def __init__( self, - id: "a NmlId (required)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, + id=None, + neuro_lex_id=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -8064,9 +8007,9 @@ class BaseProjection(Base): def __init__( self, - id: "a NmlId (required)" = None, - presynaptic_population: "a NmlId (required)" = None, - postsynaptic_population: "a NmlId (required)" = None, + id=None, + presynaptic_population=None, + postsynaptic_population=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -8350,11 +8293,11 @@ class SynapticConnection(BaseWithoutId): def __init__( self, - neuro_lex_id: "a NeuroLexId (optional)" = None, - from_: "a Nml2PopulationReferencePath (required)" = None, - to: "a Nml2PopulationReferencePath (required)" = None, - synapse: "a NmlId (required)" = None, - destination: "a NmlId (optional)" = None, + neuro_lex_id=None, + from_=None, + to=None, + synapse=None, + destination=None, gds_collector_=None, **kwargs_, ): @@ -8764,12 +8707,7 @@ class CellSet(Base): superclass = Base def __init__( - self, - id: "a NmlId (required)" = None, - select: "a string (required)" = None, - anytypeobjs_=None, - gds_collector_=None, - **kwargs_, + self, id=None, select=None, anytypeobjs_=None, gds_collector_=None, **kwargs_ ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -8961,14 +8899,7 @@ class Location(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__( - self, - x: "a float (required)" = None, - y: "a float (required)" = None, - z: "a float (required)" = None, - gds_collector_=None, - **kwargs_, - ): + def __init__(self, x=None, y=None, z=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -9186,11 +9117,11 @@ class Instance(BaseWithoutId): def __init__( self, - id: "a nonNegativeInteger (optional)" = None, - i: "a nonNegativeInteger (optional)" = None, - j: "a nonNegativeInteger (optional)" = None, - k: "a nonNegativeInteger (optional)" = None, - location: "a Location (required)" = None, + id=None, + i=None, + j=None, + k=None, + location=None, gds_collector_=None, **kwargs_, ): @@ -9450,12 +9381,7 @@ class GridLayout(BaseWithoutId): superclass = BaseWithoutId def __init__( - self, - x_size: "a nonNegativeInteger (optional)" = None, - y_size: "a nonNegativeInteger (optional)" = None, - z_size: "a nonNegativeInteger (optional)" = None, - gds_collector_=None, - **kwargs_, + self, x_size=None, y_size=None, z_size=None, gds_collector_=None, **kwargs_ ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -9652,13 +9578,7 @@ class RandomLayout(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__( - self, - number: "a nonNegativeInteger (optional)" = None, - regions: "a NmlId (optional)" = None, - gds_collector_=None, - **kwargs_, - ): + def __init__(self, number=None, regions=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -9880,12 +9800,7 @@ class UnstructuredLayout(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__( - self, - number: "a nonNegativeInteger (optional)" = None, - gds_collector_=None, - **kwargs_, - ): + def __init__(self, number=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -10081,10 +9996,10 @@ class Layout(BaseWithoutId): def __init__( self, - spaces: "a NmlId (optional)" = None, - random: "a RandomLayout (required)" = None, - grid: "a GridLayout (required)" = None, - unstructured: "a UnstructuredLayout (required)" = None, + spaces=None, + random=None, + grid=None, + unstructured=None, gds_collector_=None, **kwargs_, ): @@ -10411,18 +10326,18 @@ class Population(Standalone): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - component: "a NmlId (required)" = None, - size: "a NonNegativeInteger (optional)" = None, - type: "a populationTypes (optional)" = None, - extracellular_properties: "a NmlId (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - layout: "a Layout (optional)" = None, - instances: "list of Instance(s) (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + component=None, + size=None, + type=None, + extracellular_properties=None, + neuro_lex_id=None, + layout=None, + instances=None, gds_collector_=None, **kwargs_, ): @@ -10921,12 +10836,7 @@ class Region(Base): superclass = Base def __init__( - self, - id: "a NmlId (required)" = None, - spaces: "a NmlId (optional)" = None, - anytypeobjs_=None, - gds_collector_=None, - **kwargs_, + self, id=None, spaces=None, anytypeobjs_=None, gds_collector_=None, **kwargs_ ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -11155,12 +11065,12 @@ class SpaceStructure(BaseWithoutId): def __init__( self, - x_spacing: "a float (optional)" = None, - y_spacing: "a float (optional)" = None, - z_spacing: "a float (optional)" = None, - x_start: "a float (optional)" = 0, - y_start: "a float (optional)" = 0, - z_start: "a float (optional)" = 0, + x_spacing=None, + y_spacing=None, + z_spacing=None, + x_start=0, + y_start=0, + z_start=0, gds_collector_=None, **kwargs_, ): @@ -11419,12 +11329,7 @@ class Space(Base): superclass = Base def __init__( - self, - id: "a NmlId (required)" = None, - based_on: "a allowedSpaces (optional)" = None, - structure: "a SpaceStructure (optional)" = None, - gds_collector_=None, - **kwargs_, + self, id=None, based_on=None, structure=None, gds_collector_=None, **kwargs_ ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -11810,25 +11715,25 @@ class Network(Standalone): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - type: "a networkTypes (optional)" = None, - temperature: "a Nml2Quantity_temperature (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - spaces: "list of Space(s) (optional)" = None, - regions: "list of Region(s) (optional)" = None, - extracellular_properties: "list of ExtracellularPropertiesLocal(s) (optional)" = None, - populations: "list of Population(s) (required)" = None, - cell_sets: "list of CellSet(s) (optional)" = None, - synaptic_connections: "list of SynapticConnection(s) (optional)" = None, - projections: "list of Projection(s) (optional)" = None, - electrical_projections: "list of ElectricalProjection(s) (optional)" = None, - continuous_projections: "list of ContinuousProjection(s) (optional)" = None, - explicit_inputs: "list of ExplicitInput(s) (optional)" = None, - input_lists: "list of InputList(s) (optional)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + type=None, + temperature=None, + neuro_lex_id=None, + spaces=None, + regions=None, + extracellular_properties=None, + populations=None, + cell_sets=None, + synaptic_connections=None, + projections=None, + electrical_projections=None, + continuous_projections=None, + explicit_inputs=None, + input_lists=None, gds_collector_=None, **kwargs_, ): @@ -12565,16 +12470,16 @@ class TransientPoissonFiringSynapse(Standalone): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - average_rate: "a Nml2Quantity_pertime (required)" = None, - delay: "a Nml2Quantity_time (required)" = None, - duration: "a Nml2Quantity_time (required)" = None, - synapse: "a string (required)" = None, - spike_target: "a string (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + average_rate=None, + delay=None, + duration=None, + synapse=None, + spike_target=None, gds_collector_=None, **kwargs_, ): @@ -12951,14 +12856,14 @@ class PoissonFiringSynapse(Standalone): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - average_rate: "a Nml2Quantity_pertime (required)" = None, - synapse: "a string (required)" = None, - spike_target: "a string (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + average_rate=None, + synapse=None, + spike_target=None, gds_collector_=None, **kwargs_, ): @@ -13238,12 +13143,12 @@ class SpikeGeneratorPoisson(Standalone): def __init__( self, - id: "a NonNegativeInteger (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - average_rate: "a Nml2Quantity_pertime (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + average_rate=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -13500,13 +13405,13 @@ class SpikeGeneratorRandom(Standalone): def __init__( self, - id: "a NonNegativeInteger (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - max_isi: "a Nml2Quantity_time (required)" = None, - min_isi: "a Nml2Quantity_time (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + max_isi=None, + min_isi=None, gds_collector_=None, **kwargs_, ): @@ -13765,12 +13670,12 @@ class SpikeGenerator(Standalone): def __init__( self, - id: "a NonNegativeInteger (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - period: "a Nml2Quantity_time (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + period=None, gds_collector_=None, **kwargs_, ): @@ -14005,14 +13910,14 @@ class TimedSynapticInput(Standalone): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - synapse: "a NmlId (required)" = None, - spike_target: "a string (required)" = None, - spikes: "list of Spike(s) (optional)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + synapse=None, + spike_target=None, + spikes=None, gds_collector_=None, **kwargs_, ): @@ -14296,12 +14201,12 @@ class SpikeArray(Standalone): def __init__( self, - id: "a NonNegativeInteger (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - spikes: "list of Spike(s) (optional)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + spikes=None, gds_collector_=None, **kwargs_, ): @@ -14490,13 +14395,7 @@ class Spike(BaseNonNegativeIntegerId): subclass = None superclass = BaseNonNegativeIntegerId - def __init__( - self, - id: "a NonNegativeInteger (required)" = None, - time: "a Nml2Quantity_time (required)" = None, - gds_collector_=None, - **kwargs_, - ): + def __init__(self, id=None, time=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -14756,18 +14655,18 @@ class VoltageClampTriple(Standalone): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - active: "a ZeroOrOne (required)" = None, - delay: "a Nml2Quantity_time (required)" = None, - duration: "a Nml2Quantity_time (required)" = None, - conditioning_voltage: "a Nml2Quantity_voltage (required)" = None, - testing_voltage: "a Nml2Quantity_voltage (required)" = None, - return_voltage: "a Nml2Quantity_voltage (required)" = None, - simple_series_resistance: "a Nml2Quantity_resistance (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + active=None, + delay=None, + duration=None, + conditioning_voltage=None, + testing_voltage=None, + return_voltage=None, + simple_series_resistance=None, gds_collector_=None, **kwargs_, ): @@ -15286,15 +15185,15 @@ class VoltageClamp(Standalone): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - delay: "a Nml2Quantity_time (required)" = None, - duration: "a Nml2Quantity_time (required)" = None, - target_voltage: "a Nml2Quantity_voltage (required)" = None, - simple_series_resistance: "a Nml2Quantity_resistance (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + delay=None, + duration=None, + target_voltage=None, + simple_series_resistance=None, gds_collector_=None, **kwargs_, ): @@ -15700,14 +15599,14 @@ class CompoundInputDL(Standalone): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - pulse_generator_dls: "list of PulseGeneratorDL(s) (optional)" = None, - sine_generator_dls: "list of SineGeneratorDL(s) (optional)" = None, - ramp_generator_dls: "list of RampGeneratorDL(s) (optional)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + pulse_generator_dls=None, + sine_generator_dls=None, + ramp_generator_dls=None, gds_collector_=None, **kwargs_, ): @@ -16006,14 +15905,14 @@ class CompoundInput(Standalone): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - pulse_generators: "list of PulseGenerator(s) (optional)" = None, - sine_generators: "list of SineGenerator(s) (optional)" = None, - ramp_generators: "list of RampGenerator(s) (optional)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + pulse_generators=None, + sine_generators=None, + ramp_generators=None, gds_collector_=None, **kwargs_, ): @@ -16308,16 +16207,16 @@ class RampGeneratorDL(Standalone): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - delay: "a Nml2Quantity_time (required)" = None, - duration: "a Nml2Quantity_time (required)" = None, - start_amplitude: "a Nml2Quantity_current (required)" = None, - finish_amplitude: "a Nml2Quantity_current (required)" = None, - baseline_amplitude: "a Nml2Quantity_current (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + delay=None, + duration=None, + start_amplitude=None, + finish_amplitude=None, + baseline_amplitude=None, gds_collector_=None, **kwargs_, ): @@ -16727,16 +16626,16 @@ class RampGenerator(Standalone): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - delay: "a Nml2Quantity_time (required)" = None, - duration: "a Nml2Quantity_time (required)" = None, - start_amplitude: "a Nml2Quantity_current (required)" = None, - finish_amplitude: "a Nml2Quantity_current (required)" = None, - baseline_amplitude: "a Nml2Quantity_current (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + delay=None, + duration=None, + start_amplitude=None, + finish_amplitude=None, + baseline_amplitude=None, gds_collector_=None, **kwargs_, ): @@ -17140,16 +17039,16 @@ class SineGeneratorDL(Standalone): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - delay: "a Nml2Quantity_time (required)" = None, - phase: "a Nml2Quantity_none (required)" = None, - duration: "a Nml2Quantity_time (required)" = None, - amplitude: "a Nml2Quantity_current (required)" = None, - period: "a Nml2Quantity_time (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + delay=None, + phase=None, + duration=None, + amplitude=None, + period=None, gds_collector_=None, **kwargs_, ): @@ -17531,16 +17430,16 @@ class SineGenerator(Standalone): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - delay: "a Nml2Quantity_time (required)" = None, - phase: "a Nml2Quantity_none (required)" = None, - duration: "a Nml2Quantity_time (required)" = None, - amplitude: "a Nml2Quantity_current (required)" = None, - period: "a Nml2Quantity_time (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + delay=None, + phase=None, + duration=None, + amplitude=None, + period=None, gds_collector_=None, **kwargs_, ): @@ -17944,14 +17843,14 @@ class PulseGeneratorDL(Standalone): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - delay: "a Nml2Quantity_time (required)" = None, - duration: "a Nml2Quantity_time (required)" = None, - amplitude: "a Nml2Quantity_current (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + delay=None, + duration=None, + amplitude=None, gds_collector_=None, **kwargs_, ): @@ -18281,14 +18180,14 @@ class PulseGenerator(Standalone): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - delay: "a Nml2Quantity_time (required)" = None, - duration: "a Nml2Quantity_time (required)" = None, - amplitude: "a Nml2Quantity_current (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + delay=None, + duration=None, + amplitude=None, gds_collector_=None, **kwargs_, ): @@ -18592,9 +18491,9 @@ class ReactionScheme(Base): def __init__( self, - id: "a NmlId (required)" = None, - source: "a string (required)" = None, - type: "a string (required)" = None, + id=None, + source=None, + type=None, anytypeobjs_=None, gds_collector_=None, **kwargs_, @@ -18813,13 +18712,7 @@ class ExtracellularPropertiesLocal(Base): subclass = None superclass = Base - def __init__( - self, - id: "a NmlId (required)" = None, - species: "list of Species(s) (optional)" = None, - gds_collector_=None, - **kwargs_, - ): + def __init__(self, id=None, species=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -19030,13 +18923,7 @@ class ExtracellularProperties(Base): subclass = None superclass = Base - def __init__( - self, - id: "a NmlId (required)" = None, - species: "list of Species(s) (optional)" = None, - gds_collector_=None, - **kwargs_, - ): + def __init__(self, id=None, species=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -19259,8 +19146,8 @@ class IntracellularProperties(BaseWithoutId): def __init__( self, - species: "list of Species(s) (optional)" = None, - resistivities: "list of Resistivity(s) (optional)" = None, + species=None, + resistivities=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -19549,12 +19436,12 @@ class Species(Base): def __init__( self, - id: "a NmlId (required)" = None, - concentration_model: "a NmlId (required)" = None, - ion: "a NmlId (optional)" = None, - initial_concentration: "a Nml2Quantity_concentration (required)" = None, - initial_ext_concentration: "a Nml2Quantity_concentration (required)" = None, - segment_groups: "a NmlId (optional)" = "all", + id=None, + concentration_model=None, + ion=None, + initial_concentration=None, + initial_ext_concentration=None, + segment_groups="all", gds_collector_=None, **kwargs_, ): @@ -19912,11 +19799,7 @@ class InhomogeneousValue(BaseWithoutId): superclass = BaseWithoutId def __init__( - self, - inhomogeneous_parameters: "a string (required)" = None, - value: "a string (required)" = None, - gds_collector_=None, - **kwargs_, + self, inhomogeneous_parameters=None, value=None, gds_collector_=None, **kwargs_ ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -20153,12 +20036,12 @@ class ChannelDensityGHK2(Base): def __init__( self, - id: "a NmlId (required)" = None, - ion_channel: "a NmlId (required)" = None, - cond_density: "a Nml2Quantity_conductanceDensity (optional)" = None, - segment_groups: "a NmlId (optional)" = "all", - segments: "a NonNegativeInteger (optional)" = None, - ion: "a NmlId (required)" = None, + id=None, + ion_channel=None, + cond_density=None, + segment_groups="all", + segments=None, + ion=None, gds_collector_=None, **kwargs_, ): @@ -20526,12 +20409,12 @@ class ChannelDensityGHK(Base): def __init__( self, - id: "a NmlId (required)" = None, - ion_channel: "a NmlId (required)" = None, - permeability: "a Nml2Quantity_permeability (required)" = None, - segment_groups: "a NmlId (optional)" = "all", - segments: "a NonNegativeInteger (optional)" = None, - ion: "a NmlId (required)" = None, + id=None, + ion_channel=None, + permeability=None, + segment_groups="all", + segments=None, + ion=None, gds_collector_=None, **kwargs_, ): @@ -20908,13 +20791,13 @@ class ChannelDensityNernst(Base): def __init__( self, - id: "a NmlId (required)" = None, - ion_channel: "a NmlId (required)" = None, - cond_density: "a Nml2Quantity_conductanceDensity (optional)" = None, - segment_groups: "a NmlId (optional)" = "all", - segments: "a NonNegativeInteger (optional)" = None, - ion: "a NmlId (required)" = None, - variable_parameters: "list of VariableParameter(s) (optional)" = None, + id=None, + ion_channel=None, + cond_density=None, + segment_groups="all", + segments=None, + ion=None, + variable_parameters=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -21362,14 +21245,14 @@ class ChannelDensity(Base): def __init__( self, - id: "a NmlId (required)" = None, - ion_channel: "a NmlId (required)" = None, - cond_density: "a Nml2Quantity_conductanceDensity (optional)" = None, - erev: "a Nml2Quantity_voltage (required)" = None, - segment_groups: "a NmlId (optional)" = "all", - segments: "a NonNegativeInteger (optional)" = None, - ion: "a NmlId (required)" = None, - variable_parameters: "list of VariableParameter(s) (optional)" = None, + id=None, + ion_channel=None, + cond_density=None, + erev=None, + segment_groups="all", + segments=None, + ion=None, + variable_parameters=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -21822,70 +21705,45 @@ def _buildChildren( # end class ChannelDensity -class ChannelDensityNonUniformGHK(Base): - """ChannelDensityNonUniformGHK -- Specifies a time varying conductance density, which is distributed on a region of the **cell,** and whose current is calculated from the Goldman-Hodgkin-Katz equation. Hard coded for Ca only!. The conductance density of the channel is not uniform, but is set using the **variableParameter** . Note, there is no dynamical description of this in LEMS yet, as this type only makes sense for multicompartmental cells. A ComponentType for this needs to be present to enable export of NeuroML 2 multicompartmental cells via LEMS/jNeuroML to NEURON""" +class BaseChannelDensity(Base): + """BaseChannelDensity -- Base type for a current of density **iDensity** distributed on an area of a **cell** , flowing through the specified **ionChannel.** Instances of this ( normally **channelDensity** ) are specified in the **membraneProperties** of the **cell** .""" __hash__ = GeneratedsSuper.__hash__ member_data_items_ = [ MemberSpec_( "ion_channel", "NmlId", 0, 0, {"use": "required", "name": "ion_channel"} ), - MemberSpec_("ion", "NmlId", 0, 0, {"use": "required", "name": "ion"}), - MemberSpec_( - "variable_parameters", - "VariableParameter", - 1, - 1, - { - "maxOccurs": "unbounded", - "minOccurs": "0", - "name": "variableParameter", - "type": "VariableParameter", - }, - None, - ), + MemberSpec_("type", "NmlId", 0, 0, {"use": "required", "name": "type"}), ] subclass = None superclass = Base def __init__( - self, - id: "a NmlId (required)" = None, - ion_channel: "a NmlId (required)" = None, - ion: "a NmlId (required)" = None, - variable_parameters: "list of VariableParameter(s) (optional)" = None, - gds_collector_=None, - **kwargs_, + self, id=None, ion_channel=None, type=None, gds_collector_=None, **kwargs_ ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None self.parent_object_ = kwargs_.get("parent_object_") self.ns_prefix_ = None - super(globals().get("ChannelDensityNonUniformGHK"), self).__init__( - id, **kwargs_ - ) + super(globals().get("BaseChannelDensity"), self).__init__(id, **kwargs_) self.ion_channel = _cast(None, ion_channel) self.ion_channel_nsprefix_ = None - self.ion = _cast(None, ion) - self.ion_nsprefix_ = None - if variable_parameters is None: - self.variable_parameters = [] - else: - self.variable_parameters = variable_parameters - self.variable_parameters_nsprefix_ = None + self.type = _cast(None, type) + self.type_nsprefix_ = None + self.anyAttributes_ = {} def factory(*args_, **kwargs_): if CurrentSubclassModule_ is not None: subclass = getSubclassFromModule_( - CurrentSubclassModule_, ChannelDensityNonUniformGHK + CurrentSubclassModule_, BaseChannelDensity ) if subclass is not None: return subclass(*args_, **kwargs_) - if ChannelDensityNonUniformGHK.subclass: - return ChannelDensityNonUniformGHK.subclass(*args_, **kwargs_) + if BaseChannelDensity.subclass: + return BaseChannelDensity.subclass(*args_, **kwargs_) else: - return ChannelDensityNonUniformGHK(*args_, **kwargs_) + return BaseChannelDensity(*args_, **kwargs_) factory = staticmethod(factory) @@ -21920,10 +21778,7 @@ def validate_NmlId(self, value): validate_NmlId_patterns_ = [["^([a-zA-Z_][a-zA-Z0-9_]*)$"]] def has__content(self): - if ( - self.variable_parameters - or super(ChannelDensityNonUniformGHK, self).has__content() - ): + if super(BaseChannelDensity, self).has__content(): return True else: return False @@ -21933,21 +21788,18 @@ def export( outfile, level, namespaceprefix_="", - namespacedef_=' xmlns:None="http://www.neuroml.org/schema/neuroml2" ', - name_="ChannelDensityNonUniformGHK", + namespacedef_="", + name_="BaseChannelDensity", pretty_print=True, ): - imported_ns_def_ = GenerateDSNamespaceDefs_.get("ChannelDensityNonUniformGHK") + imported_ns_def_ = GenerateDSNamespaceDefs_.get("BaseChannelDensity") if imported_ns_def_ is not None: namespacedef_ = imported_ns_def_ if pretty_print: eol_ = "\n" else: eol_ = "" - if ( - self.original_tagname_ is not None - and name_ == "ChannelDensityNonUniformGHK" - ): + if self.original_tagname_ is not None and name_ == "BaseChannelDensity": name_ = self.original_tagname_ if UseCapturedNS_ and self.ns_prefix_: namespaceprefix_ = self.ns_prefix_ + ":" @@ -21966,7 +21818,7 @@ def export( level, already_processed, namespaceprefix_, - name_="ChannelDensityNonUniformGHK", + name_="BaseChannelDensity", ) if self.has__content(): outfile.write(">%s" % (eol_,)) @@ -21975,10 +21827,9 @@ def export( level + 1, namespaceprefix_, namespacedef_, - name_="ChannelDensityNonUniformGHK", + name_="BaseChannelDensity", pretty_print=pretty_print, ) - showIndent(outfile, level, pretty_print) outfile.write("%s" % (namespaceprefix_, name_, eol_)) else: outfile.write("/>%s" % (eol_,)) @@ -21989,14 +21840,75 @@ def _exportAttributes( level, already_processed, namespaceprefix_="", - name_="ChannelDensityNonUniformGHK", + name_="BaseChannelDensity", ): - super(ChannelDensityNonUniformGHK, self)._exportAttributes( + unique_counter = 0 + for name, value in self.anyAttributes_.items(): + xsinamespaceprefix = "xsi" + xsinamespace1 = "http://www.w3.org/2001/XMLSchema-instance" + xsinamespace2 = "{%s}" % (xsinamespace1,) + if name.startswith(xsinamespace2): + name1 = name[len(xsinamespace2) :] + name2 = "%s:%s" % ( + xsinamespaceprefix, + name1, + ) + if name2 not in already_processed: + already_processed.add(name2) + outfile.write( + " %s=%s" + % ( + name2, + quote_attrib(value), + ) + ) + else: + mo = re_.match(Namespace_extract_pat_, name) + if mo is not None: + namespace, name = mo.group(1, 2) + if name not in already_processed: + already_processed.add(name) + if namespace == "http://www.w3.org/XML/1998/namespace": + outfile.write( + " %s=%s" + % ( + name, + quote_attrib(value), + ) + ) + else: + unique_counter += 1 + outfile.write( + ' xmlns:%d="%s"' + % ( + unique_counter, + namespace, + ) + ) + outfile.write( + " %d:%s=%s" + % ( + unique_counter, + name, + quote_attrib(value), + ) + ) + else: + if name not in already_processed: + already_processed.add(name) + outfile.write( + " %s=%s" + % ( + name, + quote_attrib(value), + ) + ) + super(BaseChannelDensity, self)._exportAttributes( outfile, level, already_processed, namespaceprefix_, - name_="ChannelDensityNonUniformGHK", + name_="BaseChannelDensity", ) if self.ion_channel is not None and "ion_channel" not in already_processed: already_processed.add("ion_channel") @@ -22010,13 +21922,15 @@ def _exportAttributes( ), ) ) - if self.ion is not None and "ion" not in already_processed: - already_processed.add("ion") + if self.type is not None and "type" not in already_processed: + already_processed.add("type") outfile.write( - " ion=%s" + " type=%s" % ( self.gds_encode( - self.gds_format_string(quote_attrib(self.ion), input_name="ion") + self.gds_format_string( + quote_attrib(self.type), input_name="type" + ) ), ) ) @@ -22026,12 +21940,12 @@ def _exportChildren( outfile, level, namespaceprefix_="", - namespacedef_=' xmlns:None="http://www.neuroml.org/schema/neuroml2" ', - name_="ChannelDensityNonUniformGHK", + namespacedef_="", + name_="BaseChannelDensity", fromsubclass_=False, pretty_print=True, ): - super(ChannelDensityNonUniformGHK, self)._exportChildren( + super(BaseChannelDensity, self)._exportChildren( outfile, level, namespaceprefix_, @@ -22040,24 +21954,7 @@ def _exportChildren( True, pretty_print=pretty_print, ) - if pretty_print: - eol_ = "\n" - else: - eol_ = "" - for variableParameter_ in self.variable_parameters: - namespaceprefix_ = ( - self.variable_parameters_nsprefix_ + ":" - if (UseCapturedNS_ and self.variable_parameters_nsprefix_) - else "" - ) - variableParameter_.export( - outfile, - level, - namespaceprefix_, - namespacedef_="", - name_="variableParameter", - pretty_print=pretty_print, - ) + pass def validate_(self, gds_collector, recursive=False): self.gds_collector_ = gds_collector @@ -22067,19 +21964,311 @@ def validate_(self, gds_collector, recursive=False): self.validate_NmlId, self.ion_channel, "ion_channel" ) self.gds_check_cardinality_(self.ion_channel, "ion_channel", required=True) - self.gds_validate_defined_ST_(self.validate_NmlId, self.ion, "ion") - self.gds_check_cardinality_(self.ion, "ion", required=True) + self.gds_validate_defined_ST_(self.validate_NmlId, self.type, "type") + self.gds_check_cardinality_(self.type, "type", required=True) # validate simple type children # validate complex type children - self.gds_check_cardinality_( - self.variable_parameters, - "variable_parameters", - min_occurs=0, - max_occurs=9999999, - ) if recursive: - for item in self.variable_parameters: - item.validate_(gds_collector, recursive=True) + pass + return message_count == len(self.gds_collector_.get_messages()) + + def build(self, node, gds_collector_=None): + self.gds_collector_ = gds_collector_ + if SaveElementTreeNode: + self.gds_elementtree_node_ = node + already_processed = set() + self.ns_prefix_ = node.prefix + self._buildAttributes(node, node.attrib, already_processed) + for child in node: + nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] + self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) + return self + + def _buildAttributes(self, node, attrs, already_processed): + value = find_attr_value_("ionChannel", node) + if value is not None and "ionChannel" not in already_processed: + already_processed.add("ionChannel") + self.ion_channel = value + self.validate_NmlId(self.ion_channel) # validate type NmlId + value = find_attr_value_("type", node) + if value is not None and "type" not in already_processed: + already_processed.add("type") + self.type = value + self.validate_NmlId(self.type) # validate type NmlId + self.anyAttributes_ = {} + for name, value in attrs.items(): + if name not in already_processed: + self.anyAttributes_[name] = value + super(BaseChannelDensity, self)._buildAttributes(node, attrs, already_processed) + + def _buildChildren( + self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None + ): + super(BaseChannelDensity, self)._buildChildren(child_, node, nodeName_, True) + pass + + +# end class BaseChannelDensity + + +class ChannelDensityNonUniformGHK(Base): + """ChannelDensityNonUniformGHK -- Specifies a time varying conductance density, which is distributed on a region of the **cell,** and whose current is calculated from the Goldman-Hodgkin-Katz equation. Hard coded for Ca only!. The conductance density of the channel is not uniform, but is set using the **variableParameter** . Note, there is no dynamical description of this in LEMS yet, as this type only makes sense for multicompartmental cells. A ComponentType for this needs to be present to enable export of NeuroML 2 multicompartmental cells via LEMS/jNeuroML to NEURON""" + + __hash__ = GeneratedsSuper.__hash__ + member_data_items_ = [ + MemberSpec_( + "ion_channel", "NmlId", 0, 0, {"use": "required", "name": "ion_channel"} + ), + MemberSpec_("ion", "NmlId", 0, 0, {"use": "required", "name": "ion"}), + MemberSpec_( + "variable_parameters", + "VariableParameter", + 1, + 1, + { + "maxOccurs": "unbounded", + "minOccurs": "0", + "name": "variableParameter", + "type": "VariableParameter", + }, + None, + ), + ] + subclass = None + superclass = Base + + def __init__( + self, + id=None, + ion_channel=None, + ion=None, + variable_parameters=None, + gds_collector_=None, + **kwargs_, + ): + self.gds_collector_ = gds_collector_ + self.gds_elementtree_node_ = None + self.original_tagname_ = None + self.parent_object_ = kwargs_.get("parent_object_") + self.ns_prefix_ = None + super(globals().get("ChannelDensityNonUniformGHK"), self).__init__( + id, **kwargs_ + ) + self.ion_channel = _cast(None, ion_channel) + self.ion_channel_nsprefix_ = None + self.ion = _cast(None, ion) + self.ion_nsprefix_ = None + if variable_parameters is None: + self.variable_parameters = [] + else: + self.variable_parameters = variable_parameters + self.variable_parameters_nsprefix_ = None + + def factory(*args_, **kwargs_): + if CurrentSubclassModule_ is not None: + subclass = getSubclassFromModule_( + CurrentSubclassModule_, ChannelDensityNonUniformGHK + ) + if subclass is not None: + return subclass(*args_, **kwargs_) + if ChannelDensityNonUniformGHK.subclass: + return ChannelDensityNonUniformGHK.subclass(*args_, **kwargs_) + else: + return ChannelDensityNonUniformGHK(*args_, **kwargs_) + + factory = staticmethod(factory) + + def validate_NmlId(self, value): + # Validate type NmlId, a restriction on xs:string. + if ( + value is not None + and Validate_simpletypes_ + and self.gds_collector_ is not None + ): + if not isinstance(value, str): + lineno = self.gds_get_node_lineno_() + self.gds_collector_.add_message( + 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' + % { + "value": value, + "lineno": lineno, + } + ) + return False + if not self.gds_validate_simple_patterns( + self.validate_NmlId_patterns_, value + ): + self.gds_collector_.add_message( + 'Value "%s" does not match xsd pattern restrictions: %s' + % ( + encode_str_2_3(value), + self.validate_NmlId_patterns_, + ) + ) + + validate_NmlId_patterns_ = [["^([a-zA-Z_][a-zA-Z0-9_]*)$"]] + + def has__content(self): + if ( + self.variable_parameters + or super(ChannelDensityNonUniformGHK, self).has__content() + ): + return True + else: + return False + + def export( + self, + outfile, + level, + namespaceprefix_="", + namespacedef_=' xmlns:None="http://www.neuroml.org/schema/neuroml2" ', + name_="ChannelDensityNonUniformGHK", + pretty_print=True, + ): + imported_ns_def_ = GenerateDSNamespaceDefs_.get("ChannelDensityNonUniformGHK") + if imported_ns_def_ is not None: + namespacedef_ = imported_ns_def_ + if pretty_print: + eol_ = "\n" + else: + eol_ = "" + if ( + self.original_tagname_ is not None + and name_ == "ChannelDensityNonUniformGHK" + ): + name_ = self.original_tagname_ + if UseCapturedNS_ and self.ns_prefix_: + namespaceprefix_ = self.ns_prefix_ + ":" + showIndent(outfile, level, pretty_print) + outfile.write( + "<%s%s%s" + % ( + namespaceprefix_, + name_, + namespacedef_ and " " + namespacedef_ or "", + ) + ) + already_processed = set() + self._exportAttributes( + outfile, + level, + already_processed, + namespaceprefix_, + name_="ChannelDensityNonUniformGHK", + ) + if self.has__content(): + outfile.write(">%s" % (eol_,)) + self._exportChildren( + outfile, + level + 1, + namespaceprefix_, + namespacedef_, + name_="ChannelDensityNonUniformGHK", + pretty_print=pretty_print, + ) + showIndent(outfile, level, pretty_print) + outfile.write("%s" % (namespaceprefix_, name_, eol_)) + else: + outfile.write("/>%s" % (eol_,)) + + def _exportAttributes( + self, + outfile, + level, + already_processed, + namespaceprefix_="", + name_="ChannelDensityNonUniformGHK", + ): + super(ChannelDensityNonUniformGHK, self)._exportAttributes( + outfile, + level, + already_processed, + namespaceprefix_, + name_="ChannelDensityNonUniformGHK", + ) + if self.ion_channel is not None and "ion_channel" not in already_processed: + already_processed.add("ion_channel") + outfile.write( + " ionChannel=%s" + % ( + self.gds_encode( + self.gds_format_string( + quote_attrib(self.ion_channel), input_name="ionChannel" + ) + ), + ) + ) + if self.ion is not None and "ion" not in already_processed: + already_processed.add("ion") + outfile.write( + " ion=%s" + % ( + self.gds_encode( + self.gds_format_string(quote_attrib(self.ion), input_name="ion") + ), + ) + ) + + def _exportChildren( + self, + outfile, + level, + namespaceprefix_="", + namespacedef_=' xmlns:None="http://www.neuroml.org/schema/neuroml2" ', + name_="ChannelDensityNonUniformGHK", + fromsubclass_=False, + pretty_print=True, + ): + super(ChannelDensityNonUniformGHK, self)._exportChildren( + outfile, + level, + namespaceprefix_, + namespacedef_, + name_, + True, + pretty_print=pretty_print, + ) + if pretty_print: + eol_ = "\n" + else: + eol_ = "" + for variableParameter_ in self.variable_parameters: + namespaceprefix_ = ( + self.variable_parameters_nsprefix_ + ":" + if (UseCapturedNS_ and self.variable_parameters_nsprefix_) + else "" + ) + variableParameter_.export( + outfile, + level, + namespaceprefix_, + namespacedef_="", + name_="variableParameter", + pretty_print=pretty_print, + ) + + def validate_(self, gds_collector, recursive=False): + self.gds_collector_ = gds_collector + message_count = len(self.gds_collector_.get_messages()) + # validate simple type attributes + self.gds_validate_defined_ST_( + self.validate_NmlId, self.ion_channel, "ion_channel" + ) + self.gds_check_cardinality_(self.ion_channel, "ion_channel", required=True) + self.gds_validate_defined_ST_(self.validate_NmlId, self.ion, "ion") + self.gds_check_cardinality_(self.ion, "ion", required=True) + # validate simple type children + # validate complex type children + self.gds_check_cardinality_( + self.variable_parameters, + "variable_parameters", + min_occurs=0, + max_occurs=9999999, + ) + if recursive: + for item in self.variable_parameters: + item.validate_(gds_collector, recursive=True) return message_count == len(self.gds_collector_.get_messages()) def build(self, node, gds_collector_=None): @@ -22153,10 +22342,10 @@ class ChannelDensityNonUniformNernst(Base): def __init__( self, - id: "a NmlId (required)" = None, - ion_channel: "a NmlId (required)" = None, - ion: "a NmlId (required)" = None, - variable_parameters: "list of VariableParameter(s) (optional)" = None, + id=None, + ion_channel=None, + ion=None, + variable_parameters=None, gds_collector_=None, **kwargs_, ): @@ -22433,7 +22622,8 @@ def _buildChildren( class ChannelDensityNonUniform(Base): """ChannelDensityNonUniform -- Specifies a time varying ohmic conductance density, which is distributed on a region of the **cell.** The conductance density of the channel is not uniform, but is set using the **variableParameter** . Note, there is no dynamical description of this in LEMS yet, as this type only makes sense for multicompartmental cells. A ComponentType for this needs to be present to enable export of NeuroML 2 multicompartmental cells via LEMS/jNeuroML to NEURON \n - :param erev: The reversal potential of the current produced + :param erev: The reversal potential + of the current produced :type erev: voltage """ @@ -22466,11 +22656,11 @@ class ChannelDensityNonUniform(Base): def __init__( self, - id: "a NmlId (required)" = None, - ion_channel: "a NmlId (required)" = None, - erev: "a Nml2Quantity_voltage (required)" = None, - ion: "a NmlId (required)" = None, - variable_parameters: "list of VariableParameter(s) (optional)" = None, + id=None, + ion_channel=None, + erev=None, + ion=None, + variable_parameters=None, gds_collector_=None, **kwargs_, ): @@ -22849,14 +23039,14 @@ class ChannelPopulation(Base): def __init__( self, - id: "a NmlId (required)" = None, - ion_channel: "a NmlId (required)" = None, - number: "a NonNegativeInteger (required)" = None, - erev: "a Nml2Quantity_voltage (required)" = None, - segment_groups: "a NmlId (optional)" = "all", - segments: "a NonNegativeInteger (optional)" = None, - ion: "a NmlId (required)" = None, - variable_parameters: "list of VariableParameter(s) (optional)" = None, + id=None, + ion_channel=None, + number=None, + erev=None, + segment_groups="all", + segments=None, + ion=None, + variable_parameters=None, gds_collector_=None, **kwargs_, ): @@ -23286,11 +23476,7 @@ class Resistivity(BaseWithoutId): superclass = BaseWithoutId def __init__( - self, - value: "a Nml2Quantity_resistivity (required)" = None, - segment_groups: "a NmlId (optional)" = "all", - gds_collector_=None, - **kwargs_, + self, value=None, segment_groups="all", gds_collector_=None, **kwargs_ ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -23569,11 +23755,7 @@ class InitMembPotential(BaseWithoutId): superclass = BaseWithoutId def __init__( - self, - value: "a Nml2Quantity_voltage (required)" = None, - segment_groups: "a NmlId (optional)" = "all", - gds_collector_=None, - **kwargs_, + self, value=None, segment_groups="all", gds_collector_=None, **kwargs_ ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -23864,11 +24046,7 @@ class SpecificCapacitance(BaseWithoutId): superclass = BaseWithoutId def __init__( - self, - value: "a Nml2Quantity_specificCapacitance (required)" = None, - segment_groups: "a NmlId (optional)" = "all", - gds_collector_=None, - **kwargs_, + self, value=None, segment_groups="all", gds_collector_=None, **kwargs_ ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -24159,11 +24337,7 @@ class SpikeThresh(BaseWithoutId): superclass = BaseWithoutId def __init__( - self, - value: "a Nml2Quantity_voltage (required)" = None, - segment_groups: "a NmlId (optional)" = "all", - gds_collector_=None, - **kwargs_, + self, value=None, segment_groups="all", gds_collector_=None, **kwargs_ ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -24435,6 +24609,19 @@ class MembraneProperties(BaseWithoutId): }, None, ), + MemberSpec_( + "baseChannelDensity", + "BaseChannelDensity", + 1, + 1, + { + "maxOccurs": "unbounded", + "minOccurs": "0", + "name": "baseChannelDensity", + "type": "BaseChannelDensity", + }, + None, + ), MemberSpec_( "channel_densities", "ChannelDensity", @@ -24584,18 +24771,19 @@ class MembraneProperties(BaseWithoutId): def __init__( self, - channel_populations: "list of ChannelPopulation(s) (optional)" = None, - channel_densities: "list of ChannelDensity(s) (optional)" = None, - channel_density_v_shifts: "list of ChannelDensityVShift(s) (optional)" = None, - channel_density_nernsts: "list of ChannelDensityNernst(s) (optional)" = None, - channel_density_ghks: "list of ChannelDensityGHK(s) (optional)" = None, - channel_density_ghk2s: "list of ChannelDensityGHK2(s) (optional)" = None, - channel_density_non_uniforms: "list of ChannelDensityNonUniform(s) (optional)" = None, - channel_density_non_uniform_nernsts: "list of ChannelDensityNonUniformNernst(s) (optional)" = None, - channel_density_non_uniform_ghks: "list of ChannelDensityNonUniformGHK(s) (optional)" = None, - spike_threshes: "list of SpikeThresh(s) (required)" = None, - specific_capacitances: "list of SpecificCapacitance(s) (required)" = None, - init_memb_potentials: "list of InitMembPotential(s) (required)" = None, + channel_populations=None, + baseChannelDensity=None, + channel_densities=None, + channel_density_v_shifts=None, + channel_density_nernsts=None, + channel_density_ghks=None, + channel_density_ghk2s=None, + channel_density_non_uniforms=None, + channel_density_non_uniform_nernsts=None, + channel_density_non_uniform_ghks=None, + spike_threshes=None, + specific_capacitances=None, + init_memb_potentials=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -24613,6 +24801,11 @@ def __init__( else: self.channel_populations = channel_populations self.channel_populations_nsprefix_ = None + if baseChannelDensity is None: + self.baseChannelDensity = [] + else: + self.baseChannelDensity = baseChannelDensity + self.baseChannelDensity_nsprefix_ = None if channel_densities is None: self.channel_densities = [] else: @@ -24689,6 +24882,7 @@ def factory(*args_, **kwargs_): def has__content(self): if ( self.channel_populations + or self.baseChannelDensity or self.channel_densities or self.channel_density_v_shifts or self.channel_density_nernsts @@ -24823,6 +25017,20 @@ def _exportChildren( name_="channelPopulation", pretty_print=pretty_print, ) + for baseChannelDensity_ in self.baseChannelDensity: + namespaceprefix_ = ( + self.baseChannelDensity_nsprefix_ + ":" + if (UseCapturedNS_ and self.baseChannelDensity_nsprefix_) + else "" + ) + baseChannelDensity_.export( + outfile, + level, + namespaceprefix_, + namespacedef_="", + name_="baseChannelDensity", + pretty_print=pretty_print, + ) for channelDensity_ in self.channel_densities: namespaceprefix_ = ( self.channel_densities_nsprefix_ + ":" @@ -24993,6 +25201,12 @@ def validate_(self, gds_collector, recursive=False): min_occurs=0, max_occurs=9999999, ) + self.gds_check_cardinality_( + self.baseChannelDensity, + "baseChannelDensity", + min_occurs=0, + max_occurs=9999999, + ) self.gds_check_cardinality_( self.channel_densities, "channel_densities", @@ -25059,6 +25273,8 @@ def validate_(self, gds_collector, recursive=False): if recursive: for item in self.channel_populations: item.validate_(gds_collector, recursive=True) + for item in self.baseChannelDensity: + item.validate_(gds_collector, recursive=True) for item in self.channel_densities: item.validate_(gds_collector, recursive=True) for item in self.channel_density_v_shifts: @@ -25110,6 +25326,11 @@ def _buildChildren( obj_.build(child_, gds_collector_=gds_collector_) self.channel_populations.append(obj_) obj_.original_tagname_ = "channelPopulation" + elif nodeName_ == "baseChannelDensity": + obj_ = BaseChannelDensity.factory(parent_object_=self) + obj_.build(child_, gds_collector_=gds_collector_) + self.baseChannelDensity.append(obj_) + obj_.original_tagname_ = "baseChannelDensity" elif nodeName_ == "channelDensity": class_obj_ = self.get_class_obj_(child_, ChannelDensity) obj_ = class_obj_.factory(parent_object_=self) @@ -25219,14 +25440,14 @@ class BiophysicalProperties2CaPools(Standalone): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - membrane_properties2_ca_pools: "a MembraneProperties2CaPools (required)" = None, - intracellular_properties2_ca_pools: "a IntracellularProperties2CaPools (optional)" = None, - extracellular_properties: "a ExtracellularProperties (optional)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + membrane_properties2_ca_pools=None, + intracellular_properties2_ca_pools=None, + extracellular_properties=None, gds_collector_=None, **kwargs_, ): @@ -25532,14 +25753,14 @@ class BiophysicalProperties(Standalone): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - membrane_properties: "a MembraneProperties (required)" = None, - intracellular_properties: "a IntracellularProperties (optional)" = None, - extracellular_properties: "a ExtracellularProperties (optional)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + membrane_properties=None, + intracellular_properties=None, + extracellular_properties=None, gds_collector_=None, **kwargs_, ): @@ -25804,12 +26025,7 @@ class SegmentEndPoint(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__( - self, - segments: "a NonNegativeInteger (required)" = None, - gds_collector_=None, - **kwargs_, - ): + def __init__(self, segments=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -26015,13 +26231,7 @@ class SubTree(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__( - self, - from_: "a SegmentEndPoint (optional)" = None, - to: "a SegmentEndPoint (optional)" = None, - gds_collector_=None, - **kwargs_, - ): + def __init__(self, from_=None, to=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -26238,13 +26448,7 @@ class Path(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__( - self, - from_: "a SegmentEndPoint (optional)" = None, - to: "a SegmentEndPoint (optional)" = None, - gds_collector_=None, - **kwargs_, - ): + def __init__(self, from_=None, to=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -26450,12 +26654,7 @@ class Include(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__( - self, - segment_groups: "a NmlId (required)" = None, - gds_collector_=None, - **kwargs_, - ): + def __init__(self, segment_groups=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -26665,12 +26864,7 @@ class Member(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__( - self, - segments: "a NonNegativeInteger (required)" = None, - gds_collector_=None, - **kwargs_, - ): + def __init__(self, segments=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -26862,12 +27056,7 @@ class DistalDetails(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__( - self, - normalization_end: "a double (required)" = None, - gds_collector_=None, - **kwargs_, - ): + def __init__(self, normalization_end=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -27048,12 +27237,7 @@ class ProximalDetails(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__( - self, - translation_start: "a double (required)" = None, - gds_collector_=None, - **kwargs_, - ): + def __init__(self, translation_start=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -27249,11 +27433,11 @@ class InhomogeneousParameter(Base): def __init__( self, - id: "a NmlId (required)" = None, - variable: "a string (required)" = None, - metric: "a Metric (required)" = None, - proximal: "a ProximalDetails (optional)" = None, - distal: "a DistalDetails (optional)" = None, + id=None, + variable=None, + metric=None, + proximal=None, + distal=None, gds_collector_=None, **kwargs_, ): @@ -27649,16 +27833,16 @@ class SegmentGroup(Base): def __init__( self, - id: "a NonNegativeInteger (required)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - members: "list of Member(s) (optional)" = None, - includes: "list of Include(s) (optional)" = None, - paths: "list of Path(s) (optional)" = None, - sub_trees: "list of SubTree(s) (optional)" = None, - inhomogeneous_parameters: "list of InhomogeneousParameter(s) (optional)" = None, + id=None, + neuro_lex_id=None, + notes=None, + properties=None, + annotation=None, + members=None, + includes=None, + paths=None, + sub_trees=None, + inhomogeneous_parameters=None, gds_collector_=None, **kwargs_, ): @@ -28169,13 +28353,7 @@ class Point3DWithDiam(BaseWithoutId): superclass = BaseWithoutId def __init__( - self, - x: "a double (required)" = None, - y: "a double (required)" = None, - z: "a double (required)" = None, - diameter: "a DoubleGreaterThanZero (required)" = None, - gds_collector_=None, - **kwargs_, + self, x=None, y=None, z=None, diameter=None, gds_collector_=None, **kwargs_ ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -28455,11 +28633,7 @@ class SegmentParent(BaseWithoutId): superclass = BaseWithoutId def __init__( - self, - segments: "a NonNegativeInteger (required)" = None, - fraction_along: "a ZeroToOne (optional)" = "1", - gds_collector_=None, - **kwargs_, + self, segments=None, fraction_along="1", gds_collector_=None, **kwargs_ ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -28736,12 +28910,12 @@ class Segment(BaseNonNegativeIntegerId): def __init__( self, - id: "a NonNegativeInteger (required)" = None, - name: "a string (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - parent: "a SegmentParent (optional)" = None, - proximal: "a Point3DWithDiam (optional)" = None, - distal: "a Point3DWithDiam (required)" = None, + id=None, + name=None, + neuro_lex_id=None, + parent=None, + proximal=None, + distal=None, gds_collector_=None, **kwargs_, ): @@ -29181,13 +29355,13 @@ class Morphology(Standalone): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - segments: "list of Segment(s) (required)" = None, - segment_groups: "list of SegmentGroup(s) (optional)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + segments=None, + segment_groups=None, gds_collector_=None, **kwargs_, ): @@ -29419,12 +29593,12 @@ class BaseCell(Standalone): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -29661,10 +29835,10 @@ class PlasticityMechanism(BaseWithoutId): def __init__( self, - type: "a PlasticityTypes (required)" = None, - init_release_prob: "a ZeroToOne (required)" = None, - tau_rec: "a Nml2Quantity_time (required)" = None, - tau_fac: "a Nml2Quantity_time (optional)" = None, + type=None, + init_release_prob=None, + tau_rec=None, + tau_fac=None, gds_collector_=None, **kwargs_, ): @@ -30042,11 +30216,11 @@ class BlockMechanism(BaseWithoutId): def __init__( self, - type: "a BlockTypes (required)" = None, - species: "a NmlId (required)" = None, - block_concentration: "a Nml2Quantity_concentration (required)" = None, - scaling_conc: "a Nml2Quantity_concentration (required)" = None, - scaling_volt: "a Nml2Quantity_voltage (required)" = None, + type=None, + species=None, + block_concentration=None, + scaling_conc=None, + scaling_volt=None, gds_collector_=None, **kwargs_, ): @@ -30454,12 +30628,12 @@ class BaseSynapse(Standalone): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -30688,12 +30862,12 @@ class ConcentrationModel(Standalone): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - ion: "a NmlId (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + ion=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -30942,11 +31116,11 @@ class HHTime(BaseWithoutId): def __init__( self, - type: "a NmlId (required)" = None, - rate: "a Nml2Quantity_time (optional)" = None, - midpoint: "a Nml2Quantity_voltage (optional)" = None, - scale: "a Nml2Quantity_voltage (optional)" = None, - tau: "a Nml2Quantity_time (optional)" = None, + type=None, + rate=None, + midpoint=None, + scale=None, + tau=None, gds_collector_=None, **kwargs_, ): @@ -31315,10 +31489,10 @@ class HHVariable(BaseWithoutId): def __init__( self, - type: "a NmlId (required)" = None, - rate: "a float (optional)" = None, - midpoint: "a Nml2Quantity_voltage (optional)" = None, - scale: "a Nml2Quantity_voltage (optional)" = None, + type=None, + rate=None, + midpoint=None, + scale=None, gds_collector_=None, **kwargs_, ): @@ -31627,10 +31801,10 @@ class HHRate(BaseWithoutId): def __init__( self, - type: "a NmlId (required)" = None, - rate: "a Nml2Quantity_pertime (optional)" = None, - midpoint: "a Nml2Quantity_voltage (optional)" = None, - scale: "a Nml2Quantity_voltage (optional)" = None, + type=None, + rate=None, + midpoint=None, + scale=None, gds_collector_=None, **kwargs_, ): @@ -32007,12 +32181,12 @@ class GateFractionalSubgate(Base): def __init__( self, - id: "a NmlId (required)" = None, - fractional_conductance: "a Nml2Quantity_none (required)" = None, - notes: "a string (optional)" = None, - q10_settings: "a Q10Settings (optional)" = None, - steady_state: "a HHVariable (required)" = None, - time_course: "a HHTime (required)" = None, + id=None, + fractional_conductance=None, + notes=None, + q10_settings=None, + steady_state=None, + time_course=None, gds_collector_=None, **kwargs_, ): @@ -32425,11 +32599,11 @@ class GateFractional(Base): def __init__( self, - id: "a NmlId (required)" = None, - instances: "a PositiveInteger (required)" = None, - notes: "a string (optional)" = None, - q10_settings: "a Q10Settings (optional)" = None, - sub_gates: "list of GateFractionalSubgate(s) (required)" = None, + id=None, + instances=None, + notes=None, + q10_settings=None, + sub_gates=None, gds_collector_=None, **kwargs_, ): @@ -32768,10 +32942,10 @@ class GateHHInstantaneous(Base): def __init__( self, - id: "a NmlId (required)" = None, - instances: "a PositiveInteger (required)" = None, - notes: "a string (optional)" = None, - steady_state: "a HHVariable (required)" = None, + id=None, + instances=None, + notes=None, + steady_state=None, gds_collector_=None, **kwargs_, ): @@ -33116,13 +33290,13 @@ class GateHHRatesInf(Base): def __init__( self, - id: "a NmlId (required)" = None, - instances: "a PositiveInteger (required)" = None, - notes: "a string (optional)" = None, - q10_settings: "a Q10Settings (optional)" = None, - forward_rate: "a HHRate (required)" = None, - reverse_rate: "a HHRate (required)" = None, - steady_state: "a HHVariable (required)" = None, + id=None, + instances=None, + notes=None, + q10_settings=None, + forward_rate=None, + reverse_rate=None, + steady_state=None, gds_collector_=None, **kwargs_, ): @@ -33536,13 +33710,13 @@ class GateHHRatesTau(Base): def __init__( self, - id: "a NmlId (required)" = None, - instances: "a PositiveInteger (required)" = None, - notes: "a string (optional)" = None, - q10_settings: "a Q10Settings (optional)" = None, - forward_rate: "a HHRate (required)" = None, - reverse_rate: "a HHRate (required)" = None, - time_course: "a HHTime (required)" = None, + id=None, + instances=None, + notes=None, + q10_settings=None, + forward_rate=None, + reverse_rate=None, + time_course=None, gds_collector_=None, **kwargs_, ): @@ -33964,14 +34138,14 @@ class GateHHRatesTauInf(Base): def __init__( self, - id: "a NmlId (required)" = None, - instances: "a PositiveInteger (required)" = None, - notes: "a string (optional)" = None, - q10_settings: "a Q10Settings (optional)" = None, - forward_rate: "a HHRate (required)" = None, - reverse_rate: "a HHRate (required)" = None, - time_course: "a HHTime (required)" = None, - steady_state: "a HHVariable (required)" = None, + id=None, + instances=None, + notes=None, + q10_settings=None, + forward_rate=None, + reverse_rate=None, + time_course=None, + steady_state=None, gds_collector_=None, **kwargs_, ): @@ -34412,12 +34586,12 @@ class GateHHTauInf(Base): def __init__( self, - id: "a NmlId (required)" = None, - instances: "a PositiveInteger (required)" = None, - notes: "a string (optional)" = None, - q10_settings: "a Q10Settings (optional)" = None, - time_course: "a HHTime (required)" = None, - steady_state: "a HHVariable (required)" = None, + id=None, + instances=None, + notes=None, + q10_settings=None, + time_course=None, + steady_state=None, gds_collector_=None, **kwargs_, ): @@ -34796,12 +34970,12 @@ class GateHHRates(Base): def __init__( self, - id: "a NmlId (required)" = None, - instances: "a PositiveInteger (required)" = None, - notes: "a string (optional)" = None, - q10_settings: "a Q10Settings (optional)" = None, - forward_rate: "a HHRate (required)" = None, - reverse_rate: "a HHRate (required)" = None, + id=None, + instances=None, + notes=None, + q10_settings=None, + forward_rate=None, + reverse_rate=None, gds_collector_=None, **kwargs_, ): @@ -35205,16 +35379,16 @@ class GateHHUndetermined(Base): def __init__( self, - id: "a NmlId (required)" = None, - instances: "a PositiveInteger (required)" = None, - type: "a gateTypes (required)" = None, - notes: "a string (optional)" = None, - q10_settings: "a Q10Settings (optional)" = None, - forward_rate: "a HHRate (optional)" = None, - reverse_rate: "a HHRate (optional)" = None, - time_course: "a HHTime (optional)" = None, - steady_state: "a HHVariable (optional)" = None, - sub_gates: "list of GateFractionalSubgate(s) (optional)" = None, + id=None, + instances=None, + type=None, + notes=None, + q10_settings=None, + forward_rate=None, + reverse_rate=None, + time_course=None, + steady_state=None, + sub_gates=None, gds_collector_=None, **kwargs_, ): @@ -35778,15 +35952,15 @@ class GateKS(Base): def __init__( self, - id: "a NmlId (required)" = None, - instances: "a PositiveInteger (required)" = None, - notes: "a string (optional)" = None, - q10_settings: "a Q10Settings (optional)" = None, - closed_states: "list of ClosedState(s) (required)" = None, - open_states: "list of OpenState(s) (required)" = None, - forward_transition: "list of ForwardTransition(s) (required)" = None, - reverse_transition: "list of ReverseTransition(s) (required)" = None, - tau_inf_transition: "list of TauInfTransition(s) (required)" = None, + id=None, + instances=None, + notes=None, + q10_settings=None, + closed_states=None, + open_states=None, + forward_transition=None, + reverse_transition=None, + tau_inf_transition=None, gds_collector_=None, **kwargs_, ): @@ -36227,11 +36401,11 @@ class TauInfTransition(Base): def __init__( self, - id: "a NmlId (required)" = None, - from_: "a NmlId (required)" = None, - to: "a NmlId (required)" = None, - steady_state: "a HHVariable (required)" = None, - time_course: "a HHTime (required)" = None, + id=None, + from_=None, + to=None, + steady_state=None, + time_course=None, gds_collector_=None, **kwargs_, ): @@ -36532,9 +36706,9 @@ class ReverseTransition(Base): def __init__( self, - id: "a NmlId (required)" = None, - from_: "a NmlId (required)" = None, - to: "a NmlId (required)" = None, + id=None, + from_=None, + to=None, anytypeobjs_=None, gds_collector_=None, **kwargs_, @@ -36792,9 +36966,9 @@ class ForwardTransition(Base): def __init__( self, - id: "a NmlId (required)" = None, - from_: "a NmlId (required)" = None, - to: "a NmlId (required)" = None, + id=None, + from_=None, + to=None, anytypeobjs_=None, gds_collector_=None, **kwargs_, @@ -37044,7 +37218,7 @@ class OpenState(Base): subclass = None superclass = Base - def __init__(self, id: "a NmlId (required)" = None, gds_collector_=None, **kwargs_): + def __init__(self, id=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -37193,7 +37367,7 @@ class ClosedState(Base): subclass = None superclass = Base - def __init__(self, id: "a NmlId (required)" = None, gds_collector_=None, **kwargs_): + def __init__(self, id=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -37365,11 +37539,7 @@ class Q10ConductanceScaling(BaseWithoutId): superclass = BaseWithoutId def __init__( - self, - q10_factor: "a Nml2Quantity_none (required)" = None, - experimental_temp: "a Nml2Quantity_temperature (required)" = None, - gds_collector_=None, - **kwargs_, + self, q10_factor=None, experimental_temp=None, gds_collector_=None, **kwargs_ ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -37690,15 +37860,15 @@ class IonChannelKS(Standalone): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - species: "a NmlId (optional)" = None, - conductance: "a Nml2Quantity_conductance (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - gate_kses: "list of GateKS(s) (optional)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + species=None, + conductance=None, + neuro_lex_id=None, + gate_kses=None, gds_collector_=None, **kwargs_, ): @@ -38065,13 +38235,13 @@ class IonChannelScalable(Standalone): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - q10_conductance_scalings: "list of Q10ConductanceScaling(s) (optional)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + q10_conductance_scalings=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -39235,100 +39405,86 @@ class NeuroMLDocument(Standalone): }, None, ), - MemberSpec_( - "Component", - "Component", - 1, - 1, - { - "maxOccurs": "unbounded", - "minOccurs": "0", - "name": "Component", - "type": "Component", - }, - None, - ), ] subclass = None superclass = Standalone def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - includes: "list of IncludeType(s) (optional)" = None, - extracellular_properties: "list of ExtracellularProperties(s) (optional)" = None, - intracellular_properties: "list of IntracellularProperties(s) (optional)" = None, - morphology: "list of Morphology(s) (optional)" = None, - ion_channel: "list of IonChannel(s) (optional)" = None, - ion_channel_hhs: "list of IonChannelHH(s) (optional)" = None, - ion_channel_v_shifts: "list of IonChannelVShift(s) (optional)" = None, - ion_channel_kses: "list of IonChannelKS(s) (optional)" = None, - concentration_model: "list of ConcentrationModel(s) (optional)" = None, - decaying_pool_concentration_models: "list of DecayingPoolConcentrationModel(s) (optional)" = None, - fixed_factor_concentration_models: "list of FixedFactorConcentrationModel(s) (optional)" = None, - alpha_current_synapses: "list of AlphaCurrentSynapse(s) (optional)" = None, - alpha_synapses: "list of AlphaSynapse(s) (optional)" = None, - exp_one_synapses: "list of ExpOneSynapse(s) (optional)" = None, - exp_two_synapses: "list of ExpTwoSynapse(s) (optional)" = None, - exp_three_synapses: "list of ExpThreeSynapse(s) (optional)" = None, - blocking_plastic_synapses: "list of BlockingPlasticSynapse(s) (optional)" = None, - double_synapses: "list of DoubleSynapse(s) (optional)" = None, - gap_junctions: "list of GapJunction(s) (optional)" = None, - silent_synapses: "list of SilentSynapse(s) (optional)" = None, - linear_graded_synapses: "list of LinearGradedSynapse(s) (optional)" = None, - graded_synapses: "list of GradedSynapse(s) (optional)" = None, - biophysical_properties: "list of BiophysicalProperties(s) (optional)" = None, - cells: "list of Cell(s) (optional)" = None, - cell2_ca_poolses: "list of Cell2CaPools(s) (optional)" = None, - base_cells: "list of BaseCell(s) (optional)" = None, - iaf_tau_cells: "list of IafTauCell(s) (optional)" = None, - iaf_tau_ref_cells: "list of IafTauRefCell(s) (optional)" = None, - iaf_cells: "list of IafCell(s) (optional)" = None, - iaf_ref_cells: "list of IafRefCell(s) (optional)" = None, - izhikevich_cells: "list of IzhikevichCell(s) (optional)" = None, - izhikevich2007_cells: "list of Izhikevich2007Cell(s) (optional)" = None, - ad_ex_ia_f_cells: "list of AdExIaFCell(s) (optional)" = None, - fitz_hugh_nagumo_cells: "list of FitzHughNagumoCell(s) (optional)" = None, - fitz_hugh_nagumo1969_cells: "list of FitzHughNagumo1969Cell(s) (optional)" = None, - pinsky_rinzel_ca3_cells: "list of PinskyRinzelCA3Cell(s) (optional)" = None, - hindmarshRose1984Cell: "list of HindmarshRose1984Cell(s) (optional)" = None, - pulse_generators: "list of PulseGenerator(s) (optional)" = None, - pulse_generator_dls: "list of PulseGeneratorDL(s) (optional)" = None, - sine_generators: "list of SineGenerator(s) (optional)" = None, - sine_generator_dls: "list of SineGeneratorDL(s) (optional)" = None, - ramp_generators: "list of RampGenerator(s) (optional)" = None, - ramp_generator_dls: "list of RampGeneratorDL(s) (optional)" = None, - compound_inputs: "list of CompoundInput(s) (optional)" = None, - compound_input_dls: "list of CompoundInputDL(s) (optional)" = None, - voltage_clamps: "list of VoltageClamp(s) (optional)" = None, - voltage_clamp_triples: "list of VoltageClampTriple(s) (optional)" = None, - spike_arrays: "list of SpikeArray(s) (optional)" = None, - timed_synaptic_inputs: "list of TimedSynapticInput(s) (optional)" = None, - spike_generators: "list of SpikeGenerator(s) (optional)" = None, - spike_generator_randoms: "list of SpikeGeneratorRandom(s) (optional)" = None, - spike_generator_poissons: "list of SpikeGeneratorPoisson(s) (optional)" = None, - spike_generator_ref_poissons: "list of SpikeGeneratorRefPoisson(s) (optional)" = None, - poisson_firing_synapses: "list of PoissonFiringSynapse(s) (optional)" = None, - transient_poisson_firing_synapses: "list of TransientPoissonFiringSynapse(s) (optional)" = None, - IF_curr_alpha: "list of IF_curr_alpha(s) (optional)" = None, - IF_curr_exp: "list of IF_curr_exp(s) (optional)" = None, - IF_cond_alpha: "list of IF_cond_alpha(s) (optional)" = None, - IF_cond_exp: "list of IF_cond_exp(s) (optional)" = None, - EIF_cond_exp_isfa_ista: "list of EIF_cond_exp_isfa_ista(s) (optional)" = None, - EIF_cond_alpha_isfa_ista: "list of EIF_cond_alpha_isfa_ista(s) (optional)" = None, - HH_cond_exp: "list of HH_cond_exp(s) (optional)" = None, - exp_cond_synapses: "list of ExpCondSynapse(s) (optional)" = None, - alpha_cond_synapses: "list of AlphaCondSynapse(s) (optional)" = None, - exp_curr_synapses: "list of ExpCurrSynapse(s) (optional)" = None, - alpha_curr_synapses: "list of AlphaCurrSynapse(s) (optional)" = None, - SpikeSourcePoisson: "list of SpikeSourcePoisson(s) (optional)" = None, - networks: "list of Network(s) (optional)" = None, - ComponentType: "list of ComponentType(s) (optional)" = None, - Component: "list of Component(s) (optional)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + includes=None, + extracellular_properties=None, + intracellular_properties=None, + morphology=None, + ion_channel=None, + ion_channel_hhs=None, + ion_channel_v_shifts=None, + ion_channel_kses=None, + concentration_model=None, + decaying_pool_concentration_models=None, + fixed_factor_concentration_models=None, + alpha_current_synapses=None, + alpha_synapses=None, + exp_one_synapses=None, + exp_two_synapses=None, + exp_three_synapses=None, + blocking_plastic_synapses=None, + double_synapses=None, + gap_junctions=None, + silent_synapses=None, + linear_graded_synapses=None, + graded_synapses=None, + biophysical_properties=None, + cells=None, + cell2_ca_poolses=None, + base_cells=None, + iaf_tau_cells=None, + iaf_tau_ref_cells=None, + iaf_cells=None, + iaf_ref_cells=None, + izhikevich_cells=None, + izhikevich2007_cells=None, + ad_ex_ia_f_cells=None, + fitz_hugh_nagumo_cells=None, + fitz_hugh_nagumo1969_cells=None, + pinsky_rinzel_ca3_cells=None, + hindmarshRose1984Cell=None, + pulse_generators=None, + pulse_generator_dls=None, + sine_generators=None, + sine_generator_dls=None, + ramp_generators=None, + ramp_generator_dls=None, + compound_inputs=None, + compound_input_dls=None, + voltage_clamps=None, + voltage_clamp_triples=None, + spike_arrays=None, + timed_synaptic_inputs=None, + spike_generators=None, + spike_generator_randoms=None, + spike_generator_poissons=None, + spike_generator_ref_poissons=None, + poisson_firing_synapses=None, + transient_poisson_firing_synapses=None, + IF_curr_alpha=None, + IF_curr_exp=None, + IF_cond_alpha=None, + IF_cond_exp=None, + EIF_cond_exp_isfa_ista=None, + EIF_cond_alpha_isfa_ista=None, + HH_cond_exp=None, + exp_cond_synapses=None, + alpha_cond_synapses=None, + exp_curr_synapses=None, + alpha_curr_synapses=None, + SpikeSourcePoisson=None, + networks=None, + ComponentType=None, gds_collector_=None, **kwargs_, ): @@ -39685,11 +39841,6 @@ def __init__( else: self.ComponentType = ComponentType self.ComponentType_nsprefix_ = None - if Component is None: - self.Component = [] - else: - self.Component = Component - self.Component_nsprefix_ = None def factory(*args_, **kwargs_): if CurrentSubclassModule_ is not None: @@ -39774,7 +39925,6 @@ def has__content(self): or self.SpikeSourcePoisson or self.networks or self.ComponentType - or self.Component or super(NeuroMLDocument, self).has__content() ): return True @@ -40832,20 +40982,6 @@ def _exportChildren( name_="ComponentType", pretty_print=pretty_print, ) - for Component_ in self.Component: - namespaceprefix_ = ( - self.Component_nsprefix_ + ":" - if (UseCapturedNS_ and self.Component_nsprefix_) - else "" - ) - Component_.export( - outfile, - level, - namespaceprefix_, - namespacedef_="", - name_="Component", - pretty_print=pretty_print, - ) def validate_(self, gds_collector, recursive=False): self.gds_collector_ = gds_collector @@ -41165,9 +41301,6 @@ def validate_(self, gds_collector, recursive=False): self.gds_check_cardinality_( self.ComponentType, "ComponentType", min_occurs=0, max_occurs=9999999 ) - self.gds_check_cardinality_( - self.Component, "Component", min_occurs=0, max_occurs=9999999 - ) if recursive: for item in self.includes: item.validate_(gds_collector, recursive=True) @@ -41307,8 +41440,6 @@ def validate_(self, gds_collector, recursive=False): item.validate_(gds_collector, recursive=True) for item in self.ComponentType: item.validate_(gds_collector, recursive=True) - for item in self.Component: - item.validate_(gds_collector, recursive=True) return message_count == len(self.gds_collector_.get_messages()) def build(self, node, gds_collector_=None): @@ -41685,11 +41816,6 @@ def _buildChildren( obj_.build(child_, gds_collector_=gds_collector_) self.ComponentType.append(obj_) obj_.original_tagname_ = "ComponentType" - elif nodeName_ == "Component": - obj_ = Component.factory(parent_object_=self) - obj_.build(child_, gds_collector_=gds_collector_) - self.Component.append(obj_) - obj_.original_tagname_ = "Component" super(NeuroMLDocument, self)._buildChildren(child_, node, nodeName_, True) def summary(self, show_includes=True, show_non_network=True): @@ -41962,10 +42088,10 @@ class NamedDimensionalVariable(BaseWithoutId): def __init__( self, - name: "a string (required)" = None, - dimension: "a string (required)" = None, - description: "a string (optional)" = None, - exposure: "a string (optional)" = None, + name=None, + dimension=None, + description=None, + exposure=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -42245,9 +42371,9 @@ class NamedDimensionalType(BaseWithoutId): def __init__( self, - name: "a string (required)" = None, - dimension: "a string (required)" = None, - description: "a string (optional)" = None, + name=None, + dimension=None, + description=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -42505,9 +42631,9 @@ class Exposure(BaseWithoutId): def __init__( self, - name: "a string (required)" = None, - dimension: "a string (required)" = None, - description: "a string (optional)" = None, + name=None, + dimension=None, + description=None, gds_collector_=None, **kwargs_, ): @@ -42710,275 +42836,6 @@ def _buildChildren( # end class Exposure -class Component(Base): - """Component -- A new Component based on a new defined ComponentType.""" - - __hash__ = GeneratedsSuper.__hash__ - member_data_items_ = [ - MemberSpec_("type", "NmlId", 0, 0, {"use": "required", "name": "type"}), - ] - subclass = None - superclass = Base - - def __init__( - self, - id: "a NmlId (required)" = None, - type: "a NmlId (required)" = None, - gds_collector_=None, - **kwargs_, - ): - self.gds_collector_ = gds_collector_ - self.gds_elementtree_node_ = None - self.original_tagname_ = None - self.parent_object_ = kwargs_.get("parent_object_") - self.ns_prefix_ = None - super(globals().get("Component"), self).__init__(id, **kwargs_) - self.type = _cast(None, type) - self.type_nsprefix_ = None - self.anyAttributes_ = {} - - def factory(*args_, **kwargs_): - if CurrentSubclassModule_ is not None: - subclass = getSubclassFromModule_(CurrentSubclassModule_, Component) - if subclass is not None: - return subclass(*args_, **kwargs_) - if Component.subclass: - return Component.subclass(*args_, **kwargs_) - else: - return Component(*args_, **kwargs_) - - factory = staticmethod(factory) - - def validate_NmlId(self, value): - # Validate type NmlId, a restriction on xs:string. - if ( - value is not None - and Validate_simpletypes_ - and self.gds_collector_ is not None - ): - if not isinstance(value, str): - lineno = self.gds_get_node_lineno_() - self.gds_collector_.add_message( - 'Value "%(value)s"%(lineno)s is not of the correct base simple type (str)' - % { - "value": value, - "lineno": lineno, - } - ) - return False - if not self.gds_validate_simple_patterns( - self.validate_NmlId_patterns_, value - ): - self.gds_collector_.add_message( - 'Value "%s" does not match xsd pattern restrictions: %s' - % ( - encode_str_2_3(value), - self.validate_NmlId_patterns_, - ) - ) - - validate_NmlId_patterns_ = [["^([a-zA-Z_][a-zA-Z0-9_]*)$"]] - - def has__content(self): - if super(Component, self).has__content(): - return True - else: - return False - - def export( - self, - outfile, - level, - namespaceprefix_="", - namespacedef_="", - name_="Component", - pretty_print=True, - ): - imported_ns_def_ = GenerateDSNamespaceDefs_.get("Component") - if imported_ns_def_ is not None: - namespacedef_ = imported_ns_def_ - if pretty_print: - eol_ = "\n" - else: - eol_ = "" - if self.original_tagname_ is not None and name_ == "Component": - name_ = self.original_tagname_ - if UseCapturedNS_ and self.ns_prefix_: - namespaceprefix_ = self.ns_prefix_ + ":" - showIndent(outfile, level, pretty_print) - outfile.write( - "<%s%s%s" - % ( - namespaceprefix_, - name_, - namespacedef_ and " " + namespacedef_ or "", - ) - ) - already_processed = set() - self._exportAttributes( - outfile, level, already_processed, namespaceprefix_, name_="Component" - ) - if self.has__content(): - outfile.write(">%s" % (eol_,)) - self._exportChildren( - outfile, - level + 1, - namespaceprefix_, - namespacedef_, - name_="Component", - pretty_print=pretty_print, - ) - outfile.write("%s" % (namespaceprefix_, name_, eol_)) - else: - outfile.write("/>%s" % (eol_,)) - - def _exportAttributes( - self, outfile, level, already_processed, namespaceprefix_="", name_="Component" - ): - unique_counter = 0 - for name, value in self.anyAttributes_.items(): - xsinamespaceprefix = "xsi" - xsinamespace1 = "http://www.w3.org/2001/XMLSchema-instance" - xsinamespace2 = "{%s}" % (xsinamespace1,) - if name.startswith(xsinamespace2): - name1 = name[len(xsinamespace2) :] - name2 = "%s:%s" % ( - xsinamespaceprefix, - name1, - ) - if name2 not in already_processed: - already_processed.add(name2) - outfile.write( - " %s=%s" - % ( - name2, - quote_attrib(value), - ) - ) - else: - mo = re_.match(Namespace_extract_pat_, name) - if mo is not None: - namespace, name = mo.group(1, 2) - if name not in already_processed: - already_processed.add(name) - if namespace == "http://www.w3.org/XML/1998/namespace": - outfile.write( - " %s=%s" - % ( - name, - quote_attrib(value), - ) - ) - else: - unique_counter += 1 - outfile.write( - ' xmlns:%d="%s"' - % ( - unique_counter, - namespace, - ) - ) - outfile.write( - " %d:%s=%s" - % ( - unique_counter, - name, - quote_attrib(value), - ) - ) - else: - if name not in already_processed: - already_processed.add(name) - outfile.write( - " %s=%s" - % ( - name, - quote_attrib(value), - ) - ) - super(Component, self)._exportAttributes( - outfile, level, already_processed, namespaceprefix_, name_="Component" - ) - if self.type is not None and "type" not in already_processed: - already_processed.add("type") - outfile.write( - " type=%s" - % ( - self.gds_encode( - self.gds_format_string( - quote_attrib(self.type), input_name="type" - ) - ), - ) - ) - - def _exportChildren( - self, - outfile, - level, - namespaceprefix_="", - namespacedef_="", - name_="Component", - fromsubclass_=False, - pretty_print=True, - ): - super(Component, self)._exportChildren( - outfile, - level, - namespaceprefix_, - namespacedef_, - name_, - True, - pretty_print=pretty_print, - ) - pass - - def validate_(self, gds_collector, recursive=False): - self.gds_collector_ = gds_collector - message_count = len(self.gds_collector_.get_messages()) - # validate simple type attributes - self.gds_validate_defined_ST_(self.validate_NmlId, self.type, "type") - self.gds_check_cardinality_(self.type, "type", required=True) - # validate simple type children - # validate complex type children - if recursive: - pass - return message_count == len(self.gds_collector_.get_messages()) - - def build(self, node, gds_collector_=None): - self.gds_collector_ = gds_collector_ - if SaveElementTreeNode: - self.gds_elementtree_node_ = node - already_processed = set() - self.ns_prefix_ = node.prefix - self._buildAttributes(node, node.attrib, already_processed) - for child in node: - nodeName_ = Tag_pattern_.match(child.tag).groups()[-1] - self._buildChildren(child, node, nodeName_, gds_collector_=gds_collector_) - return self - - def _buildAttributes(self, node, attrs, already_processed): - value = find_attr_value_("type", node) - if value is not None and "type" not in already_processed: - already_processed.add("type") - self.type = value - self.validate_NmlId(self.type) # validate type NmlId - self.anyAttributes_ = {} - for name, value in attrs.items(): - if name not in already_processed: - self.anyAttributes_[name] = value - super(Component, self)._buildAttributes(node, attrs, already_processed) - - def _buildChildren( - self, child_, node, nodeName_, fromsubclass_=False, gds_collector_=None - ): - super(Component, self)._buildChildren(child_, node, nodeName_, True) - pass - - -# end class Component - - class Constant(BaseWithoutId): """Constant -- LEMS ComponentType for Constant.""" @@ -43000,10 +42857,10 @@ class Constant(BaseWithoutId): def __init__( self, - name: "a string (required)" = None, - dimension: "a string (required)" = None, - value: "a Nml2Quantity (required)" = None, - description: "a string (optional)" = None, + name=None, + dimension=None, + value=None, + description=None, gds_collector_=None, **kwargs_, ): @@ -43437,13 +43294,7 @@ class Property(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__( - self, - tag: "a string (required)" = None, - value: "a string (required)" = None, - gds_collector_=None, - **kwargs_, - ): + def __init__(self, tag=None, value=None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -43636,13 +43487,13 @@ class BasePynnSynapse(BaseSynapse): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - tau_syn: "a float (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + tau_syn=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -43863,17 +43714,17 @@ class basePyNNCell(BaseCell): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - cm: "a float (required)" = None, - i_offset: "a float (required)" = None, - tau_syn_E: "a float (required)" = None, - tau_syn_I: "a float (required)" = None, - v_init: "a float (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + cm=None, + i_offset=None, + tau_syn_E=None, + tau_syn_I=None, + v_init=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -44138,12 +43989,12 @@ class InputW(Input): def __init__( self, - id: "a NonNegativeInteger (required)" = None, - target: "a Nml2PopulationReferencePath (required)" = None, - destination: "a NmlId (required)" = None, - segment_id: "a NonNegativeInteger (optional)" = None, - fraction_along: "a ZeroToOne (optional)" = None, - weight: "a float (required)" = None, + id=None, + target=None, + destination=None, + segment_id=None, + fraction_along=None, + weight=None, gds_collector_=None, **kwargs_, ): @@ -44369,12 +44220,12 @@ class ContinuousProjection(BaseProjection): def __init__( self, - id: "a NmlId (required)" = None, - presynaptic_population: "a NmlId (required)" = None, - postsynaptic_population: "a NmlId (required)" = None, - continuous_connections: "list of ContinuousConnection(s) (optional)" = None, - continuous_connection_instances: "list of ContinuousConnectionInstance(s) (optional)" = None, - continuous_connection_instance_ws: "list of ContinuousConnectionInstanceW(s) (optional)" = None, + id=None, + presynaptic_population=None, + postsynaptic_population=None, + continuous_connections=None, + continuous_connection_instances=None, + continuous_connection_instance_ws=None, gds_collector_=None, **kwargs_, ): @@ -44784,12 +44635,12 @@ class ElectricalProjection(BaseProjection): def __init__( self, - id: "a NmlId (required)" = None, - presynaptic_population: "a NmlId (required)" = None, - postsynaptic_population: "a NmlId (required)" = None, - electrical_connections: "list of ElectricalConnection(s) (optional)" = None, - electrical_connection_instances: "list of ElectricalConnectionInstance(s) (optional)" = None, - electrical_connection_instance_ws: "list of ElectricalConnectionInstanceW(s) (optional)" = None, + id=None, + presynaptic_population=None, + postsynaptic_population=None, + electrical_connections=None, + electrical_connection_instances=None, + electrical_connection_instance_ws=None, gds_collector_=None, **kwargs_, ): @@ -45189,14 +45040,14 @@ class BaseConnectionNewFormat(BaseConnection): def __init__( self, - id: "a NmlId (required)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - pre_cell: "a string (required)" = None, - pre_segment: "a NonNegativeInteger (optional)" = "0", - pre_fraction_along: "a ZeroToOne (optional)" = "0.5", - post_cell: "a string (required)" = None, - post_segment: "a NonNegativeInteger (optional)" = "0", - post_fraction_along: "a ZeroToOne (optional)" = "0.5", + id=None, + neuro_lex_id=None, + pre_cell=None, + pre_segment="0", + pre_fraction_along="0.5", + post_cell=None, + post_segment="0", + post_fraction_along="0.5", extensiontype_=None, gds_collector_=None, **kwargs_, @@ -45617,14 +45468,14 @@ class BaseConnectionOldFormat(BaseConnection): def __init__( self, - id: "a NmlId (required)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - pre_cell_id: "a Nml2PopulationReferencePath (required)" = None, - pre_segment_id: "a NonNegativeInteger (optional)" = "0", - pre_fraction_along: "a ZeroToOne (optional)" = "0.5", - post_cell_id: "a Nml2PopulationReferencePath (required)" = None, - post_segment_id: "a NonNegativeInteger (optional)" = "0", - post_fraction_along: "a ZeroToOne (optional)" = "0.5", + id=None, + neuro_lex_id=None, + pre_cell_id=None, + pre_segment_id="0", + pre_fraction_along="0.5", + post_cell_id=None, + post_segment_id="0", + post_fraction_along="0.5", extensiontype_=None, gds_collector_=None, **kwargs_, @@ -46075,12 +45926,12 @@ class Projection(BaseProjection): def __init__( self, - id: "a NmlId (required)" = None, - presynaptic_population: "a NmlId (required)" = None, - postsynaptic_population: "a NmlId (required)" = None, - synapse: "a NmlId (required)" = None, - connections: "list of Connection(s) (optional)" = None, - connection_wds: "list of ConnectionWD(s) (optional)" = None, + id=None, + presynaptic_population=None, + postsynaptic_population=None, + synapse=None, + connections=None, + connection_wds=None, gds_collector_=None, **kwargs_, ): @@ -46465,13 +46316,13 @@ class SpikeGeneratorRefPoisson(SpikeGeneratorPoisson): def __init__( self, - id: "a NonNegativeInteger (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - average_rate: "a Nml2Quantity_pertime (required)" = None, - minimum_isi: "a Nml2Quantity_time (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + average_rate=None, + minimum_isi=None, gds_collector_=None, **kwargs_, ): @@ -46697,11 +46548,7 @@ class IntracellularProperties2CaPools(IntracellularProperties): superclass = IntracellularProperties def __init__( - self, - species: "list of Species(s) (optional)" = None, - resistivities: "list of Resistivity(s) (optional)" = None, - gds_collector_=None, - **kwargs_, + self, species=None, resistivities=None, gds_collector_=None, **kwargs_ ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -46879,13 +46726,13 @@ class ChannelDensityNernstCa2(ChannelDensityNernst): def __init__( self, - id: "a NmlId (required)" = None, - ion_channel: "a NmlId (required)" = None, - cond_density: "a Nml2Quantity_conductanceDensity (optional)" = None, - segment_groups: "a NmlId (optional)" = "all", - segments: "a NonNegativeInteger (optional)" = None, - ion: "a NmlId (required)" = None, - variable_parameters: "list of VariableParameter(s) (optional)" = None, + id=None, + ion_channel=None, + cond_density=None, + segment_groups="all", + segments=None, + ion=None, + variable_parameters=None, gds_collector_=None, **kwargs_, ): @@ -47079,15 +46926,15 @@ class ChannelDensityVShift(ChannelDensity): def __init__( self, - id: "a NmlId (required)" = None, - ion_channel: "a NmlId (required)" = None, - cond_density: "a Nml2Quantity_conductanceDensity (optional)" = None, - erev: "a Nml2Quantity_voltage (required)" = None, - segment_groups: "a NmlId (optional)" = "all", - segments: "a NonNegativeInteger (optional)" = None, - ion: "a NmlId (required)" = None, - variable_parameters: "list of VariableParameter(s) (optional)" = None, - v_shift: "a Nml2Quantity_voltage (required)" = None, + id=None, + ion_channel=None, + cond_density=None, + erev=None, + segment_groups="all", + segments=None, + ion=None, + variable_parameters=None, + v_shift=None, gds_collector_=None, **kwargs_, ): @@ -47334,19 +47181,20 @@ class MembraneProperties2CaPools(MembraneProperties): def __init__( self, - channel_populations: "list of ChannelPopulation(s) (optional)" = None, - channel_densities: "list of ChannelDensity(s) (optional)" = None, - channel_density_v_shifts: "list of ChannelDensityVShift(s) (optional)" = None, - channel_density_nernsts: "list of ChannelDensityNernst(s) (optional)" = None, - channel_density_ghks: "list of ChannelDensityGHK(s) (optional)" = None, - channel_density_ghk2s: "list of ChannelDensityGHK2(s) (optional)" = None, - channel_density_non_uniforms: "list of ChannelDensityNonUniform(s) (optional)" = None, - channel_density_non_uniform_nernsts: "list of ChannelDensityNonUniformNernst(s) (optional)" = None, - channel_density_non_uniform_ghks: "list of ChannelDensityNonUniformGHK(s) (optional)" = None, - spike_threshes: "list of SpikeThresh(s) (required)" = None, - specific_capacitances: "list of SpecificCapacitance(s) (required)" = None, - init_memb_potentials: "list of InitMembPotential(s) (required)" = None, - channel_density_nernst_ca2s: "list of ChannelDensityNernstCa2(s) (optional)" = None, + channel_populations=None, + baseChannelDensity=None, + channel_densities=None, + channel_density_v_shifts=None, + channel_density_nernsts=None, + channel_density_ghks=None, + channel_density_ghk2s=None, + channel_density_non_uniforms=None, + channel_density_non_uniform_nernsts=None, + channel_density_non_uniform_ghks=None, + spike_threshes=None, + specific_capacitances=None, + init_memb_potentials=None, + channel_density_nernst_ca2s=None, gds_collector_=None, **kwargs_, ): @@ -47357,6 +47205,7 @@ def __init__( self.ns_prefix_ = None super(globals().get("MembraneProperties2CaPools"), self).__init__( channel_populations, + baseChannelDensity, channel_densities, channel_density_v_shifts, channel_density_nernsts, @@ -47600,16 +47449,16 @@ class Cell(BaseCell): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - morphology_attr: "a NmlId (optional)" = None, - biophysical_properties_attr: "a NmlId (optional)" = None, - morphology: "a Morphology (optional)" = None, - biophysical_properties: "a BiophysicalProperties (optional)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + morphology_attr=None, + biophysical_properties_attr=None, + morphology=None, + biophysical_properties=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -49764,33 +49613,33 @@ class PinskyRinzelCA3Cell(BaseCell): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - i_soma: "a Nml2Quantity_currentDensity (required)" = None, - i_dend: "a Nml2Quantity_currentDensity (required)" = None, - gc: "a Nml2Quantity_conductanceDensity (required)" = None, - g_ls: "a Nml2Quantity_conductanceDensity (required)" = None, - g_ld: "a Nml2Quantity_conductanceDensity (required)" = None, - g_na: "a Nml2Quantity_conductanceDensity (required)" = None, - g_kdr: "a Nml2Quantity_conductanceDensity (required)" = None, - g_ca: "a Nml2Quantity_conductanceDensity (required)" = None, - g_kahp: "a Nml2Quantity_conductanceDensity (required)" = None, - g_kc: "a Nml2Quantity_conductanceDensity (required)" = None, - g_nmda: "a Nml2Quantity_conductanceDensity (required)" = None, - g_ampa: "a Nml2Quantity_conductanceDensity (required)" = None, - e_na: "a Nml2Quantity_voltage (required)" = None, - e_ca: "a Nml2Quantity_voltage (required)" = None, - e_k: "a Nml2Quantity_voltage (required)" = None, - e_l: "a Nml2Quantity_voltage (required)" = None, - qd0: "a Nml2Quantity_none (required)" = None, - pp: "a Nml2Quantity_none (required)" = None, - alphac: "a Nml2Quantity_none (required)" = None, - betac: "a Nml2Quantity_none (required)" = None, - cm: "a Nml2Quantity_specificCapacitance (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + i_soma=None, + i_dend=None, + gc=None, + g_ls=None, + g_ld=None, + g_na=None, + g_kdr=None, + g_ca=None, + g_kahp=None, + g_kc=None, + g_nmda=None, + g_ampa=None, + e_na=None, + e_ca=None, + e_k=None, + e_l=None, + qd0=None, + pp=None, + alphac=None, + betac=None, + cm=None, gds_collector_=None, **kwargs_, ): @@ -50651,18 +50500,18 @@ class FitzHughNagumo1969Cell(BaseCell): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - a: "a Nml2Quantity_none (required)" = None, - b: "a Nml2Quantity_none (required)" = None, - I: "a Nml2Quantity_none (required)" = None, - phi: "a Nml2Quantity_none (required)" = None, - V0: "a Nml2Quantity_none (required)" = None, - W0: "a Nml2Quantity_none (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + a=None, + b=None, + I=None, + phi=None, + V0=None, + W0=None, gds_collector_=None, **kwargs_, ): @@ -50985,13 +50834,13 @@ class FitzHughNagumoCell(BaseCell): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - I: "a Nml2Quantity_none (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + I=None, gds_collector_=None, **kwargs_, ): @@ -51217,13 +51066,13 @@ class BaseCellMembPotCap(BaseCell): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - C: "a Nml2Quantity_capacitance (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + C=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -51499,18 +51348,18 @@ class IzhikevichCell(BaseCell): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - v0: "a Nml2Quantity_voltage (required)" = None, - thresh: "a Nml2Quantity_voltage (required)" = None, - a: "a Nml2Quantity_none (required)" = None, - b: "a Nml2Quantity_none (required)" = None, - c: "a Nml2Quantity_none (required)" = None, - d: "a Nml2Quantity_none (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + v0=None, + thresh=None, + a=None, + b=None, + c=None, + d=None, gds_collector_=None, **kwargs_, ): @@ -51893,17 +51742,17 @@ class IafCell(BaseCell): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - leak_reversal: "a Nml2Quantity_voltage (required)" = None, - thresh: "a Nml2Quantity_voltage (required)" = None, - reset: "a Nml2Quantity_voltage (required)" = None, - C: "a Nml2Quantity_capacitance (required)" = None, - leak_conductance: "a Nml2Quantity_conductance (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + leak_reversal=None, + thresh=None, + reset=None, + C=None, + leak_conductance=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -52338,16 +52187,16 @@ class IafTauCell(BaseCell): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - leak_reversal: "a Nml2Quantity_voltage (required)" = None, - thresh: "a Nml2Quantity_voltage (required)" = None, - reset: "a Nml2Quantity_voltage (required)" = None, - tau: "a Nml2Quantity_time (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + leak_reversal=None, + thresh=None, + reset=None, + tau=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -52714,17 +52563,17 @@ class GradedSynapse(BaseSynapse): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - conductance: "a Nml2Quantity_conductance (required)" = None, - delta: "a Nml2Quantity_voltage (required)" = None, - Vth: "a Nml2Quantity_voltage (required)" = None, - k: "a Nml2Quantity_pertime (required)" = None, - erev: "a Nml2Quantity_voltage (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + conductance=None, + delta=None, + Vth=None, + k=None, + erev=None, gds_collector_=None, **kwargs_, ): @@ -53108,13 +52957,13 @@ class LinearGradedSynapse(BaseSynapse): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - conductance: "a Nml2Quantity_conductance (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + conductance=None, gds_collector_=None, **kwargs_, ): @@ -53339,12 +53188,12 @@ class SilentSynapse(BaseSynapse): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, gds_collector_=None, **kwargs_, ): @@ -53513,13 +53362,13 @@ class GapJunction(BaseSynapse): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - conductance: "a Nml2Quantity_conductance (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + conductance=None, gds_collector_=None, **kwargs_, ): @@ -53732,12 +53581,12 @@ class BaseCurrentBasedSynapse(BaseSynapse): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -53932,12 +53781,12 @@ class BaseVoltageDepSynapse(BaseSynapse): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -54157,15 +54006,15 @@ class FixedFactorConcentrationModel(ConcentrationModel): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - ion: "a NmlId (required)" = None, - resting_conc: "a Nml2Quantity_concentration (required)" = None, - decay_constant: "a Nml2Quantity_time (required)" = None, - rho: "a Nml2Quantity_rhoFactor (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + ion=None, + resting_conc=None, + decay_constant=None, + rho=None, gds_collector_=None, **kwargs_, ): @@ -54546,15 +54395,15 @@ class DecayingPoolConcentrationModel(ConcentrationModel): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - ion: "a NmlId (required)" = None, - resting_conc: "a Nml2Quantity_concentration (required)" = None, - decay_constant: "a Nml2Quantity_time (required)" = None, - shell_thickness: "a Nml2Quantity_length (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + ion=None, + resting_conc=None, + decay_constant=None, + shell_thickness=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -55049,24 +54898,24 @@ class IonChannel(IonChannelScalable): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - q10_conductance_scalings: "list of Q10ConductanceScaling(s) (optional)" = None, - species: "a NmlId (optional)" = None, - type: "a channelTypes (optional)" = None, - conductance: "a Nml2Quantity_conductance (optional)" = None, - gates: "list of GateHHUndetermined(s) (optional)" = None, - gate_hh_rates: "list of GateHHRates(s) (optional)" = None, - gate_h_hrates_taus: "list of GateHHRatesTau(s) (optional)" = None, - gate_hh_tau_infs: "list of GateHHTauInf(s) (optional)" = None, - gate_h_hrates_infs: "list of GateHHRatesInf(s) (optional)" = None, - gate_h_hrates_tau_infs: "list of GateHHRatesTauInf(s) (optional)" = None, - gate_hh_instantaneouses: "list of GateHHInstantaneous(s) (optional)" = None, - gate_fractionals: "list of GateFractional(s) (optional)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + q10_conductance_scalings=None, + species=None, + type=None, + conductance=None, + gates=None, + gate_hh_rates=None, + gate_h_hrates_taus=None, + gate_hh_tau_infs=None, + gate_h_hrates_infs=None, + gate_h_hrates_tau_infs=None, + gate_hh_instantaneouses=None, + gate_fractionals=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -55649,11 +55498,11 @@ class ConditionalDerivedVariable(NamedDimensionalVariable): def __init__( self, - name: "a string (required)" = None, - dimension: "a string (required)" = None, - description: "a string (optional)" = None, - exposure: "a string (optional)" = None, - Case: "list of Case(s) (required)" = None, + name=None, + dimension=None, + description=None, + exposure=None, + Case=None, gds_collector_=None, **kwargs_, ): @@ -55850,10 +55699,10 @@ class StateVariable(NamedDimensionalVariable): def __init__( self, - name: "a string (required)" = None, - dimension: "a string (required)" = None, - description: "a string (optional)" = None, - exposure: "a string (optional)" = None, + name=None, + dimension=None, + description=None, + exposure=None, gds_collector_=None, **kwargs_, ): @@ -56012,12 +55861,12 @@ class DerivedVariable(NamedDimensionalVariable): def __init__( self, - name: "a string (required)" = None, - dimension: "a string (required)" = None, - description: "a string (optional)" = None, - exposure: "a string (optional)" = None, - value: "a string (optional)" = None, - select: "a string (optional)" = None, + name=None, + dimension=None, + description=None, + exposure=None, + value=None, + select=None, gds_collector_=None, **kwargs_, ): @@ -56211,9 +56060,9 @@ class Requirement(NamedDimensionalType): def __init__( self, - name: "a string (required)" = None, - dimension: "a string (required)" = None, - description: "a string (optional)" = None, + name=None, + dimension=None, + description=None, gds_collector_=None, **kwargs_, ): @@ -56375,10 +56224,10 @@ class LEMS_Property(NamedDimensionalType): def __init__( self, - name: "a string (required)" = None, - dimension: "a string (required)" = None, - description: "a string (optional)" = None, - default_value: "a double (optional)" = None, + name=None, + dimension=None, + description=None, + default_value=None, gds_collector_=None, **kwargs_, ): @@ -56553,10 +56402,10 @@ class DerivedParameter(NamedDimensionalType): def __init__( self, - name: "a string (required)" = None, - dimension: "a string (required)" = None, - description: "a string (optional)" = None, - value: "a string (required)" = None, + name=None, + dimension=None, + description=None, + value=None, gds_collector_=None, **kwargs_, ): @@ -56738,9 +56587,9 @@ class Parameter(NamedDimensionalType): def __init__( self, - name: "a string (required)" = None, - dimension: "a string (required)" = None, - description: "a string (optional)" = None, + name=None, + dimension=None, + description=None, gds_collector_=None, **kwargs_, ): @@ -56896,13 +56745,13 @@ class AlphaCurrSynapse(BasePynnSynapse): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - tau_syn: "a float (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + tau_syn=None, gds_collector_=None, **kwargs_, ): @@ -57071,13 +56920,13 @@ class ExpCurrSynapse(BasePynnSynapse): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - tau_syn: "a float (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + tau_syn=None, gds_collector_=None, **kwargs_, ): @@ -57242,14 +57091,14 @@ class AlphaCondSynapse(BasePynnSynapse): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - tau_syn: "a float (required)" = None, - e_rev: "a float (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + tau_syn=None, + e_rev=None, gds_collector_=None, **kwargs_, ): @@ -57436,14 +57285,14 @@ class ExpCondSynapse(BasePynnSynapse): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - tau_syn: "a float (required)" = None, - e_rev: "a float (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + tau_syn=None, + e_rev=None, gds_collector_=None, **kwargs_, ): @@ -57668,26 +57517,26 @@ class HH_cond_exp(basePyNNCell): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - cm: "a float (required)" = None, - i_offset: "a float (required)" = None, - tau_syn_E: "a float (required)" = None, - tau_syn_I: "a float (required)" = None, - v_init: "a float (required)" = None, - v_offset: "a float (required)" = None, - e_rev_E: "a float (required)" = None, - e_rev_I: "a float (required)" = None, - e_rev_K: "a float (required)" = None, - e_rev_Na: "a float (required)" = None, - e_rev_leak: "a float (required)" = None, - g_leak: "a float (required)" = None, - gbar_K: "a float (required)" = None, - gbar_Na: "a float (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + cm=None, + i_offset=None, + tau_syn_E=None, + tau_syn_I=None, + v_init=None, + v_offset=None, + e_rev_E=None, + e_rev_I=None, + e_rev_K=None, + e_rev_Na=None, + e_rev_leak=None, + g_leak=None, + gbar_K=None, + gbar_Na=None, gds_collector_=None, **kwargs_, ): @@ -58028,22 +57877,22 @@ class basePyNNIaFCell(basePyNNCell): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - cm: "a float (required)" = None, - i_offset: "a float (required)" = None, - tau_syn_E: "a float (required)" = None, - tau_syn_I: "a float (required)" = None, - v_init: "a float (required)" = None, - tau_m: "a float (required)" = None, - tau_refrac: "a float (required)" = None, - v_reset: "a float (required)" = None, - v_rest: "a float (required)" = None, - v_thresh: "a float (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + cm=None, + i_offset=None, + tau_syn_E=None, + tau_syn_I=None, + v_init=None, + tau_m=None, + tau_refrac=None, + v_reset=None, + v_rest=None, + v_thresh=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -58317,16 +58166,16 @@ class ContinuousConnection(BaseConnectionNewFormat): def __init__( self, - id: "a NonNegativeInteger (required)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - pre_cell: "a string (required)" = None, - pre_segment: "a NonNegativeInteger (optional)" = "0", - pre_fraction_along: "a ZeroToOne (optional)" = "0.5", - post_cell: "a string (required)" = None, - post_segment: "a NonNegativeInteger (optional)" = "0", - post_fraction_along: "a ZeroToOne (optional)" = "0.5", - pre_component: "a NmlId (required)" = None, - post_component: "a NmlId (required)" = None, + id=None, + neuro_lex_id=None, + pre_cell=None, + pre_segment="0", + pre_fraction_along="0.5", + post_cell=None, + post_segment="0", + post_fraction_along="0.5", + pre_component=None, + post_component=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -58693,15 +58542,15 @@ class ElectricalConnection(BaseConnectionNewFormat): def __init__( self, - id: "a NonNegativeInteger (required)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - pre_cell: "a string (required)" = None, - pre_segment: "a NonNegativeInteger (optional)" = "0", - pre_fraction_along: "a ZeroToOne (optional)" = "0.5", - post_cell: "a string (required)" = None, - post_segment: "a NonNegativeInteger (optional)" = "0", - post_fraction_along: "a ZeroToOne (optional)" = "0.5", - synapse: "a NmlId (required)" = None, + id=None, + neuro_lex_id=None, + pre_cell=None, + pre_segment="0", + pre_fraction_along="0.5", + post_cell=None, + post_segment="0", + post_fraction_along="0.5", + synapse=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -59045,16 +58894,16 @@ class ConnectionWD(BaseConnectionOldFormat): def __init__( self, - id: "a NonNegativeInteger (required)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - pre_cell_id: "a Nml2PopulationReferencePath (required)" = None, - pre_segment_id: "a NonNegativeInteger (optional)" = "0", - pre_fraction_along: "a ZeroToOne (optional)" = "0.5", - post_cell_id: "a Nml2PopulationReferencePath (required)" = None, - post_segment_id: "a NonNegativeInteger (optional)" = "0", - post_fraction_along: "a ZeroToOne (optional)" = "0.5", - weight: "a float (required)" = None, - delay: "a Nml2Quantity_time (required)" = None, + id=None, + neuro_lex_id=None, + pre_cell_id=None, + pre_segment_id="0", + pre_fraction_along="0.5", + post_cell_id=None, + post_segment_id="0", + post_fraction_along="0.5", + weight=None, + delay=None, gds_collector_=None, **kwargs_, ): @@ -59402,14 +59251,14 @@ class Connection(BaseConnectionOldFormat): def __init__( self, - id: "a NonNegativeInteger (required)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - pre_cell_id: "a Nml2PopulationReferencePath (required)" = None, - pre_segment_id: "a NonNegativeInteger (optional)" = "0", - pre_fraction_along: "a ZeroToOne (optional)" = "0.5", - post_cell_id: "a Nml2PopulationReferencePath (required)" = None, - post_segment_id: "a NonNegativeInteger (optional)" = "0", - post_fraction_along: "a ZeroToOne (optional)" = "0.5", + id=None, + neuro_lex_id=None, + pre_cell_id=None, + pre_segment_id="0", + pre_fraction_along="0.5", + post_cell_id=None, + post_segment_id="0", + post_fraction_along="0.5", gds_collector_=None, **kwargs_, ): @@ -59655,16 +59504,16 @@ class ConcentrationModel_D(DecayingPoolConcentrationModel): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - ion: "a NmlId (required)" = None, - resting_conc: "a Nml2Quantity_concentration (required)" = None, - decay_constant: "a Nml2Quantity_time (required)" = None, - shell_thickness: "a Nml2Quantity_length (required)" = None, - type: "a string (required)" = "decayingPoolConcentrationModel", + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + ion=None, + resting_conc=None, + decay_constant=None, + shell_thickness=None, + type="decayingPoolConcentrationModel", gds_collector_=None, **kwargs_, ): @@ -59874,17 +59723,17 @@ class Cell2CaPools(Cell): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - morphology_attr: "a NmlId (optional)" = None, - biophysical_properties_attr: "a NmlId (optional)" = None, - morphology: "a Morphology (optional)" = None, - biophysical_properties: "a BiophysicalProperties (optional)" = None, - biophysical_properties2_ca_pools: "a BiophysicalProperties2CaPools (optional)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + morphology_attr=None, + biophysical_properties_attr=None, + morphology=None, + biophysical_properties=None, + biophysical_properties2_ca_pools=None, gds_collector_=None, **kwargs_, ): @@ -60133,24 +59982,24 @@ class HindmarshRose1984Cell(BaseCellMembPotCap): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - C: "a Nml2Quantity_capacitance (required)" = None, - a: "a Nml2Quantity_none (required)" = None, - b: "a Nml2Quantity_none (required)" = None, - c: "a Nml2Quantity_none (required)" = None, - d: "a Nml2Quantity_none (required)" = None, - s: "a Nml2Quantity_none (required)" = None, - x1: "a Nml2Quantity_none (required)" = None, - r: "a Nml2Quantity_none (required)" = None, - x0: "a Nml2Quantity_none (required)" = None, - y0: "a Nml2Quantity_none (required)" = None, - z0: "a Nml2Quantity_none (required)" = None, - v_scaling: "a Nml2Quantity_voltage (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + C=None, + a=None, + b=None, + c=None, + d=None, + s=None, + x1=None, + r=None, + x0=None, + y0=None, + z0=None, + v_scaling=None, gds_collector_=None, **kwargs_, ): @@ -60657,23 +60506,23 @@ class AdExIaFCell(BaseCellMembPotCap): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - C: "a Nml2Quantity_capacitance (required)" = None, - g_l: "a Nml2Quantity_conductance (required)" = None, - EL: "a Nml2Quantity_voltage (required)" = None, - reset: "a Nml2Quantity_voltage (required)" = None, - VT: "a Nml2Quantity_voltage (required)" = None, - thresh: "a Nml2Quantity_voltage (required)" = None, - del_t: "a Nml2Quantity_voltage (required)" = None, - tauw: "a Nml2Quantity_time (required)" = None, - refract: "a Nml2Quantity_time (required)" = None, - a: "a Nml2Quantity_conductance (required)" = None, - b: "a Nml2Quantity_current (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + C=None, + g_l=None, + EL=None, + reset=None, + VT=None, + thresh=None, + del_t=None, + tauw=None, + refract=None, + a=None, + b=None, gds_collector_=None, **kwargs_, ): @@ -61246,22 +61095,22 @@ class Izhikevich2007Cell(BaseCellMembPotCap): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - C: "a Nml2Quantity_capacitance (required)" = None, - v0: "a Nml2Quantity_voltage (required)" = None, - k: "a Nml2Quantity_conductancePerVoltage (required)" = None, - vr: "a Nml2Quantity_voltage (required)" = None, - vt: "a Nml2Quantity_voltage (required)" = None, - vpeak: "a Nml2Quantity_voltage (required)" = None, - a: "a Nml2Quantity_pertime (required)" = None, - b: "a Nml2Quantity_conductance (required)" = None, - c: "a Nml2Quantity_voltage (required)" = None, - d: "a Nml2Quantity_current (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + C=None, + v0=None, + k=None, + vr=None, + vt=None, + vpeak=None, + a=None, + b=None, + c=None, + d=None, gds_collector_=None, **kwargs_, ): @@ -61803,18 +61652,18 @@ class IafRefCell(IafCell): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - leak_reversal: "a Nml2Quantity_voltage (required)" = None, - thresh: "a Nml2Quantity_voltage (required)" = None, - reset: "a Nml2Quantity_voltage (required)" = None, - C: "a Nml2Quantity_capacitance (required)" = None, - leak_conductance: "a Nml2Quantity_conductance (required)" = None, - refract: "a Nml2Quantity_time (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + leak_reversal=None, + thresh=None, + reset=None, + C=None, + leak_conductance=None, + refract=None, gds_collector_=None, **kwargs_, ): @@ -62050,17 +61899,17 @@ class IafTauRefCell(IafTauCell): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - leak_reversal: "a Nml2Quantity_voltage (required)" = None, - thresh: "a Nml2Quantity_voltage (required)" = None, - reset: "a Nml2Quantity_voltage (required)" = None, - tau: "a Nml2Quantity_time (required)" = None, - refract: "a Nml2Quantity_time (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + leak_reversal=None, + thresh=None, + reset=None, + tau=None, + refract=None, gds_collector_=None, **kwargs_, ): @@ -62300,16 +62149,16 @@ class DoubleSynapse(BaseVoltageDepSynapse): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - synapse1: "a NmlId (required)" = None, - synapse2: "a NmlId (required)" = None, - synapse1_path: "a string (required)" = None, - synapse2_path: "a string (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + synapse1=None, + synapse2=None, + synapse1_path=None, + synapse2_path=None, gds_collector_=None, **kwargs_, ): @@ -62595,14 +62444,14 @@ class AlphaCurrentSynapse(BaseCurrentBasedSynapse): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - tau: "a Nml2Quantity_time (required)" = None, - ibase: "a Nml2Quantity_current (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + tau=None, + ibase=None, gds_collector_=None, **kwargs_, ): @@ -62905,15 +62754,15 @@ class BaseConductanceBasedSynapseTwo(BaseVoltageDepSynapse): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - gbase1: "a Nml2Quantity_conductance (required)" = None, - gbase2: "a Nml2Quantity_conductance (required)" = None, - erev: "a Nml2Quantity_voltage (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + gbase1=None, + gbase2=None, + erev=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -63270,14 +63119,14 @@ class BaseConductanceBasedSynapse(BaseVoltageDepSynapse): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - gbase: "a Nml2Quantity_conductance (required)" = None, - erev: "a Nml2Quantity_voltage (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + gbase=None, + erev=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -63604,25 +63453,25 @@ class IonChannelVShift(IonChannel): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - q10_conductance_scalings: "list of Q10ConductanceScaling(s) (optional)" = None, - species: "a NmlId (optional)" = None, - type: "a channelTypes (optional)" = None, - conductance: "a Nml2Quantity_conductance (optional)" = None, - gates: "list of GateHHUndetermined(s) (optional)" = None, - gate_hh_rates: "list of GateHHRates(s) (optional)" = None, - gate_h_hrates_taus: "list of GateHHRatesTau(s) (optional)" = None, - gate_hh_tau_infs: "list of GateHHTauInf(s) (optional)" = None, - gate_h_hrates_infs: "list of GateHHRatesInf(s) (optional)" = None, - gate_h_hrates_tau_infs: "list of GateHHRatesTauInf(s) (optional)" = None, - gate_hh_instantaneouses: "list of GateHHInstantaneous(s) (optional)" = None, - gate_fractionals: "list of GateFractional(s) (optional)" = None, - v_shift: "a Nml2Quantity_voltage (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + q10_conductance_scalings=None, + species=None, + type=None, + conductance=None, + gates=None, + gate_hh_rates=None, + gate_h_hrates_taus=None, + gate_hh_tau_infs=None, + gate_h_hrates_infs=None, + gate_h_hrates_tau_infs=None, + gate_hh_instantaneouses=None, + gate_fractionals=None, + v_shift=None, gds_collector_=None, **kwargs_, ): @@ -63866,24 +63715,24 @@ class IonChannelHH(IonChannel): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - q10_conductance_scalings: "list of Q10ConductanceScaling(s) (optional)" = None, - species: "a NmlId (optional)" = None, - type: "a channelTypes (optional)" = None, - conductance: "a Nml2Quantity_conductance (optional)" = None, - gates: "list of GateHHUndetermined(s) (optional)" = None, - gate_hh_rates: "list of GateHHRates(s) (optional)" = None, - gate_h_hrates_taus: "list of GateHHRatesTau(s) (optional)" = None, - gate_hh_tau_infs: "list of GateHHTauInf(s) (optional)" = None, - gate_h_hrates_infs: "list of GateHHRatesInf(s) (optional)" = None, - gate_h_hrates_tau_infs: "list of GateHHRatesTauInf(s) (optional)" = None, - gate_hh_instantaneouses: "list of GateHHInstantaneous(s) (optional)" = None, - gate_fractionals: "list of GateFractional(s) (optional)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + q10_conductance_scalings=None, + species=None, + type=None, + conductance=None, + gates=None, + gate_hh_rates=None, + gate_h_hrates_taus=None, + gate_hh_tau_infs=None, + gate_h_hrates_infs=None, + gate_h_hrates_tau_infs=None, + gate_hh_instantaneouses=None, + gate_fractionals=None, gds_collector_=None, **kwargs_, ): @@ -64080,22 +63929,22 @@ class IF_curr_exp(basePyNNIaFCell): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - cm: "a float (required)" = None, - i_offset: "a float (required)" = None, - tau_syn_E: "a float (required)" = None, - tau_syn_I: "a float (required)" = None, - v_init: "a float (required)" = None, - tau_m: "a float (required)" = None, - tau_refrac: "a float (required)" = None, - v_reset: "a float (required)" = None, - v_rest: "a float (required)" = None, - v_thresh: "a float (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + cm=None, + i_offset=None, + tau_syn_E=None, + tau_syn_I=None, + v_init=None, + tau_m=None, + tau_refrac=None, + v_reset=None, + v_rest=None, + v_thresh=None, gds_collector_=None, **kwargs_, ): @@ -64290,22 +64139,22 @@ class IF_curr_alpha(basePyNNIaFCell): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - cm: "a float (required)" = None, - i_offset: "a float (required)" = None, - tau_syn_E: "a float (required)" = None, - tau_syn_I: "a float (required)" = None, - v_init: "a float (required)" = None, - tau_m: "a float (required)" = None, - tau_refrac: "a float (required)" = None, - v_reset: "a float (required)" = None, - v_rest: "a float (required)" = None, - v_thresh: "a float (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + cm=None, + i_offset=None, + tau_syn_E=None, + tau_syn_I=None, + v_init=None, + tau_m=None, + tau_refrac=None, + v_reset=None, + v_rest=None, + v_thresh=None, gds_collector_=None, **kwargs_, ): @@ -64511,24 +64360,24 @@ class basePyNNIaFCondCell(basePyNNIaFCell): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - cm: "a float (required)" = None, - i_offset: "a float (required)" = None, - tau_syn_E: "a float (required)" = None, - tau_syn_I: "a float (required)" = None, - v_init: "a float (required)" = None, - tau_m: "a float (required)" = None, - tau_refrac: "a float (required)" = None, - v_reset: "a float (required)" = None, - v_rest: "a float (required)" = None, - v_thresh: "a float (required)" = None, - e_rev_E: "a float (required)" = None, - e_rev_I: "a float (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + cm=None, + i_offset=None, + tau_syn_E=None, + tau_syn_I=None, + v_init=None, + tau_m=None, + tau_refrac=None, + v_reset=None, + v_rest=None, + v_thresh=None, + e_rev_E=None, + e_rev_I=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -64761,16 +64610,16 @@ class ContinuousConnectionInstance(ContinuousConnection): def __init__( self, - id: "a NonNegativeInteger (required)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - pre_cell: "a string (required)" = None, - pre_segment: "a NonNegativeInteger (optional)" = "0", - pre_fraction_along: "a ZeroToOne (optional)" = "0.5", - post_cell: "a string (required)" = None, - post_segment: "a NonNegativeInteger (optional)" = "0", - post_fraction_along: "a ZeroToOne (optional)" = "0.5", - pre_component: "a NmlId (required)" = None, - post_component: "a NmlId (required)" = None, + id=None, + neuro_lex_id=None, + pre_cell=None, + pre_segment="0", + pre_fraction_along="0.5", + post_cell=None, + post_segment="0", + post_fraction_along="0.5", + pre_component=None, + post_component=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -64991,15 +64840,15 @@ class ElectricalConnectionInstance(ElectricalConnection): def __init__( self, - id: "a NonNegativeInteger (required)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - pre_cell: "a string (required)" = None, - pre_segment: "a NonNegativeInteger (optional)" = "0", - pre_fraction_along: "a ZeroToOne (optional)" = "0.5", - post_cell: "a string (required)" = None, - post_segment: "a NonNegativeInteger (optional)" = "0", - post_fraction_along: "a ZeroToOne (optional)" = "0.5", - synapse: "a NmlId (required)" = None, + id=None, + neuro_lex_id=None, + pre_cell=None, + pre_segment="0", + pre_fraction_along="0.5", + post_cell=None, + post_segment="0", + post_fraction_along="0.5", + synapse=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -65254,18 +65103,18 @@ class ExpThreeSynapse(BaseConductanceBasedSynapseTwo): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - gbase1: "a Nml2Quantity_conductance (required)" = None, - gbase2: "a Nml2Quantity_conductance (required)" = None, - erev: "a Nml2Quantity_voltage (required)" = None, - tau_decay1: "a Nml2Quantity_time (required)" = None, - tau_decay2: "a Nml2Quantity_time (required)" = None, - tau_rise: "a Nml2Quantity_time (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + gbase1=None, + gbase2=None, + erev=None, + tau_decay1=None, + tau_decay2=None, + tau_rise=None, gds_collector_=None, **kwargs_, ): @@ -65563,16 +65412,16 @@ class ExpTwoSynapse(BaseConductanceBasedSynapse): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - gbase: "a Nml2Quantity_conductance (required)" = None, - erev: "a Nml2Quantity_voltage (required)" = None, - tau_decay: "a Nml2Quantity_time (required)" = None, - tau_rise: "a Nml2Quantity_time (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + gbase=None, + erev=None, + tau_decay=None, + tau_rise=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -65854,15 +65703,15 @@ class ExpOneSynapse(BaseConductanceBasedSynapse): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - gbase: "a Nml2Quantity_conductance (required)" = None, - erev: "a Nml2Quantity_voltage (required)" = None, - tau_decay: "a Nml2Quantity_time (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + gbase=None, + erev=None, + tau_decay=None, gds_collector_=None, **kwargs_, ): @@ -66096,15 +65945,15 @@ class AlphaSynapse(BaseConductanceBasedSynapse): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - gbase: "a Nml2Quantity_conductance (required)" = None, - erev: "a Nml2Quantity_voltage (required)" = None, - tau: "a Nml2Quantity_time (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + gbase=None, + erev=None, + tau=None, gds_collector_=None, **kwargs_, ): @@ -66366,29 +66215,29 @@ class EIF_cond_exp_isfa_ista(basePyNNIaFCondCell): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - cm: "a float (required)" = None, - i_offset: "a float (required)" = None, - tau_syn_E: "a float (required)" = None, - tau_syn_I: "a float (required)" = None, - v_init: "a float (required)" = None, - tau_m: "a float (required)" = None, - tau_refrac: "a float (required)" = None, - v_reset: "a float (required)" = None, - v_rest: "a float (required)" = None, - v_thresh: "a float (required)" = None, - e_rev_E: "a float (required)" = None, - e_rev_I: "a float (required)" = None, - a: "a float (required)" = None, - b: "a float (required)" = None, - delta_T: "a float (required)" = None, - tau_w: "a float (required)" = None, - v_spike: "a float (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + cm=None, + i_offset=None, + tau_syn_E=None, + tau_syn_I=None, + v_init=None, + tau_m=None, + tau_refrac=None, + v_reset=None, + v_rest=None, + v_thresh=None, + e_rev_E=None, + e_rev_I=None, + a=None, + b=None, + delta_T=None, + tau_w=None, + v_spike=None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -66690,24 +66539,24 @@ class IF_cond_exp(basePyNNIaFCondCell): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - cm: "a float (required)" = None, - i_offset: "a float (required)" = None, - tau_syn_E: "a float (required)" = None, - tau_syn_I: "a float (required)" = None, - v_init: "a float (required)" = None, - tau_m: "a float (required)" = None, - tau_refrac: "a float (required)" = None, - v_reset: "a float (required)" = None, - v_rest: "a float (required)" = None, - v_thresh: "a float (required)" = None, - e_rev_E: "a float (required)" = None, - e_rev_I: "a float (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + cm=None, + i_offset=None, + tau_syn_E=None, + tau_syn_I=None, + v_init=None, + tau_m=None, + tau_refrac=None, + v_reset=None, + v_rest=None, + v_thresh=None, + e_rev_E=None, + e_rev_I=None, gds_collector_=None, **kwargs_, ): @@ -66908,24 +66757,24 @@ class IF_cond_alpha(basePyNNIaFCondCell): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - cm: "a float (required)" = None, - i_offset: "a float (required)" = None, - tau_syn_E: "a float (required)" = None, - tau_syn_I: "a float (required)" = None, - v_init: "a float (required)" = None, - tau_m: "a float (required)" = None, - tau_refrac: "a float (required)" = None, - v_reset: "a float (required)" = None, - v_rest: "a float (required)" = None, - v_thresh: "a float (required)" = None, - e_rev_E: "a float (required)" = None, - e_rev_I: "a float (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + cm=None, + i_offset=None, + tau_syn_E=None, + tau_syn_I=None, + v_init=None, + tau_m=None, + tau_refrac=None, + v_reset=None, + v_rest=None, + v_thresh=None, + e_rev_E=None, + e_rev_I=None, gds_collector_=None, **kwargs_, ): @@ -67106,17 +66955,17 @@ class ContinuousConnectionInstanceW(ContinuousConnectionInstance): def __init__( self, - id: "a NonNegativeInteger (required)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - pre_cell: "a string (required)" = None, - pre_segment: "a NonNegativeInteger (optional)" = "0", - pre_fraction_along: "a ZeroToOne (optional)" = "0.5", - post_cell: "a string (required)" = None, - post_segment: "a NonNegativeInteger (optional)" = "0", - post_fraction_along: "a ZeroToOne (optional)" = "0.5", - pre_component: "a NmlId (required)" = None, - post_component: "a NmlId (required)" = None, - weight: "a float (required)" = None, + id=None, + neuro_lex_id=None, + pre_cell=None, + pre_segment="0", + pre_fraction_along="0.5", + post_cell=None, + post_segment="0", + post_fraction_along="0.5", + pre_component=None, + post_component=None, + weight=None, gds_collector_=None, **kwargs_, ): @@ -67343,16 +67192,16 @@ class ElectricalConnectionInstanceW(ElectricalConnectionInstance): def __init__( self, - id: "a NonNegativeInteger (required)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - pre_cell: "a string (required)" = None, - pre_segment: "a NonNegativeInteger (optional)" = "0", - pre_fraction_along: "a ZeroToOne (optional)" = "0.5", - post_cell: "a string (required)" = None, - post_segment: "a NonNegativeInteger (optional)" = "0", - post_fraction_along: "a ZeroToOne (optional)" = "0.5", - synapse: "a NmlId (required)" = None, - weight: "a float (required)" = None, + id=None, + neuro_lex_id=None, + pre_cell=None, + pre_segment="0", + pre_fraction_along="0.5", + post_cell=None, + post_segment="0", + post_fraction_along="0.5", + synapse=None, + weight=None, gds_collector_=None, **kwargs_, ): @@ -67605,18 +67454,18 @@ class BlockingPlasticSynapse(ExpTwoSynapse): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - gbase: "a Nml2Quantity_conductance (required)" = None, - erev: "a Nml2Quantity_voltage (required)" = None, - tau_decay: "a Nml2Quantity_time (required)" = None, - tau_rise: "a Nml2Quantity_time (required)" = None, - plasticity_mechanism: "a PlasticityMechanism (optional)" = None, - block_mechanism: "a BlockMechanism (optional)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + gbase=None, + erev=None, + tau_decay=None, + tau_rise=None, + plasticity_mechanism=None, + block_mechanism=None, gds_collector_=None, **kwargs_, ): @@ -67894,29 +67743,29 @@ class EIF_cond_alpha_isfa_ista(EIF_cond_exp_isfa_ista): def __init__( self, - id: "a NmlId (required)" = None, - metaid: "a MetaId (optional)" = None, - notes: "a string (optional)" = None, - properties: "list of Property(s) (optional)" = None, - annotation: "a Annotation (optional)" = None, - neuro_lex_id: "a NeuroLexId (optional)" = None, - cm: "a float (required)" = None, - i_offset: "a float (required)" = None, - tau_syn_E: "a float (required)" = None, - tau_syn_I: "a float (required)" = None, - v_init: "a float (required)" = None, - tau_m: "a float (required)" = None, - tau_refrac: "a float (required)" = None, - v_reset: "a float (required)" = None, - v_rest: "a float (required)" = None, - v_thresh: "a float (required)" = None, - e_rev_E: "a float (required)" = None, - e_rev_I: "a float (required)" = None, - a: "a float (required)" = None, - b: "a float (required)" = None, - delta_T: "a float (required)" = None, - tau_w: "a float (required)" = None, - v_spike: "a float (required)" = None, + id=None, + metaid=None, + notes=None, + properties=None, + annotation=None, + neuro_lex_id=None, + cm=None, + i_offset=None, + tau_syn_E=None, + tau_syn_I=None, + v_init=None, + tau_m=None, + tau_refrac=None, + v_reset=None, + v_rest=None, + v_thresh=None, + e_rev_E=None, + e_rev_I=None, + a=None, + b=None, + delta_T=None, + tau_w=None, + v_spike=None, gds_collector_=None, **kwargs_, ): @@ -68363,7 +68212,6 @@ def main(): ("Annotation", "NeuroML_v2.3.2.xsd", "CT"), ("ComponentType", "NeuroML_v2.3.2.xsd", "CT"), ("Constant", "NeuroML_v2.3.2.xsd", "CT"), - ("Component", "NeuroML_v2.3.2.xsd", "CT"), ("Exposure", "NeuroML_v2.3.2.xsd", "CT"), ("NamedDimensionalType", "NeuroML_v2.3.2.xsd", "CT"), ("NamedDimensionalVariable", "NeuroML_v2.3.2.xsd", "CT"), @@ -68474,6 +68322,7 @@ def main(): ("ChannelDensityNonUniform", "NeuroML_v2.3.2.xsd", "CT"), ("ChannelDensityNonUniformNernst", "NeuroML_v2.3.2.xsd", "CT"), ("ChannelDensityNonUniformGHK", "NeuroML_v2.3.2.xsd", "CT"), + ("BaseChannelDensity", "NeuroML_v2.3.2.xsd", "CT"), ("ChannelDensity", "NeuroML_v2.3.2.xsd", "CT"), ("ChannelDensityVShift", "NeuroML_v2.3.2.xsd", "CT"), ("ChannelDensityNernst", "NeuroML_v2.3.2.xsd", "CT"), @@ -68573,6 +68422,7 @@ def main(): "Base", "BaseCell", "BaseCellMembPotCap", + "BaseChannelDensity", "BaseConductanceBasedSynapse", "BaseConductanceBasedSynapseTwo", "BaseConnection", @@ -68604,7 +68454,6 @@ def main(): "ChannelDensityVShift", "ChannelPopulation", "ClosedState", - "Component", "ComponentType", "CompoundInput", "CompoundInputDL", From cb299133c2470eabcd7a6491a938b0783740b83b Mon Sep 17 00:00:00 2001 From: "Ankur Sinha (Ankur Sinha Gmail)" Date: Wed, 2 Oct 2024 15:13:15 +0100 Subject: [PATCH 5/8] feat(nml): handle component types that use "any attributes" --- neuroml/nml/generatedssupersuper.py | 33 +++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/neuroml/nml/generatedssupersuper.py b/neuroml/nml/generatedssupersuper.py index 2753ece..e790cb6 100644 --- a/neuroml/nml/generatedssupersuper.py +++ b/neuroml/nml/generatedssupersuper.py @@ -6,6 +6,7 @@ Copyright 2023 NeuroML contributors """ +import inspect import logging import sys @@ -195,6 +196,38 @@ def component_factory(cls, component_type, validate=True, **kwargs): else: comp_type_class = getattr(module_object, component_type.__name__) + # handle Components that allow "anyAttributes_": these are included in + # the schema to allow use of user-defined Components + comp_type_class_atts = inspect.getmembers(comp_type_class, inspect.isroutine) + cls.logger.debug(f"Atts for {comp_type_class} are: {comp_type_class_atts}") + comp_type_class_members = comp_type_class._get_members() + + # if we do have an anyattribute, we need to split the kwargs into + # members and other bits that will populate the anyattribute because + # the anyattribute needs to be explicitly populated by us + for att in comp_type_class_atts: + atname = att[0] + if atname == "_exportAttributes": + new_comp_args = kwargs.copy() + member_args = {} + for m in comp_type_class_members: + try: + member_args[m.get_name()] = new_comp_args.pop(m.get_name()) + except KeyError: + cls.logger.error( + f"Error: {comp_type_class} requires {m.get_name()}" + ) + + # create new class with args that match members + comp = comp_type_class(**member_args) + # populate anyattributes with remaining kwargs + comp.anyAttributes_ = new_comp_args + logging.warning( + "New Component created. Note: This will NOT be validated against the schema." + ) + return comp + + # if it does not have an anyattribute, treat as general comp = comp_type_class(**kwargs) # handle component types that support __ANY__ From 5dd8527798ccd9a30851cae53336c20cfebaeb04 Mon Sep 17 00:00:00 2001 From: "Ankur Sinha (Ankur Sinha Gmail)" Date: Tue, 15 Oct 2024 15:36:38 +0100 Subject: [PATCH 6/8] chore: regen nml --- neuroml/nml/nml.py | 3071 +++++++++++++++++++++++--------------------- 1 file changed, 1635 insertions(+), 1436 deletions(-) diff --git a/neuroml/nml/nml.py b/neuroml/nml/nml.py index 5fb418b..0a39d27 100644 --- a/neuroml/nml/nml.py +++ b/neuroml/nml/nml.py @@ -2,7 +2,7 @@ # -*- coding: utf-8 -*- # -# Generated Wed Oct 2 12:35:48 2024 by generateDS.py version 2.44.1. +# Generated Tue Oct 15 15:36:13 2024 by generateDS.py version 2.44.1. # Python 3.11.10 (main, Sep 9 2024, 00:00:00) [GCC 14.2.1 20240801 (Red Hat 14.2.1-1)] # # Command line options: @@ -1354,17 +1354,17 @@ class ComponentType(GeneratedsSuper): def __init__( self, - name=None, - extends=None, - description=None, - Property=None, - Parameter=None, - DerivedParameter=None, - Constant=None, - Exposure=None, - Requirement=None, - InstanceRequirement=None, - Dynamics=None, + name: "a string (required)" = None, + extends: "a string (optional)" = None, + description: "a string (optional)" = None, + Property: "list of Property(s) (optional)" = None, + Parameter: "list of Parameter(s) (optional)" = None, + DerivedParameter: "list of DerivedParameter(s) (optional)" = None, + Constant: "list of Constant(s) (optional)" = None, + Exposure: "list of Exposure(s) (optional)" = None, + Requirement: "list of Requirement(s) (optional)" = None, + InstanceRequirement: "list of InstanceRequirement(s) (optional)" = None, + Dynamics: "list of Dynamics(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -1810,7 +1810,13 @@ class InstanceRequirement(GeneratedsSuper): subclass = None superclass = None - def __init__(self, name=None, type=None, gds_collector_=None, **kwargs_): + def __init__( + self, + name: "a string (required)" = None, + type: "a string (required)" = None, + gds_collector_=None, + **kwargs_, + ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -2092,14 +2098,14 @@ class Dynamics(GeneratedsSuper): def __init__( self, - StateVariable=None, - DerivedVariable=None, - ConditionalDerivedVariable=None, - TimeDerivative=None, - OnStart=None, - OnEvent=None, - OnCondition=None, - Regime=None, + StateVariable: "list of StateVariable(s) (optional)" = None, + DerivedVariable: "list of DerivedVariable(s) (optional)" = None, + ConditionalDerivedVariable: "list of ConditionalDerivedVariable(s) (optional)" = None, + TimeDerivative: "list of TimeDerivative(s) (optional)" = None, + OnStart: "a OnStart (optional)" = None, + OnEvent: "list of OnEvent(s) (optional)" = None, + OnCondition: "list of OnCondition(s) (optional)" = None, + Regime: "list of Regime(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -2477,7 +2483,13 @@ class Case(GeneratedsSuper): subclass = None superclass = None - def __init__(self, condition=None, value=None, gds_collector_=None, **kwargs_): + def __init__( + self, + condition: "a string (optional)" = None, + value: "a string (required)" = None, + gds_collector_=None, + **kwargs_, + ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -2651,7 +2663,13 @@ class TimeDerivative(GeneratedsSuper): subclass = None superclass = None - def __init__(self, variable=None, value=None, gds_collector_=None, **kwargs_): + def __init__( + self, + variable: "a string (required)" = None, + value: "a string (required)" = None, + gds_collector_=None, + **kwargs_, + ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -2839,7 +2857,12 @@ class OnStart(GeneratedsSuper): subclass = None superclass = None - def __init__(self, StateAssignment=None, gds_collector_=None, **kwargs_): + def __init__( + self, + StateAssignment: "list of StateAssignment(s) (required)" = None, + gds_collector_=None, + **kwargs_, + ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -3004,7 +3027,13 @@ class StateAssignment(GeneratedsSuper): subclass = None superclass = None - def __init__(self, variable=None, value=None, gds_collector_=None, **kwargs_): + def __init__( + self, + variable: "a string (required)" = None, + value: "a string (required)" = None, + gds_collector_=None, + **kwargs_, + ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -3208,9 +3237,9 @@ class OnEvent(GeneratedsSuper): def __init__( self, - port=None, - StateAssignment=None, - EventOut=None, + port: "a string (required)" = None, + StateAssignment: "list of StateAssignment(s) (optional)" = None, + EventOut: "list of EventOut(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -3422,7 +3451,9 @@ class EventOut(GeneratedsSuper): subclass = None superclass = None - def __init__(self, port=None, gds_collector_=None, **kwargs_): + def __init__( + self, port: "a string (required)" = None, gds_collector_=None, **kwargs_ + ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -3612,10 +3643,10 @@ class OnCondition(GeneratedsSuper): def __init__( self, - test=None, - StateAssignment=None, - EventOut=None, - Transition=None, + test: "a string (required)" = None, + StateAssignment: "list of StateAssignment(s) (optional)" = None, + EventOut: "list of EventOut(s) (optional)" = None, + Transition: "a Transition (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -3858,7 +3889,9 @@ class Transition(GeneratedsSuper): subclass = None superclass = None - def __init__(self, regime=None, gds_collector_=None, **kwargs_): + def __init__( + self, regime: "a string (required)" = None, gds_collector_=None, **kwargs_ + ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -4046,11 +4079,11 @@ class Regime(GeneratedsSuper): def __init__( self, - name=None, - initial=None, - TimeDerivative=None, - OnEntry=None, - OnCondition=None, + name: "a string (required)" = None, + initial: "a TrueOrFalse (optional)" = None, + TimeDerivative: "list of TimeDerivative(s) (optional)" = None, + OnEntry: "a OnEntry (optional)" = None, + OnCondition: "list of OnCondition(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -4348,7 +4381,12 @@ class OnEntry(GeneratedsSuper): subclass = None superclass = None - def __init__(self, StateAssignment=None, gds_collector_=None, **kwargs_): + def __init__( + self, + StateAssignment: "list of StateAssignment(s) (required)" = None, + gds_collector_=None, + **kwargs_, + ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -4510,7 +4548,9 @@ class IncludeType(GeneratedsSuper): subclass = None superclass = None - def __init__(self, href=None, gds_collector_=None, **kwargs_): + def __init__( + self, href: "a anyURI (required)" = None, gds_collector_=None, **kwargs_ + ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -4687,10 +4727,10 @@ class Q10Settings(GeneratedsSuper): def __init__( self, - type=None, - fixed_q10=None, - q10_factor=None, - experimental_temp=None, + type: "a NmlId (required)" = None, + fixed_q10: "a Nml2Quantity_none (optional)" = None, + q10_factor: "a Nml2Quantity_none (optional)" = None, + experimental_temp: "a Nml2Quantity_temperature (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -5050,9 +5090,9 @@ class VariableParameter(GeneratedsSuper): def __init__( self, - parameter=None, - segment_groups=None, - inhomogeneous_value=None, + parameter: "a string (required)" = None, + segment_groups: "a string (required)" = None, + inhomogeneous_value: "a InhomogeneousValue (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -5426,7 +5466,13 @@ class BaseNonNegativeIntegerId(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__(self, id=None, extensiontype_=None, gds_collector_=None, **kwargs_): + def __init__( + self, + id: "a NmlId (required)" = None, + extensiontype_=None, + gds_collector_=None, + **kwargs_, + ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -5647,7 +5693,13 @@ class Base(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__(self, id=None, extensiontype_=None, gds_collector_=None, **kwargs_): + def __init__( + self, + id: "a NmlId (required)" = None, + extensiontype_=None, + gds_collector_=None, + **kwargs_, + ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -5890,11 +5942,11 @@ class Standalone(Base): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -6251,14 +6303,14 @@ class SpikeSourcePoisson(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - start=None, - duration=None, - rate=None, + id: "a NonNegativeInteger (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + start: "a Nml2Quantity_time (required)" = None, + duration: "a Nml2Quantity_time (required)" = None, + rate: "a Nml2Quantity_pertime (required)" = None, gds_collector_=None, **kwargs_, ): @@ -6588,11 +6640,11 @@ class Input(BaseNonNegativeIntegerId): def __init__( self, - id=None, - target=None, - destination=None, - segment_id=None, - fraction_along=None, + id: "a NonNegativeInteger (required)" = None, + target: "a Nml2PopulationReferencePath (required)" = None, + destination: "a NmlId (required)" = None, + segment_id: "a NonNegativeInteger (optional)" = None, + fraction_along: "a ZeroToOne (optional)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -7037,11 +7089,11 @@ class InputList(Base): def __init__( self, - id=None, - populations=None, - component=None, - input=None, - input_ws=None, + id: "a NonNegativeInteger (required)" = None, + populations: "a NmlId (required)" = None, + component: "a NmlId (required)" = None, + input: "list of Input(s) (optional)" = None, + input_ws: "list of InputW(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -7402,7 +7454,12 @@ class ExplicitInput(BaseWithoutId): superclass = BaseWithoutId def __init__( - self, target=None, input=None, destination=None, gds_collector_=None, **kwargs_ + self, + target: "a Nml2PopulationReferencePath (required)" = None, + input: "a NmlId (required)" = None, + destination: "a NmlId (optional)" = None, + gds_collector_=None, + **kwargs_, ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -7764,8 +7821,8 @@ class BaseConnection(BaseNonNegativeIntegerId): def __init__( self, - id=None, - neuro_lex_id=None, + id: "a NmlId (required)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -8007,9 +8064,9 @@ class BaseProjection(Base): def __init__( self, - id=None, - presynaptic_population=None, - postsynaptic_population=None, + id: "a NmlId (required)" = None, + presynaptic_population: "a NmlId (required)" = None, + postsynaptic_population: "a NmlId (required)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -8293,11 +8350,11 @@ class SynapticConnection(BaseWithoutId): def __init__( self, - neuro_lex_id=None, - from_=None, - to=None, - synapse=None, - destination=None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + from_: "a Nml2PopulationReferencePath (required)" = None, + to: "a Nml2PopulationReferencePath (required)" = None, + synapse: "a NmlId (required)" = None, + destination: "a NmlId (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -8707,7 +8764,12 @@ class CellSet(Base): superclass = Base def __init__( - self, id=None, select=None, anytypeobjs_=None, gds_collector_=None, **kwargs_ + self, + id: "a NmlId (required)" = None, + select: "a string (required)" = None, + anytypeobjs_=None, + gds_collector_=None, + **kwargs_, ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -8899,7 +8961,14 @@ class Location(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__(self, x=None, y=None, z=None, gds_collector_=None, **kwargs_): + def __init__( + self, + x: "a float (required)" = None, + y: "a float (required)" = None, + z: "a float (required)" = None, + gds_collector_=None, + **kwargs_, + ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -9117,11 +9186,11 @@ class Instance(BaseWithoutId): def __init__( self, - id=None, - i=None, - j=None, - k=None, - location=None, + id: "a nonNegativeInteger (optional)" = None, + i: "a nonNegativeInteger (optional)" = None, + j: "a nonNegativeInteger (optional)" = None, + k: "a nonNegativeInteger (optional)" = None, + location: "a Location (required)" = None, gds_collector_=None, **kwargs_, ): @@ -9381,7 +9450,12 @@ class GridLayout(BaseWithoutId): superclass = BaseWithoutId def __init__( - self, x_size=None, y_size=None, z_size=None, gds_collector_=None, **kwargs_ + self, + x_size: "a nonNegativeInteger (optional)" = None, + y_size: "a nonNegativeInteger (optional)" = None, + z_size: "a nonNegativeInteger (optional)" = None, + gds_collector_=None, + **kwargs_, ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -9578,7 +9652,13 @@ class RandomLayout(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__(self, number=None, regions=None, gds_collector_=None, **kwargs_): + def __init__( + self, + number: "a nonNegativeInteger (optional)" = None, + regions: "a NmlId (optional)" = None, + gds_collector_=None, + **kwargs_, + ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -9800,7 +9880,12 @@ class UnstructuredLayout(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__(self, number=None, gds_collector_=None, **kwargs_): + def __init__( + self, + number: "a nonNegativeInteger (optional)" = None, + gds_collector_=None, + **kwargs_, + ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -9996,10 +10081,10 @@ class Layout(BaseWithoutId): def __init__( self, - spaces=None, - random=None, - grid=None, - unstructured=None, + spaces: "a NmlId (optional)" = None, + random: "a RandomLayout (required)" = None, + grid: "a GridLayout (required)" = None, + unstructured: "a UnstructuredLayout (required)" = None, gds_collector_=None, **kwargs_, ): @@ -10326,18 +10411,18 @@ class Population(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - component=None, - size=None, - type=None, - extracellular_properties=None, - neuro_lex_id=None, - layout=None, - instances=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + component: "a NmlId (required)" = None, + size: "a NonNegativeInteger (optional)" = None, + type: "a populationTypes (optional)" = None, + extracellular_properties: "a NmlId (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + layout: "a Layout (optional)" = None, + instances: "list of Instance(s) (required)" = None, gds_collector_=None, **kwargs_, ): @@ -10836,7 +10921,12 @@ class Region(Base): superclass = Base def __init__( - self, id=None, spaces=None, anytypeobjs_=None, gds_collector_=None, **kwargs_ + self, + id: "a NmlId (required)" = None, + spaces: "a NmlId (optional)" = None, + anytypeobjs_=None, + gds_collector_=None, + **kwargs_, ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -11065,12 +11155,12 @@ class SpaceStructure(BaseWithoutId): def __init__( self, - x_spacing=None, - y_spacing=None, - z_spacing=None, - x_start=0, - y_start=0, - z_start=0, + x_spacing: "a float (optional)" = None, + y_spacing: "a float (optional)" = None, + z_spacing: "a float (optional)" = None, + x_start: "a float (optional)" = 0, + y_start: "a float (optional)" = 0, + z_start: "a float (optional)" = 0, gds_collector_=None, **kwargs_, ): @@ -11329,7 +11419,12 @@ class Space(Base): superclass = Base def __init__( - self, id=None, based_on=None, structure=None, gds_collector_=None, **kwargs_ + self, + id: "a NmlId (required)" = None, + based_on: "a allowedSpaces (optional)" = None, + structure: "a SpaceStructure (optional)" = None, + gds_collector_=None, + **kwargs_, ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -11715,25 +11810,25 @@ class Network(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - type=None, - temperature=None, - neuro_lex_id=None, - spaces=None, - regions=None, - extracellular_properties=None, - populations=None, - cell_sets=None, - synaptic_connections=None, - projections=None, - electrical_projections=None, - continuous_projections=None, - explicit_inputs=None, - input_lists=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + type: "a networkTypes (optional)" = None, + temperature: "a Nml2Quantity_temperature (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + spaces: "list of Space(s) (optional)" = None, + regions: "list of Region(s) (optional)" = None, + extracellular_properties: "list of ExtracellularPropertiesLocal(s) (optional)" = None, + populations: "list of Population(s) (required)" = None, + cell_sets: "list of CellSet(s) (optional)" = None, + synaptic_connections: "list of SynapticConnection(s) (optional)" = None, + projections: "list of Projection(s) (optional)" = None, + electrical_projections: "list of ElectricalProjection(s) (optional)" = None, + continuous_projections: "list of ContinuousProjection(s) (optional)" = None, + explicit_inputs: "list of ExplicitInput(s) (optional)" = None, + input_lists: "list of InputList(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -12470,16 +12565,16 @@ class TransientPoissonFiringSynapse(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - average_rate=None, - delay=None, - duration=None, - synapse=None, - spike_target=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + average_rate: "a Nml2Quantity_pertime (required)" = None, + delay: "a Nml2Quantity_time (required)" = None, + duration: "a Nml2Quantity_time (required)" = None, + synapse: "a string (required)" = None, + spike_target: "a string (required)" = None, gds_collector_=None, **kwargs_, ): @@ -12856,14 +12951,14 @@ class PoissonFiringSynapse(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - average_rate=None, - synapse=None, - spike_target=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + average_rate: "a Nml2Quantity_pertime (required)" = None, + synapse: "a string (required)" = None, + spike_target: "a string (required)" = None, gds_collector_=None, **kwargs_, ): @@ -13143,12 +13238,12 @@ class SpikeGeneratorPoisson(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - average_rate=None, + id: "a NonNegativeInteger (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + average_rate: "a Nml2Quantity_pertime (required)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -13405,13 +13500,13 @@ class SpikeGeneratorRandom(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - max_isi=None, - min_isi=None, + id: "a NonNegativeInteger (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + max_isi: "a Nml2Quantity_time (required)" = None, + min_isi: "a Nml2Quantity_time (required)" = None, gds_collector_=None, **kwargs_, ): @@ -13670,12 +13765,12 @@ class SpikeGenerator(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - period=None, + id: "a NonNegativeInteger (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + period: "a Nml2Quantity_time (required)" = None, gds_collector_=None, **kwargs_, ): @@ -13910,14 +14005,14 @@ class TimedSynapticInput(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - synapse=None, - spike_target=None, - spikes=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + synapse: "a NmlId (required)" = None, + spike_target: "a string (required)" = None, + spikes: "list of Spike(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -14201,12 +14296,12 @@ class SpikeArray(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - spikes=None, + id: "a NonNegativeInteger (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + spikes: "list of Spike(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -14395,7 +14490,13 @@ class Spike(BaseNonNegativeIntegerId): subclass = None superclass = BaseNonNegativeIntegerId - def __init__(self, id=None, time=None, gds_collector_=None, **kwargs_): + def __init__( + self, + id: "a NonNegativeInteger (required)" = None, + time: "a Nml2Quantity_time (required)" = None, + gds_collector_=None, + **kwargs_, + ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -14655,18 +14756,18 @@ class VoltageClampTriple(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - active=None, - delay=None, - duration=None, - conditioning_voltage=None, - testing_voltage=None, - return_voltage=None, - simple_series_resistance=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + active: "a ZeroOrOne (required)" = None, + delay: "a Nml2Quantity_time (required)" = None, + duration: "a Nml2Quantity_time (required)" = None, + conditioning_voltage: "a Nml2Quantity_voltage (required)" = None, + testing_voltage: "a Nml2Quantity_voltage (required)" = None, + return_voltage: "a Nml2Quantity_voltage (required)" = None, + simple_series_resistance: "a Nml2Quantity_resistance (required)" = None, gds_collector_=None, **kwargs_, ): @@ -15185,15 +15286,15 @@ class VoltageClamp(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - delay=None, - duration=None, - target_voltage=None, - simple_series_resistance=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + delay: "a Nml2Quantity_time (required)" = None, + duration: "a Nml2Quantity_time (required)" = None, + target_voltage: "a Nml2Quantity_voltage (required)" = None, + simple_series_resistance: "a Nml2Quantity_resistance (required)" = None, gds_collector_=None, **kwargs_, ): @@ -15599,14 +15700,14 @@ class CompoundInputDL(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - pulse_generator_dls=None, - sine_generator_dls=None, - ramp_generator_dls=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + pulse_generator_dls: "list of PulseGeneratorDL(s) (optional)" = None, + sine_generator_dls: "list of SineGeneratorDL(s) (optional)" = None, + ramp_generator_dls: "list of RampGeneratorDL(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -15905,14 +16006,14 @@ class CompoundInput(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - pulse_generators=None, - sine_generators=None, - ramp_generators=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + pulse_generators: "list of PulseGenerator(s) (optional)" = None, + sine_generators: "list of SineGenerator(s) (optional)" = None, + ramp_generators: "list of RampGenerator(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -16207,16 +16308,16 @@ class RampGeneratorDL(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - delay=None, - duration=None, - start_amplitude=None, - finish_amplitude=None, - baseline_amplitude=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + delay: "a Nml2Quantity_time (required)" = None, + duration: "a Nml2Quantity_time (required)" = None, + start_amplitude: "a Nml2Quantity_current (required)" = None, + finish_amplitude: "a Nml2Quantity_current (required)" = None, + baseline_amplitude: "a Nml2Quantity_current (required)" = None, gds_collector_=None, **kwargs_, ): @@ -16626,16 +16727,16 @@ class RampGenerator(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - delay=None, - duration=None, - start_amplitude=None, - finish_amplitude=None, - baseline_amplitude=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + delay: "a Nml2Quantity_time (required)" = None, + duration: "a Nml2Quantity_time (required)" = None, + start_amplitude: "a Nml2Quantity_current (required)" = None, + finish_amplitude: "a Nml2Quantity_current (required)" = None, + baseline_amplitude: "a Nml2Quantity_current (required)" = None, gds_collector_=None, **kwargs_, ): @@ -17039,16 +17140,16 @@ class SineGeneratorDL(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - delay=None, - phase=None, - duration=None, - amplitude=None, - period=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + delay: "a Nml2Quantity_time (required)" = None, + phase: "a Nml2Quantity_none (required)" = None, + duration: "a Nml2Quantity_time (required)" = None, + amplitude: "a Nml2Quantity_current (required)" = None, + period: "a Nml2Quantity_time (required)" = None, gds_collector_=None, **kwargs_, ): @@ -17430,16 +17531,16 @@ class SineGenerator(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - delay=None, - phase=None, - duration=None, - amplitude=None, - period=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + delay: "a Nml2Quantity_time (required)" = None, + phase: "a Nml2Quantity_none (required)" = None, + duration: "a Nml2Quantity_time (required)" = None, + amplitude: "a Nml2Quantity_current (required)" = None, + period: "a Nml2Quantity_time (required)" = None, gds_collector_=None, **kwargs_, ): @@ -17843,14 +17944,14 @@ class PulseGeneratorDL(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - delay=None, - duration=None, - amplitude=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + delay: "a Nml2Quantity_time (required)" = None, + duration: "a Nml2Quantity_time (required)" = None, + amplitude: "a Nml2Quantity_current (required)" = None, gds_collector_=None, **kwargs_, ): @@ -18180,14 +18281,14 @@ class PulseGenerator(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - delay=None, - duration=None, - amplitude=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + delay: "a Nml2Quantity_time (required)" = None, + duration: "a Nml2Quantity_time (required)" = None, + amplitude: "a Nml2Quantity_current (required)" = None, gds_collector_=None, **kwargs_, ): @@ -18491,9 +18592,9 @@ class ReactionScheme(Base): def __init__( self, - id=None, - source=None, - type=None, + id: "a NmlId (required)" = None, + source: "a string (required)" = None, + type: "a string (required)" = None, anytypeobjs_=None, gds_collector_=None, **kwargs_, @@ -18712,7 +18813,13 @@ class ExtracellularPropertiesLocal(Base): subclass = None superclass = Base - def __init__(self, id=None, species=None, gds_collector_=None, **kwargs_): + def __init__( + self, + id: "a NmlId (required)" = None, + species: "list of Species(s) (optional)" = None, + gds_collector_=None, + **kwargs_, + ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -18923,7 +19030,13 @@ class ExtracellularProperties(Base): subclass = None superclass = Base - def __init__(self, id=None, species=None, gds_collector_=None, **kwargs_): + def __init__( + self, + id: "a NmlId (required)" = None, + species: "list of Species(s) (optional)" = None, + gds_collector_=None, + **kwargs_, + ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -19146,8 +19259,8 @@ class IntracellularProperties(BaseWithoutId): def __init__( self, - species=None, - resistivities=None, + species: "list of Species(s) (optional)" = None, + resistivities: "list of Resistivity(s) (optional)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -19436,12 +19549,12 @@ class Species(Base): def __init__( self, - id=None, - concentration_model=None, - ion=None, - initial_concentration=None, - initial_ext_concentration=None, - segment_groups="all", + id: "a NmlId (required)" = None, + concentration_model: "a NmlId (required)" = None, + ion: "a NmlId (optional)" = None, + initial_concentration: "a Nml2Quantity_concentration (required)" = None, + initial_ext_concentration: "a Nml2Quantity_concentration (required)" = None, + segment_groups: "a NmlId (optional)" = "all", gds_collector_=None, **kwargs_, ): @@ -19799,7 +19912,11 @@ class InhomogeneousValue(BaseWithoutId): superclass = BaseWithoutId def __init__( - self, inhomogeneous_parameters=None, value=None, gds_collector_=None, **kwargs_ + self, + inhomogeneous_parameters: "a string (required)" = None, + value: "a string (required)" = None, + gds_collector_=None, + **kwargs_, ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -20036,12 +20153,12 @@ class ChannelDensityGHK2(Base): def __init__( self, - id=None, - ion_channel=None, - cond_density=None, - segment_groups="all", - segments=None, - ion=None, + id: "a NmlId (required)" = None, + ion_channel: "a NmlId (required)" = None, + cond_density: "a Nml2Quantity_conductanceDensity (optional)" = None, + segment_groups: "a NmlId (optional)" = "all", + segments: "a NonNegativeInteger (optional)" = None, + ion: "a NmlId (required)" = None, gds_collector_=None, **kwargs_, ): @@ -20409,12 +20526,12 @@ class ChannelDensityGHK(Base): def __init__( self, - id=None, - ion_channel=None, - permeability=None, - segment_groups="all", - segments=None, - ion=None, + id: "a NmlId (required)" = None, + ion_channel: "a NmlId (required)" = None, + permeability: "a Nml2Quantity_permeability (required)" = None, + segment_groups: "a NmlId (optional)" = "all", + segments: "a NonNegativeInteger (optional)" = None, + ion: "a NmlId (required)" = None, gds_collector_=None, **kwargs_, ): @@ -20791,13 +20908,13 @@ class ChannelDensityNernst(Base): def __init__( self, - id=None, - ion_channel=None, - cond_density=None, - segment_groups="all", - segments=None, - ion=None, - variable_parameters=None, + id: "a NmlId (required)" = None, + ion_channel: "a NmlId (required)" = None, + cond_density: "a Nml2Quantity_conductanceDensity (optional)" = None, + segment_groups: "a NmlId (optional)" = "all", + segments: "a NonNegativeInteger (optional)" = None, + ion: "a NmlId (required)" = None, + variable_parameters: "list of VariableParameter(s) (optional)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -21245,14 +21362,14 @@ class ChannelDensity(Base): def __init__( self, - id=None, - ion_channel=None, - cond_density=None, - erev=None, - segment_groups="all", - segments=None, - ion=None, - variable_parameters=None, + id: "a NmlId (required)" = None, + ion_channel: "a NmlId (required)" = None, + cond_density: "a Nml2Quantity_conductanceDensity (optional)" = None, + erev: "a Nml2Quantity_voltage (required)" = None, + segment_groups: "a NmlId (optional)" = "all", + segments: "a NonNegativeInteger (optional)" = None, + ion: "a NmlId (required)" = None, + variable_parameters: "list of VariableParameter(s) (optional)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -21719,7 +21836,12 @@ class BaseChannelDensity(Base): superclass = Base def __init__( - self, id=None, ion_channel=None, type=None, gds_collector_=None, **kwargs_ + self, + id: "a NmlId (required)" = None, + ion_channel: "a NmlId (required)" = None, + type: "a NmlId (required)" = None, + gds_collector_=None, + **kwargs_, ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -22039,10 +22161,10 @@ class ChannelDensityNonUniformGHK(Base): def __init__( self, - id=None, - ion_channel=None, - ion=None, - variable_parameters=None, + id: "a NmlId (required)" = None, + ion_channel: "a NmlId (required)" = None, + ion: "a NmlId (required)" = None, + variable_parameters: "list of VariableParameter(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -22342,10 +22464,10 @@ class ChannelDensityNonUniformNernst(Base): def __init__( self, - id=None, - ion_channel=None, - ion=None, - variable_parameters=None, + id: "a NmlId (required)" = None, + ion_channel: "a NmlId (required)" = None, + ion: "a NmlId (required)" = None, + variable_parameters: "list of VariableParameter(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -22656,11 +22778,11 @@ class ChannelDensityNonUniform(Base): def __init__( self, - id=None, - ion_channel=None, - erev=None, - ion=None, - variable_parameters=None, + id: "a NmlId (required)" = None, + ion_channel: "a NmlId (required)" = None, + erev: "a Nml2Quantity_voltage (required)" = None, + ion: "a NmlId (required)" = None, + variable_parameters: "list of VariableParameter(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -23039,14 +23161,14 @@ class ChannelPopulation(Base): def __init__( self, - id=None, - ion_channel=None, - number=None, - erev=None, - segment_groups="all", - segments=None, - ion=None, - variable_parameters=None, + id: "a NmlId (required)" = None, + ion_channel: "a NmlId (required)" = None, + number: "a NonNegativeInteger (required)" = None, + erev: "a Nml2Quantity_voltage (required)" = None, + segment_groups: "a NmlId (optional)" = "all", + segments: "a NonNegativeInteger (optional)" = None, + ion: "a NmlId (required)" = None, + variable_parameters: "list of VariableParameter(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -23476,7 +23598,11 @@ class Resistivity(BaseWithoutId): superclass = BaseWithoutId def __init__( - self, value=None, segment_groups="all", gds_collector_=None, **kwargs_ + self, + value: "a Nml2Quantity_resistivity (required)" = None, + segment_groups: "a NmlId (optional)" = "all", + gds_collector_=None, + **kwargs_, ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -23755,7 +23881,11 @@ class InitMembPotential(BaseWithoutId): superclass = BaseWithoutId def __init__( - self, value=None, segment_groups="all", gds_collector_=None, **kwargs_ + self, + value: "a Nml2Quantity_voltage (required)" = None, + segment_groups: "a NmlId (optional)" = "all", + gds_collector_=None, + **kwargs_, ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -24046,7 +24176,11 @@ class SpecificCapacitance(BaseWithoutId): superclass = BaseWithoutId def __init__( - self, value=None, segment_groups="all", gds_collector_=None, **kwargs_ + self, + value: "a Nml2Quantity_specificCapacitance (required)" = None, + segment_groups: "a NmlId (optional)" = "all", + gds_collector_=None, + **kwargs_, ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -24337,7 +24471,11 @@ class SpikeThresh(BaseWithoutId): superclass = BaseWithoutId def __init__( - self, value=None, segment_groups="all", gds_collector_=None, **kwargs_ + self, + value: "a Nml2Quantity_voltage (required)" = None, + segment_groups: "a NmlId (optional)" = "all", + gds_collector_=None, + **kwargs_, ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -24771,19 +24909,19 @@ class MembraneProperties(BaseWithoutId): def __init__( self, - channel_populations=None, - baseChannelDensity=None, - channel_densities=None, - channel_density_v_shifts=None, - channel_density_nernsts=None, - channel_density_ghks=None, - channel_density_ghk2s=None, - channel_density_non_uniforms=None, - channel_density_non_uniform_nernsts=None, - channel_density_non_uniform_ghks=None, - spike_threshes=None, - specific_capacitances=None, - init_memb_potentials=None, + channel_populations: "list of ChannelPopulation(s) (optional)" = None, + baseChannelDensity: "list of BaseChannelDensity(s) (optional)" = None, + channel_densities: "list of ChannelDensity(s) (optional)" = None, + channel_density_v_shifts: "list of ChannelDensityVShift(s) (optional)" = None, + channel_density_nernsts: "list of ChannelDensityNernst(s) (optional)" = None, + channel_density_ghks: "list of ChannelDensityGHK(s) (optional)" = None, + channel_density_ghk2s: "list of ChannelDensityGHK2(s) (optional)" = None, + channel_density_non_uniforms: "list of ChannelDensityNonUniform(s) (optional)" = None, + channel_density_non_uniform_nernsts: "list of ChannelDensityNonUniformNernst(s) (optional)" = None, + channel_density_non_uniform_ghks: "list of ChannelDensityNonUniformGHK(s) (optional)" = None, + spike_threshes: "list of SpikeThresh(s) (required)" = None, + specific_capacitances: "list of SpecificCapacitance(s) (required)" = None, + init_memb_potentials: "list of InitMembPotential(s) (required)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -25440,14 +25578,14 @@ class BiophysicalProperties2CaPools(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - membrane_properties2_ca_pools=None, - intracellular_properties2_ca_pools=None, - extracellular_properties=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + membrane_properties2_ca_pools: "a MembraneProperties2CaPools (required)" = None, + intracellular_properties2_ca_pools: "a IntracellularProperties2CaPools (optional)" = None, + extracellular_properties: "a ExtracellularProperties (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -25753,14 +25891,14 @@ class BiophysicalProperties(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - membrane_properties=None, - intracellular_properties=None, - extracellular_properties=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + membrane_properties: "a MembraneProperties (required)" = None, + intracellular_properties: "a IntracellularProperties (optional)" = None, + extracellular_properties: "a ExtracellularProperties (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -26025,7 +26163,12 @@ class SegmentEndPoint(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__(self, segments=None, gds_collector_=None, **kwargs_): + def __init__( + self, + segments: "a NonNegativeInteger (required)" = None, + gds_collector_=None, + **kwargs_, + ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -26231,7 +26374,13 @@ class SubTree(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__(self, from_=None, to=None, gds_collector_=None, **kwargs_): + def __init__( + self, + from_: "a SegmentEndPoint (optional)" = None, + to: "a SegmentEndPoint (optional)" = None, + gds_collector_=None, + **kwargs_, + ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -26448,7 +26597,13 @@ class Path(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__(self, from_=None, to=None, gds_collector_=None, **kwargs_): + def __init__( + self, + from_: "a SegmentEndPoint (optional)" = None, + to: "a SegmentEndPoint (optional)" = None, + gds_collector_=None, + **kwargs_, + ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -26654,7 +26809,12 @@ class Include(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__(self, segment_groups=None, gds_collector_=None, **kwargs_): + def __init__( + self, + segment_groups: "a NmlId (required)" = None, + gds_collector_=None, + **kwargs_, + ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -26864,7 +27024,12 @@ class Member(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__(self, segments=None, gds_collector_=None, **kwargs_): + def __init__( + self, + segments: "a NonNegativeInteger (required)" = None, + gds_collector_=None, + **kwargs_, + ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -27056,7 +27221,12 @@ class DistalDetails(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__(self, normalization_end=None, gds_collector_=None, **kwargs_): + def __init__( + self, + normalization_end: "a double (required)" = None, + gds_collector_=None, + **kwargs_, + ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -27237,7 +27407,12 @@ class ProximalDetails(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__(self, translation_start=None, gds_collector_=None, **kwargs_): + def __init__( + self, + translation_start: "a double (required)" = None, + gds_collector_=None, + **kwargs_, + ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -27433,11 +27608,11 @@ class InhomogeneousParameter(Base): def __init__( self, - id=None, - variable=None, - metric=None, - proximal=None, - distal=None, + id: "a NmlId (required)" = None, + variable: "a string (required)" = None, + metric: "a Metric (required)" = None, + proximal: "a ProximalDetails (optional)" = None, + distal: "a DistalDetails (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -27833,16 +28008,16 @@ class SegmentGroup(Base): def __init__( self, - id=None, - neuro_lex_id=None, - notes=None, - properties=None, - annotation=None, - members=None, - includes=None, - paths=None, - sub_trees=None, - inhomogeneous_parameters=None, + id: "a NonNegativeInteger (required)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + members: "list of Member(s) (optional)" = None, + includes: "list of Include(s) (optional)" = None, + paths: "list of Path(s) (optional)" = None, + sub_trees: "list of SubTree(s) (optional)" = None, + inhomogeneous_parameters: "list of InhomogeneousParameter(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -28353,7 +28528,13 @@ class Point3DWithDiam(BaseWithoutId): superclass = BaseWithoutId def __init__( - self, x=None, y=None, z=None, diameter=None, gds_collector_=None, **kwargs_ + self, + x: "a double (required)" = None, + y: "a double (required)" = None, + z: "a double (required)" = None, + diameter: "a DoubleGreaterThanZero (required)" = None, + gds_collector_=None, + **kwargs_, ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -28633,7 +28814,11 @@ class SegmentParent(BaseWithoutId): superclass = BaseWithoutId def __init__( - self, segments=None, fraction_along="1", gds_collector_=None, **kwargs_ + self, + segments: "a NonNegativeInteger (required)" = None, + fraction_along: "a ZeroToOne (optional)" = "1", + gds_collector_=None, + **kwargs_, ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -28910,12 +29095,12 @@ class Segment(BaseNonNegativeIntegerId): def __init__( self, - id=None, - name=None, - neuro_lex_id=None, - parent=None, - proximal=None, - distal=None, + id: "a NonNegativeInteger (required)" = None, + name: "a string (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + parent: "a SegmentParent (optional)" = None, + proximal: "a Point3DWithDiam (optional)" = None, + distal: "a Point3DWithDiam (required)" = None, gds_collector_=None, **kwargs_, ): @@ -29355,13 +29540,13 @@ class Morphology(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - segments=None, - segment_groups=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + segments: "list of Segment(s) (required)" = None, + segment_groups: "list of SegmentGroup(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -29593,12 +29778,12 @@ class BaseCell(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -29835,10 +30020,10 @@ class PlasticityMechanism(BaseWithoutId): def __init__( self, - type=None, - init_release_prob=None, - tau_rec=None, - tau_fac=None, + type: "a PlasticityTypes (required)" = None, + init_release_prob: "a ZeroToOne (required)" = None, + tau_rec: "a Nml2Quantity_time (required)" = None, + tau_fac: "a Nml2Quantity_time (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -30216,11 +30401,11 @@ class BlockMechanism(BaseWithoutId): def __init__( self, - type=None, - species=None, - block_concentration=None, - scaling_conc=None, - scaling_volt=None, + type: "a BlockTypes (required)" = None, + species: "a NmlId (required)" = None, + block_concentration: "a Nml2Quantity_concentration (required)" = None, + scaling_conc: "a Nml2Quantity_concentration (required)" = None, + scaling_volt: "a Nml2Quantity_voltage (required)" = None, gds_collector_=None, **kwargs_, ): @@ -30628,12 +30813,12 @@ class BaseSynapse(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -30862,12 +31047,12 @@ class ConcentrationModel(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - ion=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + ion: "a NmlId (required)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -31116,11 +31301,11 @@ class HHTime(BaseWithoutId): def __init__( self, - type=None, - rate=None, - midpoint=None, - scale=None, - tau=None, + type: "a NmlId (required)" = None, + rate: "a Nml2Quantity_time (optional)" = None, + midpoint: "a Nml2Quantity_voltage (optional)" = None, + scale: "a Nml2Quantity_voltage (optional)" = None, + tau: "a Nml2Quantity_time (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -31489,10 +31674,10 @@ class HHVariable(BaseWithoutId): def __init__( self, - type=None, - rate=None, - midpoint=None, - scale=None, + type: "a NmlId (required)" = None, + rate: "a float (optional)" = None, + midpoint: "a Nml2Quantity_voltage (optional)" = None, + scale: "a Nml2Quantity_voltage (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -31801,10 +31986,10 @@ class HHRate(BaseWithoutId): def __init__( self, - type=None, - rate=None, - midpoint=None, - scale=None, + type: "a NmlId (required)" = None, + rate: "a Nml2Quantity_pertime (optional)" = None, + midpoint: "a Nml2Quantity_voltage (optional)" = None, + scale: "a Nml2Quantity_voltage (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -32181,12 +32366,12 @@ class GateFractionalSubgate(Base): def __init__( self, - id=None, - fractional_conductance=None, - notes=None, - q10_settings=None, - steady_state=None, - time_course=None, + id: "a NmlId (required)" = None, + fractional_conductance: "a Nml2Quantity_none (required)" = None, + notes: "a string (optional)" = None, + q10_settings: "a Q10Settings (optional)" = None, + steady_state: "a HHVariable (required)" = None, + time_course: "a HHTime (required)" = None, gds_collector_=None, **kwargs_, ): @@ -32599,11 +32784,11 @@ class GateFractional(Base): def __init__( self, - id=None, - instances=None, - notes=None, - q10_settings=None, - sub_gates=None, + id: "a NmlId (required)" = None, + instances: "a PositiveInteger (required)" = None, + notes: "a string (optional)" = None, + q10_settings: "a Q10Settings (optional)" = None, + sub_gates: "list of GateFractionalSubgate(s) (required)" = None, gds_collector_=None, **kwargs_, ): @@ -32942,10 +33127,10 @@ class GateHHInstantaneous(Base): def __init__( self, - id=None, - instances=None, - notes=None, - steady_state=None, + id: "a NmlId (required)" = None, + instances: "a PositiveInteger (required)" = None, + notes: "a string (optional)" = None, + steady_state: "a HHVariable (required)" = None, gds_collector_=None, **kwargs_, ): @@ -33290,13 +33475,13 @@ class GateHHRatesInf(Base): def __init__( self, - id=None, - instances=None, - notes=None, - q10_settings=None, - forward_rate=None, - reverse_rate=None, - steady_state=None, + id: "a NmlId (required)" = None, + instances: "a PositiveInteger (required)" = None, + notes: "a string (optional)" = None, + q10_settings: "a Q10Settings (optional)" = None, + forward_rate: "a HHRate (required)" = None, + reverse_rate: "a HHRate (required)" = None, + steady_state: "a HHVariable (required)" = None, gds_collector_=None, **kwargs_, ): @@ -33710,13 +33895,13 @@ class GateHHRatesTau(Base): def __init__( self, - id=None, - instances=None, - notes=None, - q10_settings=None, - forward_rate=None, - reverse_rate=None, - time_course=None, + id: "a NmlId (required)" = None, + instances: "a PositiveInteger (required)" = None, + notes: "a string (optional)" = None, + q10_settings: "a Q10Settings (optional)" = None, + forward_rate: "a HHRate (required)" = None, + reverse_rate: "a HHRate (required)" = None, + time_course: "a HHTime (required)" = None, gds_collector_=None, **kwargs_, ): @@ -34138,14 +34323,14 @@ class GateHHRatesTauInf(Base): def __init__( self, - id=None, - instances=None, - notes=None, - q10_settings=None, - forward_rate=None, - reverse_rate=None, - time_course=None, - steady_state=None, + id: "a NmlId (required)" = None, + instances: "a PositiveInteger (required)" = None, + notes: "a string (optional)" = None, + q10_settings: "a Q10Settings (optional)" = None, + forward_rate: "a HHRate (required)" = None, + reverse_rate: "a HHRate (required)" = None, + time_course: "a HHTime (required)" = None, + steady_state: "a HHVariable (required)" = None, gds_collector_=None, **kwargs_, ): @@ -34586,12 +34771,12 @@ class GateHHTauInf(Base): def __init__( self, - id=None, - instances=None, - notes=None, - q10_settings=None, - time_course=None, - steady_state=None, + id: "a NmlId (required)" = None, + instances: "a PositiveInteger (required)" = None, + notes: "a string (optional)" = None, + q10_settings: "a Q10Settings (optional)" = None, + time_course: "a HHTime (required)" = None, + steady_state: "a HHVariable (required)" = None, gds_collector_=None, **kwargs_, ): @@ -34970,12 +35155,12 @@ class GateHHRates(Base): def __init__( self, - id=None, - instances=None, - notes=None, - q10_settings=None, - forward_rate=None, - reverse_rate=None, + id: "a NmlId (required)" = None, + instances: "a PositiveInteger (required)" = None, + notes: "a string (optional)" = None, + q10_settings: "a Q10Settings (optional)" = None, + forward_rate: "a HHRate (required)" = None, + reverse_rate: "a HHRate (required)" = None, gds_collector_=None, **kwargs_, ): @@ -35379,16 +35564,16 @@ class GateHHUndetermined(Base): def __init__( self, - id=None, - instances=None, - type=None, - notes=None, - q10_settings=None, - forward_rate=None, - reverse_rate=None, - time_course=None, - steady_state=None, - sub_gates=None, + id: "a NmlId (required)" = None, + instances: "a PositiveInteger (required)" = None, + type: "a gateTypes (required)" = None, + notes: "a string (optional)" = None, + q10_settings: "a Q10Settings (optional)" = None, + forward_rate: "a HHRate (optional)" = None, + reverse_rate: "a HHRate (optional)" = None, + time_course: "a HHTime (optional)" = None, + steady_state: "a HHVariable (optional)" = None, + sub_gates: "list of GateFractionalSubgate(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -35952,15 +36137,15 @@ class GateKS(Base): def __init__( self, - id=None, - instances=None, - notes=None, - q10_settings=None, - closed_states=None, - open_states=None, - forward_transition=None, - reverse_transition=None, - tau_inf_transition=None, + id: "a NmlId (required)" = None, + instances: "a PositiveInteger (required)" = None, + notes: "a string (optional)" = None, + q10_settings: "a Q10Settings (optional)" = None, + closed_states: "list of ClosedState(s) (required)" = None, + open_states: "list of OpenState(s) (required)" = None, + forward_transition: "list of ForwardTransition(s) (required)" = None, + reverse_transition: "list of ReverseTransition(s) (required)" = None, + tau_inf_transition: "list of TauInfTransition(s) (required)" = None, gds_collector_=None, **kwargs_, ): @@ -36401,11 +36586,11 @@ class TauInfTransition(Base): def __init__( self, - id=None, - from_=None, - to=None, - steady_state=None, - time_course=None, + id: "a NmlId (required)" = None, + from_: "a NmlId (required)" = None, + to: "a NmlId (required)" = None, + steady_state: "a HHVariable (required)" = None, + time_course: "a HHTime (required)" = None, gds_collector_=None, **kwargs_, ): @@ -36706,9 +36891,9 @@ class ReverseTransition(Base): def __init__( self, - id=None, - from_=None, - to=None, + id: "a NmlId (required)" = None, + from_: "a NmlId (required)" = None, + to: "a NmlId (required)" = None, anytypeobjs_=None, gds_collector_=None, **kwargs_, @@ -36966,9 +37151,9 @@ class ForwardTransition(Base): def __init__( self, - id=None, - from_=None, - to=None, + id: "a NmlId (required)" = None, + from_: "a NmlId (required)" = None, + to: "a NmlId (required)" = None, anytypeobjs_=None, gds_collector_=None, **kwargs_, @@ -37218,7 +37403,7 @@ class OpenState(Base): subclass = None superclass = Base - def __init__(self, id=None, gds_collector_=None, **kwargs_): + def __init__(self, id: "a NmlId (required)" = None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -37367,7 +37552,7 @@ class ClosedState(Base): subclass = None superclass = Base - def __init__(self, id=None, gds_collector_=None, **kwargs_): + def __init__(self, id: "a NmlId (required)" = None, gds_collector_=None, **kwargs_): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -37539,7 +37724,11 @@ class Q10ConductanceScaling(BaseWithoutId): superclass = BaseWithoutId def __init__( - self, q10_factor=None, experimental_temp=None, gds_collector_=None, **kwargs_ + self, + q10_factor: "a Nml2Quantity_none (required)" = None, + experimental_temp: "a Nml2Quantity_temperature (required)" = None, + gds_collector_=None, + **kwargs_, ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -37860,15 +38049,15 @@ class IonChannelKS(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - species=None, - conductance=None, - neuro_lex_id=None, - gate_kses=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + species: "a NmlId (optional)" = None, + conductance: "a Nml2Quantity_conductance (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + gate_kses: "list of GateKS(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -38235,13 +38424,13 @@ class IonChannelScalable(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - q10_conductance_scalings=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + q10_conductance_scalings: "list of Q10ConductanceScaling(s) (optional)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -39411,80 +39600,80 @@ class NeuroMLDocument(Standalone): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - includes=None, - extracellular_properties=None, - intracellular_properties=None, - morphology=None, - ion_channel=None, - ion_channel_hhs=None, - ion_channel_v_shifts=None, - ion_channel_kses=None, - concentration_model=None, - decaying_pool_concentration_models=None, - fixed_factor_concentration_models=None, - alpha_current_synapses=None, - alpha_synapses=None, - exp_one_synapses=None, - exp_two_synapses=None, - exp_three_synapses=None, - blocking_plastic_synapses=None, - double_synapses=None, - gap_junctions=None, - silent_synapses=None, - linear_graded_synapses=None, - graded_synapses=None, - biophysical_properties=None, - cells=None, - cell2_ca_poolses=None, - base_cells=None, - iaf_tau_cells=None, - iaf_tau_ref_cells=None, - iaf_cells=None, - iaf_ref_cells=None, - izhikevich_cells=None, - izhikevich2007_cells=None, - ad_ex_ia_f_cells=None, - fitz_hugh_nagumo_cells=None, - fitz_hugh_nagumo1969_cells=None, - pinsky_rinzel_ca3_cells=None, - hindmarshRose1984Cell=None, - pulse_generators=None, - pulse_generator_dls=None, - sine_generators=None, - sine_generator_dls=None, - ramp_generators=None, - ramp_generator_dls=None, - compound_inputs=None, - compound_input_dls=None, - voltage_clamps=None, - voltage_clamp_triples=None, - spike_arrays=None, - timed_synaptic_inputs=None, - spike_generators=None, - spike_generator_randoms=None, - spike_generator_poissons=None, - spike_generator_ref_poissons=None, - poisson_firing_synapses=None, - transient_poisson_firing_synapses=None, - IF_curr_alpha=None, - IF_curr_exp=None, - IF_cond_alpha=None, - IF_cond_exp=None, - EIF_cond_exp_isfa_ista=None, - EIF_cond_alpha_isfa_ista=None, - HH_cond_exp=None, - exp_cond_synapses=None, - alpha_cond_synapses=None, - exp_curr_synapses=None, - alpha_curr_synapses=None, - SpikeSourcePoisson=None, - networks=None, - ComponentType=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + includes: "list of IncludeType(s) (optional)" = None, + extracellular_properties: "list of ExtracellularProperties(s) (optional)" = None, + intracellular_properties: "list of IntracellularProperties(s) (optional)" = None, + morphology: "list of Morphology(s) (optional)" = None, + ion_channel: "list of IonChannel(s) (optional)" = None, + ion_channel_hhs: "list of IonChannelHH(s) (optional)" = None, + ion_channel_v_shifts: "list of IonChannelVShift(s) (optional)" = None, + ion_channel_kses: "list of IonChannelKS(s) (optional)" = None, + concentration_model: "list of ConcentrationModel(s) (optional)" = None, + decaying_pool_concentration_models: "list of DecayingPoolConcentrationModel(s) (optional)" = None, + fixed_factor_concentration_models: "list of FixedFactorConcentrationModel(s) (optional)" = None, + alpha_current_synapses: "list of AlphaCurrentSynapse(s) (optional)" = None, + alpha_synapses: "list of AlphaSynapse(s) (optional)" = None, + exp_one_synapses: "list of ExpOneSynapse(s) (optional)" = None, + exp_two_synapses: "list of ExpTwoSynapse(s) (optional)" = None, + exp_three_synapses: "list of ExpThreeSynapse(s) (optional)" = None, + blocking_plastic_synapses: "list of BlockingPlasticSynapse(s) (optional)" = None, + double_synapses: "list of DoubleSynapse(s) (optional)" = None, + gap_junctions: "list of GapJunction(s) (optional)" = None, + silent_synapses: "list of SilentSynapse(s) (optional)" = None, + linear_graded_synapses: "list of LinearGradedSynapse(s) (optional)" = None, + graded_synapses: "list of GradedSynapse(s) (optional)" = None, + biophysical_properties: "list of BiophysicalProperties(s) (optional)" = None, + cells: "list of Cell(s) (optional)" = None, + cell2_ca_poolses: "list of Cell2CaPools(s) (optional)" = None, + base_cells: "list of BaseCell(s) (optional)" = None, + iaf_tau_cells: "list of IafTauCell(s) (optional)" = None, + iaf_tau_ref_cells: "list of IafTauRefCell(s) (optional)" = None, + iaf_cells: "list of IafCell(s) (optional)" = None, + iaf_ref_cells: "list of IafRefCell(s) (optional)" = None, + izhikevich_cells: "list of IzhikevichCell(s) (optional)" = None, + izhikevich2007_cells: "list of Izhikevich2007Cell(s) (optional)" = None, + ad_ex_ia_f_cells: "list of AdExIaFCell(s) (optional)" = None, + fitz_hugh_nagumo_cells: "list of FitzHughNagumoCell(s) (optional)" = None, + fitz_hugh_nagumo1969_cells: "list of FitzHughNagumo1969Cell(s) (optional)" = None, + pinsky_rinzel_ca3_cells: "list of PinskyRinzelCA3Cell(s) (optional)" = None, + hindmarshRose1984Cell: "list of HindmarshRose1984Cell(s) (optional)" = None, + pulse_generators: "list of PulseGenerator(s) (optional)" = None, + pulse_generator_dls: "list of PulseGeneratorDL(s) (optional)" = None, + sine_generators: "list of SineGenerator(s) (optional)" = None, + sine_generator_dls: "list of SineGeneratorDL(s) (optional)" = None, + ramp_generators: "list of RampGenerator(s) (optional)" = None, + ramp_generator_dls: "list of RampGeneratorDL(s) (optional)" = None, + compound_inputs: "list of CompoundInput(s) (optional)" = None, + compound_input_dls: "list of CompoundInputDL(s) (optional)" = None, + voltage_clamps: "list of VoltageClamp(s) (optional)" = None, + voltage_clamp_triples: "list of VoltageClampTriple(s) (optional)" = None, + spike_arrays: "list of SpikeArray(s) (optional)" = None, + timed_synaptic_inputs: "list of TimedSynapticInput(s) (optional)" = None, + spike_generators: "list of SpikeGenerator(s) (optional)" = None, + spike_generator_randoms: "list of SpikeGeneratorRandom(s) (optional)" = None, + spike_generator_poissons: "list of SpikeGeneratorPoisson(s) (optional)" = None, + spike_generator_ref_poissons: "list of SpikeGeneratorRefPoisson(s) (optional)" = None, + poisson_firing_synapses: "list of PoissonFiringSynapse(s) (optional)" = None, + transient_poisson_firing_synapses: "list of TransientPoissonFiringSynapse(s) (optional)" = None, + IF_curr_alpha: "list of IF_curr_alpha(s) (optional)" = None, + IF_curr_exp: "list of IF_curr_exp(s) (optional)" = None, + IF_cond_alpha: "list of IF_cond_alpha(s) (optional)" = None, + IF_cond_exp: "list of IF_cond_exp(s) (optional)" = None, + EIF_cond_exp_isfa_ista: "list of EIF_cond_exp_isfa_ista(s) (optional)" = None, + EIF_cond_alpha_isfa_ista: "list of EIF_cond_alpha_isfa_ista(s) (optional)" = None, + HH_cond_exp: "list of HH_cond_exp(s) (optional)" = None, + exp_cond_synapses: "list of ExpCondSynapse(s) (optional)" = None, + alpha_cond_synapses: "list of AlphaCondSynapse(s) (optional)" = None, + exp_curr_synapses: "list of ExpCurrSynapse(s) (optional)" = None, + alpha_curr_synapses: "list of AlphaCurrSynapse(s) (optional)" = None, + SpikeSourcePoisson: "list of SpikeSourcePoisson(s) (optional)" = None, + networks: "list of Network(s) (optional)" = None, + ComponentType: "list of ComponentType(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -42088,10 +42277,10 @@ class NamedDimensionalVariable(BaseWithoutId): def __init__( self, - name=None, - dimension=None, - description=None, - exposure=None, + name: "a string (required)" = None, + dimension: "a string (required)" = None, + description: "a string (optional)" = None, + exposure: "a string (optional)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -42371,9 +42560,9 @@ class NamedDimensionalType(BaseWithoutId): def __init__( self, - name=None, - dimension=None, - description=None, + name: "a string (required)" = None, + dimension: "a string (required)" = None, + description: "a string (optional)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -42631,9 +42820,9 @@ class Exposure(BaseWithoutId): def __init__( self, - name=None, - dimension=None, - description=None, + name: "a string (required)" = None, + dimension: "a string (required)" = None, + description: "a string (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -42857,10 +43046,10 @@ class Constant(BaseWithoutId): def __init__( self, - name=None, - dimension=None, - value=None, - description=None, + name: "a string (required)" = None, + dimension: "a string (required)" = None, + value: "a Nml2Quantity (required)" = None, + description: "a string (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -43294,7 +43483,13 @@ class Property(BaseWithoutId): subclass = None superclass = BaseWithoutId - def __init__(self, tag=None, value=None, gds_collector_=None, **kwargs_): + def __init__( + self, + tag: "a string (required)" = None, + value: "a string (required)" = None, + gds_collector_=None, + **kwargs_, + ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None self.original_tagname_ = None @@ -43487,13 +43682,13 @@ class BasePynnSynapse(BaseSynapse): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - tau_syn=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + tau_syn: "a float (required)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -43714,17 +43909,17 @@ class basePyNNCell(BaseCell): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - cm=None, - i_offset=None, - tau_syn_E=None, - tau_syn_I=None, - v_init=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + cm: "a float (required)" = None, + i_offset: "a float (required)" = None, + tau_syn_E: "a float (required)" = None, + tau_syn_I: "a float (required)" = None, + v_init: "a float (required)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -43989,12 +44184,12 @@ class InputW(Input): def __init__( self, - id=None, - target=None, - destination=None, - segment_id=None, - fraction_along=None, - weight=None, + id: "a NonNegativeInteger (required)" = None, + target: "a Nml2PopulationReferencePath (required)" = None, + destination: "a NmlId (required)" = None, + segment_id: "a NonNegativeInteger (optional)" = None, + fraction_along: "a ZeroToOne (optional)" = None, + weight: "a float (required)" = None, gds_collector_=None, **kwargs_, ): @@ -44220,12 +44415,12 @@ class ContinuousProjection(BaseProjection): def __init__( self, - id=None, - presynaptic_population=None, - postsynaptic_population=None, - continuous_connections=None, - continuous_connection_instances=None, - continuous_connection_instance_ws=None, + id: "a NmlId (required)" = None, + presynaptic_population: "a NmlId (required)" = None, + postsynaptic_population: "a NmlId (required)" = None, + continuous_connections: "list of ContinuousConnection(s) (optional)" = None, + continuous_connection_instances: "list of ContinuousConnectionInstance(s) (optional)" = None, + continuous_connection_instance_ws: "list of ContinuousConnectionInstanceW(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -44635,12 +44830,12 @@ class ElectricalProjection(BaseProjection): def __init__( self, - id=None, - presynaptic_population=None, - postsynaptic_population=None, - electrical_connections=None, - electrical_connection_instances=None, - electrical_connection_instance_ws=None, + id: "a NmlId (required)" = None, + presynaptic_population: "a NmlId (required)" = None, + postsynaptic_population: "a NmlId (required)" = None, + electrical_connections: "list of ElectricalConnection(s) (optional)" = None, + electrical_connection_instances: "list of ElectricalConnectionInstance(s) (optional)" = None, + electrical_connection_instance_ws: "list of ElectricalConnectionInstanceW(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -45040,14 +45235,14 @@ class BaseConnectionNewFormat(BaseConnection): def __init__( self, - id=None, - neuro_lex_id=None, - pre_cell=None, - pre_segment="0", - pre_fraction_along="0.5", - post_cell=None, - post_segment="0", - post_fraction_along="0.5", + id: "a NmlId (required)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + pre_cell: "a string (required)" = None, + pre_segment: "a NonNegativeInteger (optional)" = "0", + pre_fraction_along: "a ZeroToOne (optional)" = "0.5", + post_cell: "a string (required)" = None, + post_segment: "a NonNegativeInteger (optional)" = "0", + post_fraction_along: "a ZeroToOne (optional)" = "0.5", extensiontype_=None, gds_collector_=None, **kwargs_, @@ -45468,14 +45663,14 @@ class BaseConnectionOldFormat(BaseConnection): def __init__( self, - id=None, - neuro_lex_id=None, - pre_cell_id=None, - pre_segment_id="0", - pre_fraction_along="0.5", - post_cell_id=None, - post_segment_id="0", - post_fraction_along="0.5", + id: "a NmlId (required)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + pre_cell_id: "a Nml2PopulationReferencePath (required)" = None, + pre_segment_id: "a NonNegativeInteger (optional)" = "0", + pre_fraction_along: "a ZeroToOne (optional)" = "0.5", + post_cell_id: "a Nml2PopulationReferencePath (required)" = None, + post_segment_id: "a NonNegativeInteger (optional)" = "0", + post_fraction_along: "a ZeroToOne (optional)" = "0.5", extensiontype_=None, gds_collector_=None, **kwargs_, @@ -45926,12 +46121,12 @@ class Projection(BaseProjection): def __init__( self, - id=None, - presynaptic_population=None, - postsynaptic_population=None, - synapse=None, - connections=None, - connection_wds=None, + id: "a NmlId (required)" = None, + presynaptic_population: "a NmlId (required)" = None, + postsynaptic_population: "a NmlId (required)" = None, + synapse: "a NmlId (required)" = None, + connections: "list of Connection(s) (optional)" = None, + connection_wds: "list of ConnectionWD(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -46316,13 +46511,13 @@ class SpikeGeneratorRefPoisson(SpikeGeneratorPoisson): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - average_rate=None, - minimum_isi=None, + id: "a NonNegativeInteger (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + average_rate: "a Nml2Quantity_pertime (required)" = None, + minimum_isi: "a Nml2Quantity_time (required)" = None, gds_collector_=None, **kwargs_, ): @@ -46548,7 +46743,11 @@ class IntracellularProperties2CaPools(IntracellularProperties): superclass = IntracellularProperties def __init__( - self, species=None, resistivities=None, gds_collector_=None, **kwargs_ + self, + species: "list of Species(s) (optional)" = None, + resistivities: "list of Resistivity(s) (optional)" = None, + gds_collector_=None, + **kwargs_, ): self.gds_collector_ = gds_collector_ self.gds_elementtree_node_ = None @@ -46726,13 +46925,13 @@ class ChannelDensityNernstCa2(ChannelDensityNernst): def __init__( self, - id=None, - ion_channel=None, - cond_density=None, - segment_groups="all", - segments=None, - ion=None, - variable_parameters=None, + id: "a NmlId (required)" = None, + ion_channel: "a NmlId (required)" = None, + cond_density: "a Nml2Quantity_conductanceDensity (optional)" = None, + segment_groups: "a NmlId (optional)" = "all", + segments: "a NonNegativeInteger (optional)" = None, + ion: "a NmlId (required)" = None, + variable_parameters: "list of VariableParameter(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -46926,15 +47125,15 @@ class ChannelDensityVShift(ChannelDensity): def __init__( self, - id=None, - ion_channel=None, - cond_density=None, - erev=None, - segment_groups="all", - segments=None, - ion=None, - variable_parameters=None, - v_shift=None, + id: "a NmlId (required)" = None, + ion_channel: "a NmlId (required)" = None, + cond_density: "a Nml2Quantity_conductanceDensity (optional)" = None, + erev: "a Nml2Quantity_voltage (required)" = None, + segment_groups: "a NmlId (optional)" = "all", + segments: "a NonNegativeInteger (optional)" = None, + ion: "a NmlId (required)" = None, + variable_parameters: "list of VariableParameter(s) (optional)" = None, + v_shift: "a Nml2Quantity_voltage (required)" = None, gds_collector_=None, **kwargs_, ): @@ -47181,20 +47380,20 @@ class MembraneProperties2CaPools(MembraneProperties): def __init__( self, - channel_populations=None, - baseChannelDensity=None, - channel_densities=None, - channel_density_v_shifts=None, - channel_density_nernsts=None, - channel_density_ghks=None, - channel_density_ghk2s=None, - channel_density_non_uniforms=None, - channel_density_non_uniform_nernsts=None, - channel_density_non_uniform_ghks=None, - spike_threshes=None, - specific_capacitances=None, - init_memb_potentials=None, - channel_density_nernst_ca2s=None, + channel_populations: "list of ChannelPopulation(s) (optional)" = None, + baseChannelDensity: "list of BaseChannelDensity(s) (optional)" = None, + channel_densities: "list of ChannelDensity(s) (optional)" = None, + channel_density_v_shifts: "list of ChannelDensityVShift(s) (optional)" = None, + channel_density_nernsts: "list of ChannelDensityNernst(s) (optional)" = None, + channel_density_ghks: "list of ChannelDensityGHK(s) (optional)" = None, + channel_density_ghk2s: "list of ChannelDensityGHK2(s) (optional)" = None, + channel_density_non_uniforms: "list of ChannelDensityNonUniform(s) (optional)" = None, + channel_density_non_uniform_nernsts: "list of ChannelDensityNonUniformNernst(s) (optional)" = None, + channel_density_non_uniform_ghks: "list of ChannelDensityNonUniformGHK(s) (optional)" = None, + spike_threshes: "list of SpikeThresh(s) (required)" = None, + specific_capacitances: "list of SpecificCapacitance(s) (required)" = None, + init_memb_potentials: "list of InitMembPotential(s) (required)" = None, + channel_density_nernst_ca2s: "list of ChannelDensityNernstCa2(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -47449,16 +47648,16 @@ class Cell(BaseCell): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - morphology_attr=None, - biophysical_properties_attr=None, - morphology=None, - biophysical_properties=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + morphology_attr: "a NmlId (optional)" = None, + biophysical_properties_attr: "a NmlId (optional)" = None, + morphology: "a Morphology (optional)" = None, + biophysical_properties: "a BiophysicalProperties (optional)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -49613,33 +49812,33 @@ class PinskyRinzelCA3Cell(BaseCell): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - i_soma=None, - i_dend=None, - gc=None, - g_ls=None, - g_ld=None, - g_na=None, - g_kdr=None, - g_ca=None, - g_kahp=None, - g_kc=None, - g_nmda=None, - g_ampa=None, - e_na=None, - e_ca=None, - e_k=None, - e_l=None, - qd0=None, - pp=None, - alphac=None, - betac=None, - cm=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + i_soma: "a Nml2Quantity_currentDensity (required)" = None, + i_dend: "a Nml2Quantity_currentDensity (required)" = None, + gc: "a Nml2Quantity_conductanceDensity (required)" = None, + g_ls: "a Nml2Quantity_conductanceDensity (required)" = None, + g_ld: "a Nml2Quantity_conductanceDensity (required)" = None, + g_na: "a Nml2Quantity_conductanceDensity (required)" = None, + g_kdr: "a Nml2Quantity_conductanceDensity (required)" = None, + g_ca: "a Nml2Quantity_conductanceDensity (required)" = None, + g_kahp: "a Nml2Quantity_conductanceDensity (required)" = None, + g_kc: "a Nml2Quantity_conductanceDensity (required)" = None, + g_nmda: "a Nml2Quantity_conductanceDensity (required)" = None, + g_ampa: "a Nml2Quantity_conductanceDensity (required)" = None, + e_na: "a Nml2Quantity_voltage (required)" = None, + e_ca: "a Nml2Quantity_voltage (required)" = None, + e_k: "a Nml2Quantity_voltage (required)" = None, + e_l: "a Nml2Quantity_voltage (required)" = None, + qd0: "a Nml2Quantity_none (required)" = None, + pp: "a Nml2Quantity_none (required)" = None, + alphac: "a Nml2Quantity_none (required)" = None, + betac: "a Nml2Quantity_none (required)" = None, + cm: "a Nml2Quantity_specificCapacitance (required)" = None, gds_collector_=None, **kwargs_, ): @@ -50500,18 +50699,18 @@ class FitzHughNagumo1969Cell(BaseCell): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - a=None, - b=None, - I=None, - phi=None, - V0=None, - W0=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + a: "a Nml2Quantity_none (required)" = None, + b: "a Nml2Quantity_none (required)" = None, + I: "a Nml2Quantity_none (required)" = None, + phi: "a Nml2Quantity_none (required)" = None, + V0: "a Nml2Quantity_none (required)" = None, + W0: "a Nml2Quantity_none (required)" = None, gds_collector_=None, **kwargs_, ): @@ -50834,13 +51033,13 @@ class FitzHughNagumoCell(BaseCell): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - I=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + I: "a Nml2Quantity_none (required)" = None, gds_collector_=None, **kwargs_, ): @@ -51066,13 +51265,13 @@ class BaseCellMembPotCap(BaseCell): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - C=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + C: "a Nml2Quantity_capacitance (required)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -51348,18 +51547,18 @@ class IzhikevichCell(BaseCell): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - v0=None, - thresh=None, - a=None, - b=None, - c=None, - d=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + v0: "a Nml2Quantity_voltage (required)" = None, + thresh: "a Nml2Quantity_voltage (required)" = None, + a: "a Nml2Quantity_none (required)" = None, + b: "a Nml2Quantity_none (required)" = None, + c: "a Nml2Quantity_none (required)" = None, + d: "a Nml2Quantity_none (required)" = None, gds_collector_=None, **kwargs_, ): @@ -51742,17 +51941,17 @@ class IafCell(BaseCell): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - leak_reversal=None, - thresh=None, - reset=None, - C=None, - leak_conductance=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + leak_reversal: "a Nml2Quantity_voltage (required)" = None, + thresh: "a Nml2Quantity_voltage (required)" = None, + reset: "a Nml2Quantity_voltage (required)" = None, + C: "a Nml2Quantity_capacitance (required)" = None, + leak_conductance: "a Nml2Quantity_conductance (required)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -52187,16 +52386,16 @@ class IafTauCell(BaseCell): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - leak_reversal=None, - thresh=None, - reset=None, - tau=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + leak_reversal: "a Nml2Quantity_voltage (required)" = None, + thresh: "a Nml2Quantity_voltage (required)" = None, + reset: "a Nml2Quantity_voltage (required)" = None, + tau: "a Nml2Quantity_time (required)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -52563,17 +52762,17 @@ class GradedSynapse(BaseSynapse): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - conductance=None, - delta=None, - Vth=None, - k=None, - erev=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + conductance: "a Nml2Quantity_conductance (required)" = None, + delta: "a Nml2Quantity_voltage (required)" = None, + Vth: "a Nml2Quantity_voltage (required)" = None, + k: "a Nml2Quantity_pertime (required)" = None, + erev: "a Nml2Quantity_voltage (required)" = None, gds_collector_=None, **kwargs_, ): @@ -52957,13 +53156,13 @@ class LinearGradedSynapse(BaseSynapse): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - conductance=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + conductance: "a Nml2Quantity_conductance (required)" = None, gds_collector_=None, **kwargs_, ): @@ -53188,12 +53387,12 @@ class SilentSynapse(BaseSynapse): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -53362,13 +53561,13 @@ class GapJunction(BaseSynapse): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - conductance=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + conductance: "a Nml2Quantity_conductance (required)" = None, gds_collector_=None, **kwargs_, ): @@ -53581,12 +53780,12 @@ class BaseCurrentBasedSynapse(BaseSynapse): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -53781,12 +53980,12 @@ class BaseVoltageDepSynapse(BaseSynapse): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -54006,15 +54205,15 @@ class FixedFactorConcentrationModel(ConcentrationModel): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - ion=None, - resting_conc=None, - decay_constant=None, - rho=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + ion: "a NmlId (required)" = None, + resting_conc: "a Nml2Quantity_concentration (required)" = None, + decay_constant: "a Nml2Quantity_time (required)" = None, + rho: "a Nml2Quantity_rhoFactor (required)" = None, gds_collector_=None, **kwargs_, ): @@ -54395,15 +54594,15 @@ class DecayingPoolConcentrationModel(ConcentrationModel): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - ion=None, - resting_conc=None, - decay_constant=None, - shell_thickness=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + ion: "a NmlId (required)" = None, + resting_conc: "a Nml2Quantity_concentration (required)" = None, + decay_constant: "a Nml2Quantity_time (required)" = None, + shell_thickness: "a Nml2Quantity_length (required)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -54898,24 +55097,24 @@ class IonChannel(IonChannelScalable): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - q10_conductance_scalings=None, - species=None, - type=None, - conductance=None, - gates=None, - gate_hh_rates=None, - gate_h_hrates_taus=None, - gate_hh_tau_infs=None, - gate_h_hrates_infs=None, - gate_h_hrates_tau_infs=None, - gate_hh_instantaneouses=None, - gate_fractionals=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + q10_conductance_scalings: "list of Q10ConductanceScaling(s) (optional)" = None, + species: "a NmlId (optional)" = None, + type: "a channelTypes (optional)" = None, + conductance: "a Nml2Quantity_conductance (optional)" = None, + gates: "list of GateHHUndetermined(s) (optional)" = None, + gate_hh_rates: "list of GateHHRates(s) (optional)" = None, + gate_h_hrates_taus: "list of GateHHRatesTau(s) (optional)" = None, + gate_hh_tau_infs: "list of GateHHTauInf(s) (optional)" = None, + gate_h_hrates_infs: "list of GateHHRatesInf(s) (optional)" = None, + gate_h_hrates_tau_infs: "list of GateHHRatesTauInf(s) (optional)" = None, + gate_hh_instantaneouses: "list of GateHHInstantaneous(s) (optional)" = None, + gate_fractionals: "list of GateFractional(s) (optional)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -55498,11 +55697,11 @@ class ConditionalDerivedVariable(NamedDimensionalVariable): def __init__( self, - name=None, - dimension=None, - description=None, - exposure=None, - Case=None, + name: "a string (required)" = None, + dimension: "a string (required)" = None, + description: "a string (optional)" = None, + exposure: "a string (optional)" = None, + Case: "list of Case(s) (required)" = None, gds_collector_=None, **kwargs_, ): @@ -55699,10 +55898,10 @@ class StateVariable(NamedDimensionalVariable): def __init__( self, - name=None, - dimension=None, - description=None, - exposure=None, + name: "a string (required)" = None, + dimension: "a string (required)" = None, + description: "a string (optional)" = None, + exposure: "a string (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -55861,12 +56060,12 @@ class DerivedVariable(NamedDimensionalVariable): def __init__( self, - name=None, - dimension=None, - description=None, - exposure=None, - value=None, - select=None, + name: "a string (required)" = None, + dimension: "a string (required)" = None, + description: "a string (optional)" = None, + exposure: "a string (optional)" = None, + value: "a string (optional)" = None, + select: "a string (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -56060,9 +56259,9 @@ class Requirement(NamedDimensionalType): def __init__( self, - name=None, - dimension=None, - description=None, + name: "a string (required)" = None, + dimension: "a string (required)" = None, + description: "a string (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -56224,10 +56423,10 @@ class LEMS_Property(NamedDimensionalType): def __init__( self, - name=None, - dimension=None, - description=None, - default_value=None, + name: "a string (required)" = None, + dimension: "a string (required)" = None, + description: "a string (optional)" = None, + default_value: "a double (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -56402,10 +56601,10 @@ class DerivedParameter(NamedDimensionalType): def __init__( self, - name=None, - dimension=None, - description=None, - value=None, + name: "a string (required)" = None, + dimension: "a string (required)" = None, + description: "a string (optional)" = None, + value: "a string (required)" = None, gds_collector_=None, **kwargs_, ): @@ -56587,9 +56786,9 @@ class Parameter(NamedDimensionalType): def __init__( self, - name=None, - dimension=None, - description=None, + name: "a string (required)" = None, + dimension: "a string (required)" = None, + description: "a string (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -56745,13 +56944,13 @@ class AlphaCurrSynapse(BasePynnSynapse): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - tau_syn=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + tau_syn: "a float (required)" = None, gds_collector_=None, **kwargs_, ): @@ -56920,13 +57119,13 @@ class ExpCurrSynapse(BasePynnSynapse): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - tau_syn=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + tau_syn: "a float (required)" = None, gds_collector_=None, **kwargs_, ): @@ -57091,14 +57290,14 @@ class AlphaCondSynapse(BasePynnSynapse): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - tau_syn=None, - e_rev=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + tau_syn: "a float (required)" = None, + e_rev: "a float (required)" = None, gds_collector_=None, **kwargs_, ): @@ -57285,14 +57484,14 @@ class ExpCondSynapse(BasePynnSynapse): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - tau_syn=None, - e_rev=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + tau_syn: "a float (required)" = None, + e_rev: "a float (required)" = None, gds_collector_=None, **kwargs_, ): @@ -57517,26 +57716,26 @@ class HH_cond_exp(basePyNNCell): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - cm=None, - i_offset=None, - tau_syn_E=None, - tau_syn_I=None, - v_init=None, - v_offset=None, - e_rev_E=None, - e_rev_I=None, - e_rev_K=None, - e_rev_Na=None, - e_rev_leak=None, - g_leak=None, - gbar_K=None, - gbar_Na=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + cm: "a float (required)" = None, + i_offset: "a float (required)" = None, + tau_syn_E: "a float (required)" = None, + tau_syn_I: "a float (required)" = None, + v_init: "a float (required)" = None, + v_offset: "a float (required)" = None, + e_rev_E: "a float (required)" = None, + e_rev_I: "a float (required)" = None, + e_rev_K: "a float (required)" = None, + e_rev_Na: "a float (required)" = None, + e_rev_leak: "a float (required)" = None, + g_leak: "a float (required)" = None, + gbar_K: "a float (required)" = None, + gbar_Na: "a float (required)" = None, gds_collector_=None, **kwargs_, ): @@ -57877,22 +58076,22 @@ class basePyNNIaFCell(basePyNNCell): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - cm=None, - i_offset=None, - tau_syn_E=None, - tau_syn_I=None, - v_init=None, - tau_m=None, - tau_refrac=None, - v_reset=None, - v_rest=None, - v_thresh=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + cm: "a float (required)" = None, + i_offset: "a float (required)" = None, + tau_syn_E: "a float (required)" = None, + tau_syn_I: "a float (required)" = None, + v_init: "a float (required)" = None, + tau_m: "a float (required)" = None, + tau_refrac: "a float (required)" = None, + v_reset: "a float (required)" = None, + v_rest: "a float (required)" = None, + v_thresh: "a float (required)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -58166,16 +58365,16 @@ class ContinuousConnection(BaseConnectionNewFormat): def __init__( self, - id=None, - neuro_lex_id=None, - pre_cell=None, - pre_segment="0", - pre_fraction_along="0.5", - post_cell=None, - post_segment="0", - post_fraction_along="0.5", - pre_component=None, - post_component=None, + id: "a NonNegativeInteger (required)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + pre_cell: "a string (required)" = None, + pre_segment: "a NonNegativeInteger (optional)" = "0", + pre_fraction_along: "a ZeroToOne (optional)" = "0.5", + post_cell: "a string (required)" = None, + post_segment: "a NonNegativeInteger (optional)" = "0", + post_fraction_along: "a ZeroToOne (optional)" = "0.5", + pre_component: "a NmlId (required)" = None, + post_component: "a NmlId (required)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -58542,15 +58741,15 @@ class ElectricalConnection(BaseConnectionNewFormat): def __init__( self, - id=None, - neuro_lex_id=None, - pre_cell=None, - pre_segment="0", - pre_fraction_along="0.5", - post_cell=None, - post_segment="0", - post_fraction_along="0.5", - synapse=None, + id: "a NonNegativeInteger (required)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + pre_cell: "a string (required)" = None, + pre_segment: "a NonNegativeInteger (optional)" = "0", + pre_fraction_along: "a ZeroToOne (optional)" = "0.5", + post_cell: "a string (required)" = None, + post_segment: "a NonNegativeInteger (optional)" = "0", + post_fraction_along: "a ZeroToOne (optional)" = "0.5", + synapse: "a NmlId (required)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -58894,16 +59093,16 @@ class ConnectionWD(BaseConnectionOldFormat): def __init__( self, - id=None, - neuro_lex_id=None, - pre_cell_id=None, - pre_segment_id="0", - pre_fraction_along="0.5", - post_cell_id=None, - post_segment_id="0", - post_fraction_along="0.5", - weight=None, - delay=None, + id: "a NonNegativeInteger (required)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + pre_cell_id: "a Nml2PopulationReferencePath (required)" = None, + pre_segment_id: "a NonNegativeInteger (optional)" = "0", + pre_fraction_along: "a ZeroToOne (optional)" = "0.5", + post_cell_id: "a Nml2PopulationReferencePath (required)" = None, + post_segment_id: "a NonNegativeInteger (optional)" = "0", + post_fraction_along: "a ZeroToOne (optional)" = "0.5", + weight: "a float (required)" = None, + delay: "a Nml2Quantity_time (required)" = None, gds_collector_=None, **kwargs_, ): @@ -59251,14 +59450,14 @@ class Connection(BaseConnectionOldFormat): def __init__( self, - id=None, - neuro_lex_id=None, - pre_cell_id=None, - pre_segment_id="0", - pre_fraction_along="0.5", - post_cell_id=None, - post_segment_id="0", - post_fraction_along="0.5", + id: "a NonNegativeInteger (required)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + pre_cell_id: "a Nml2PopulationReferencePath (required)" = None, + pre_segment_id: "a NonNegativeInteger (optional)" = "0", + pre_fraction_along: "a ZeroToOne (optional)" = "0.5", + post_cell_id: "a Nml2PopulationReferencePath (required)" = None, + post_segment_id: "a NonNegativeInteger (optional)" = "0", + post_fraction_along: "a ZeroToOne (optional)" = "0.5", gds_collector_=None, **kwargs_, ): @@ -59504,16 +59703,16 @@ class ConcentrationModel_D(DecayingPoolConcentrationModel): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - ion=None, - resting_conc=None, - decay_constant=None, - shell_thickness=None, - type="decayingPoolConcentrationModel", + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + ion: "a NmlId (required)" = None, + resting_conc: "a Nml2Quantity_concentration (required)" = None, + decay_constant: "a Nml2Quantity_time (required)" = None, + shell_thickness: "a Nml2Quantity_length (required)" = None, + type: "a string (required)" = "decayingPoolConcentrationModel", gds_collector_=None, **kwargs_, ): @@ -59723,17 +59922,17 @@ class Cell2CaPools(Cell): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - morphology_attr=None, - biophysical_properties_attr=None, - morphology=None, - biophysical_properties=None, - biophysical_properties2_ca_pools=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + morphology_attr: "a NmlId (optional)" = None, + biophysical_properties_attr: "a NmlId (optional)" = None, + morphology: "a Morphology (optional)" = None, + biophysical_properties: "a BiophysicalProperties (optional)" = None, + biophysical_properties2_ca_pools: "a BiophysicalProperties2CaPools (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -59982,24 +60181,24 @@ class HindmarshRose1984Cell(BaseCellMembPotCap): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - C=None, - a=None, - b=None, - c=None, - d=None, - s=None, - x1=None, - r=None, - x0=None, - y0=None, - z0=None, - v_scaling=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + C: "a Nml2Quantity_capacitance (required)" = None, + a: "a Nml2Quantity_none (required)" = None, + b: "a Nml2Quantity_none (required)" = None, + c: "a Nml2Quantity_none (required)" = None, + d: "a Nml2Quantity_none (required)" = None, + s: "a Nml2Quantity_none (required)" = None, + x1: "a Nml2Quantity_none (required)" = None, + r: "a Nml2Quantity_none (required)" = None, + x0: "a Nml2Quantity_none (required)" = None, + y0: "a Nml2Quantity_none (required)" = None, + z0: "a Nml2Quantity_none (required)" = None, + v_scaling: "a Nml2Quantity_voltage (required)" = None, gds_collector_=None, **kwargs_, ): @@ -60506,23 +60705,23 @@ class AdExIaFCell(BaseCellMembPotCap): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - C=None, - g_l=None, - EL=None, - reset=None, - VT=None, - thresh=None, - del_t=None, - tauw=None, - refract=None, - a=None, - b=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + C: "a Nml2Quantity_capacitance (required)" = None, + g_l: "a Nml2Quantity_conductance (required)" = None, + EL: "a Nml2Quantity_voltage (required)" = None, + reset: "a Nml2Quantity_voltage (required)" = None, + VT: "a Nml2Quantity_voltage (required)" = None, + thresh: "a Nml2Quantity_voltage (required)" = None, + del_t: "a Nml2Quantity_voltage (required)" = None, + tauw: "a Nml2Quantity_time (required)" = None, + refract: "a Nml2Quantity_time (required)" = None, + a: "a Nml2Quantity_conductance (required)" = None, + b: "a Nml2Quantity_current (required)" = None, gds_collector_=None, **kwargs_, ): @@ -61095,22 +61294,22 @@ class Izhikevich2007Cell(BaseCellMembPotCap): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - C=None, - v0=None, - k=None, - vr=None, - vt=None, - vpeak=None, - a=None, - b=None, - c=None, - d=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + C: "a Nml2Quantity_capacitance (required)" = None, + v0: "a Nml2Quantity_voltage (required)" = None, + k: "a Nml2Quantity_conductancePerVoltage (required)" = None, + vr: "a Nml2Quantity_voltage (required)" = None, + vt: "a Nml2Quantity_voltage (required)" = None, + vpeak: "a Nml2Quantity_voltage (required)" = None, + a: "a Nml2Quantity_pertime (required)" = None, + b: "a Nml2Quantity_conductance (required)" = None, + c: "a Nml2Quantity_voltage (required)" = None, + d: "a Nml2Quantity_current (required)" = None, gds_collector_=None, **kwargs_, ): @@ -61652,18 +61851,18 @@ class IafRefCell(IafCell): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - leak_reversal=None, - thresh=None, - reset=None, - C=None, - leak_conductance=None, - refract=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + leak_reversal: "a Nml2Quantity_voltage (required)" = None, + thresh: "a Nml2Quantity_voltage (required)" = None, + reset: "a Nml2Quantity_voltage (required)" = None, + C: "a Nml2Quantity_capacitance (required)" = None, + leak_conductance: "a Nml2Quantity_conductance (required)" = None, + refract: "a Nml2Quantity_time (required)" = None, gds_collector_=None, **kwargs_, ): @@ -61899,17 +62098,17 @@ class IafTauRefCell(IafTauCell): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - leak_reversal=None, - thresh=None, - reset=None, - tau=None, - refract=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + leak_reversal: "a Nml2Quantity_voltage (required)" = None, + thresh: "a Nml2Quantity_voltage (required)" = None, + reset: "a Nml2Quantity_voltage (required)" = None, + tau: "a Nml2Quantity_time (required)" = None, + refract: "a Nml2Quantity_time (required)" = None, gds_collector_=None, **kwargs_, ): @@ -62149,16 +62348,16 @@ class DoubleSynapse(BaseVoltageDepSynapse): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - synapse1=None, - synapse2=None, - synapse1_path=None, - synapse2_path=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + synapse1: "a NmlId (required)" = None, + synapse2: "a NmlId (required)" = None, + synapse1_path: "a string (required)" = None, + synapse2_path: "a string (required)" = None, gds_collector_=None, **kwargs_, ): @@ -62444,14 +62643,14 @@ class AlphaCurrentSynapse(BaseCurrentBasedSynapse): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - tau=None, - ibase=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + tau: "a Nml2Quantity_time (required)" = None, + ibase: "a Nml2Quantity_current (required)" = None, gds_collector_=None, **kwargs_, ): @@ -62754,15 +62953,15 @@ class BaseConductanceBasedSynapseTwo(BaseVoltageDepSynapse): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - gbase1=None, - gbase2=None, - erev=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + gbase1: "a Nml2Quantity_conductance (required)" = None, + gbase2: "a Nml2Quantity_conductance (required)" = None, + erev: "a Nml2Quantity_voltage (required)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -63119,14 +63318,14 @@ class BaseConductanceBasedSynapse(BaseVoltageDepSynapse): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - gbase=None, - erev=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + gbase: "a Nml2Quantity_conductance (required)" = None, + erev: "a Nml2Quantity_voltage (required)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -63453,25 +63652,25 @@ class IonChannelVShift(IonChannel): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - q10_conductance_scalings=None, - species=None, - type=None, - conductance=None, - gates=None, - gate_hh_rates=None, - gate_h_hrates_taus=None, - gate_hh_tau_infs=None, - gate_h_hrates_infs=None, - gate_h_hrates_tau_infs=None, - gate_hh_instantaneouses=None, - gate_fractionals=None, - v_shift=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + q10_conductance_scalings: "list of Q10ConductanceScaling(s) (optional)" = None, + species: "a NmlId (optional)" = None, + type: "a channelTypes (optional)" = None, + conductance: "a Nml2Quantity_conductance (optional)" = None, + gates: "list of GateHHUndetermined(s) (optional)" = None, + gate_hh_rates: "list of GateHHRates(s) (optional)" = None, + gate_h_hrates_taus: "list of GateHHRatesTau(s) (optional)" = None, + gate_hh_tau_infs: "list of GateHHTauInf(s) (optional)" = None, + gate_h_hrates_infs: "list of GateHHRatesInf(s) (optional)" = None, + gate_h_hrates_tau_infs: "list of GateHHRatesTauInf(s) (optional)" = None, + gate_hh_instantaneouses: "list of GateHHInstantaneous(s) (optional)" = None, + gate_fractionals: "list of GateFractional(s) (optional)" = None, + v_shift: "a Nml2Quantity_voltage (required)" = None, gds_collector_=None, **kwargs_, ): @@ -63715,24 +63914,24 @@ class IonChannelHH(IonChannel): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - q10_conductance_scalings=None, - species=None, - type=None, - conductance=None, - gates=None, - gate_hh_rates=None, - gate_h_hrates_taus=None, - gate_hh_tau_infs=None, - gate_h_hrates_infs=None, - gate_h_hrates_tau_infs=None, - gate_hh_instantaneouses=None, - gate_fractionals=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + q10_conductance_scalings: "list of Q10ConductanceScaling(s) (optional)" = None, + species: "a NmlId (optional)" = None, + type: "a channelTypes (optional)" = None, + conductance: "a Nml2Quantity_conductance (optional)" = None, + gates: "list of GateHHUndetermined(s) (optional)" = None, + gate_hh_rates: "list of GateHHRates(s) (optional)" = None, + gate_h_hrates_taus: "list of GateHHRatesTau(s) (optional)" = None, + gate_hh_tau_infs: "list of GateHHTauInf(s) (optional)" = None, + gate_h_hrates_infs: "list of GateHHRatesInf(s) (optional)" = None, + gate_h_hrates_tau_infs: "list of GateHHRatesTauInf(s) (optional)" = None, + gate_hh_instantaneouses: "list of GateHHInstantaneous(s) (optional)" = None, + gate_fractionals: "list of GateFractional(s) (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -63929,22 +64128,22 @@ class IF_curr_exp(basePyNNIaFCell): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - cm=None, - i_offset=None, - tau_syn_E=None, - tau_syn_I=None, - v_init=None, - tau_m=None, - tau_refrac=None, - v_reset=None, - v_rest=None, - v_thresh=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + cm: "a float (required)" = None, + i_offset: "a float (required)" = None, + tau_syn_E: "a float (required)" = None, + tau_syn_I: "a float (required)" = None, + v_init: "a float (required)" = None, + tau_m: "a float (required)" = None, + tau_refrac: "a float (required)" = None, + v_reset: "a float (required)" = None, + v_rest: "a float (required)" = None, + v_thresh: "a float (required)" = None, gds_collector_=None, **kwargs_, ): @@ -64139,22 +64338,22 @@ class IF_curr_alpha(basePyNNIaFCell): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - cm=None, - i_offset=None, - tau_syn_E=None, - tau_syn_I=None, - v_init=None, - tau_m=None, - tau_refrac=None, - v_reset=None, - v_rest=None, - v_thresh=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + cm: "a float (required)" = None, + i_offset: "a float (required)" = None, + tau_syn_E: "a float (required)" = None, + tau_syn_I: "a float (required)" = None, + v_init: "a float (required)" = None, + tau_m: "a float (required)" = None, + tau_refrac: "a float (required)" = None, + v_reset: "a float (required)" = None, + v_rest: "a float (required)" = None, + v_thresh: "a float (required)" = None, gds_collector_=None, **kwargs_, ): @@ -64360,24 +64559,24 @@ class basePyNNIaFCondCell(basePyNNIaFCell): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - cm=None, - i_offset=None, - tau_syn_E=None, - tau_syn_I=None, - v_init=None, - tau_m=None, - tau_refrac=None, - v_reset=None, - v_rest=None, - v_thresh=None, - e_rev_E=None, - e_rev_I=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + cm: "a float (required)" = None, + i_offset: "a float (required)" = None, + tau_syn_E: "a float (required)" = None, + tau_syn_I: "a float (required)" = None, + v_init: "a float (required)" = None, + tau_m: "a float (required)" = None, + tau_refrac: "a float (required)" = None, + v_reset: "a float (required)" = None, + v_rest: "a float (required)" = None, + v_thresh: "a float (required)" = None, + e_rev_E: "a float (required)" = None, + e_rev_I: "a float (required)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -64610,16 +64809,16 @@ class ContinuousConnectionInstance(ContinuousConnection): def __init__( self, - id=None, - neuro_lex_id=None, - pre_cell=None, - pre_segment="0", - pre_fraction_along="0.5", - post_cell=None, - post_segment="0", - post_fraction_along="0.5", - pre_component=None, - post_component=None, + id: "a NonNegativeInteger (required)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + pre_cell: "a string (required)" = None, + pre_segment: "a NonNegativeInteger (optional)" = "0", + pre_fraction_along: "a ZeroToOne (optional)" = "0.5", + post_cell: "a string (required)" = None, + post_segment: "a NonNegativeInteger (optional)" = "0", + post_fraction_along: "a ZeroToOne (optional)" = "0.5", + pre_component: "a NmlId (required)" = None, + post_component: "a NmlId (required)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -64840,15 +65039,15 @@ class ElectricalConnectionInstance(ElectricalConnection): def __init__( self, - id=None, - neuro_lex_id=None, - pre_cell=None, - pre_segment="0", - pre_fraction_along="0.5", - post_cell=None, - post_segment="0", - post_fraction_along="0.5", - synapse=None, + id: "a NonNegativeInteger (required)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + pre_cell: "a string (required)" = None, + pre_segment: "a NonNegativeInteger (optional)" = "0", + pre_fraction_along: "a ZeroToOne (optional)" = "0.5", + post_cell: "a string (required)" = None, + post_segment: "a NonNegativeInteger (optional)" = "0", + post_fraction_along: "a ZeroToOne (optional)" = "0.5", + synapse: "a NmlId (required)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -65103,18 +65302,18 @@ class ExpThreeSynapse(BaseConductanceBasedSynapseTwo): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - gbase1=None, - gbase2=None, - erev=None, - tau_decay1=None, - tau_decay2=None, - tau_rise=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + gbase1: "a Nml2Quantity_conductance (required)" = None, + gbase2: "a Nml2Quantity_conductance (required)" = None, + erev: "a Nml2Quantity_voltage (required)" = None, + tau_decay1: "a Nml2Quantity_time (required)" = None, + tau_decay2: "a Nml2Quantity_time (required)" = None, + tau_rise: "a Nml2Quantity_time (required)" = None, gds_collector_=None, **kwargs_, ): @@ -65412,16 +65611,16 @@ class ExpTwoSynapse(BaseConductanceBasedSynapse): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - gbase=None, - erev=None, - tau_decay=None, - tau_rise=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + gbase: "a Nml2Quantity_conductance (required)" = None, + erev: "a Nml2Quantity_voltage (required)" = None, + tau_decay: "a Nml2Quantity_time (required)" = None, + tau_rise: "a Nml2Quantity_time (required)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -65703,15 +65902,15 @@ class ExpOneSynapse(BaseConductanceBasedSynapse): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - gbase=None, - erev=None, - tau_decay=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + gbase: "a Nml2Quantity_conductance (required)" = None, + erev: "a Nml2Quantity_voltage (required)" = None, + tau_decay: "a Nml2Quantity_time (required)" = None, gds_collector_=None, **kwargs_, ): @@ -65945,15 +66144,15 @@ class AlphaSynapse(BaseConductanceBasedSynapse): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - gbase=None, - erev=None, - tau=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + gbase: "a Nml2Quantity_conductance (required)" = None, + erev: "a Nml2Quantity_voltage (required)" = None, + tau: "a Nml2Quantity_time (required)" = None, gds_collector_=None, **kwargs_, ): @@ -66215,29 +66414,29 @@ class EIF_cond_exp_isfa_ista(basePyNNIaFCondCell): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - cm=None, - i_offset=None, - tau_syn_E=None, - tau_syn_I=None, - v_init=None, - tau_m=None, - tau_refrac=None, - v_reset=None, - v_rest=None, - v_thresh=None, - e_rev_E=None, - e_rev_I=None, - a=None, - b=None, - delta_T=None, - tau_w=None, - v_spike=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + cm: "a float (required)" = None, + i_offset: "a float (required)" = None, + tau_syn_E: "a float (required)" = None, + tau_syn_I: "a float (required)" = None, + v_init: "a float (required)" = None, + tau_m: "a float (required)" = None, + tau_refrac: "a float (required)" = None, + v_reset: "a float (required)" = None, + v_rest: "a float (required)" = None, + v_thresh: "a float (required)" = None, + e_rev_E: "a float (required)" = None, + e_rev_I: "a float (required)" = None, + a: "a float (required)" = None, + b: "a float (required)" = None, + delta_T: "a float (required)" = None, + tau_w: "a float (required)" = None, + v_spike: "a float (required)" = None, extensiontype_=None, gds_collector_=None, **kwargs_, @@ -66539,24 +66738,24 @@ class IF_cond_exp(basePyNNIaFCondCell): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - cm=None, - i_offset=None, - tau_syn_E=None, - tau_syn_I=None, - v_init=None, - tau_m=None, - tau_refrac=None, - v_reset=None, - v_rest=None, - v_thresh=None, - e_rev_E=None, - e_rev_I=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + cm: "a float (required)" = None, + i_offset: "a float (required)" = None, + tau_syn_E: "a float (required)" = None, + tau_syn_I: "a float (required)" = None, + v_init: "a float (required)" = None, + tau_m: "a float (required)" = None, + tau_refrac: "a float (required)" = None, + v_reset: "a float (required)" = None, + v_rest: "a float (required)" = None, + v_thresh: "a float (required)" = None, + e_rev_E: "a float (required)" = None, + e_rev_I: "a float (required)" = None, gds_collector_=None, **kwargs_, ): @@ -66757,24 +66956,24 @@ class IF_cond_alpha(basePyNNIaFCondCell): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - cm=None, - i_offset=None, - tau_syn_E=None, - tau_syn_I=None, - v_init=None, - tau_m=None, - tau_refrac=None, - v_reset=None, - v_rest=None, - v_thresh=None, - e_rev_E=None, - e_rev_I=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + cm: "a float (required)" = None, + i_offset: "a float (required)" = None, + tau_syn_E: "a float (required)" = None, + tau_syn_I: "a float (required)" = None, + v_init: "a float (required)" = None, + tau_m: "a float (required)" = None, + tau_refrac: "a float (required)" = None, + v_reset: "a float (required)" = None, + v_rest: "a float (required)" = None, + v_thresh: "a float (required)" = None, + e_rev_E: "a float (required)" = None, + e_rev_I: "a float (required)" = None, gds_collector_=None, **kwargs_, ): @@ -66955,17 +67154,17 @@ class ContinuousConnectionInstanceW(ContinuousConnectionInstance): def __init__( self, - id=None, - neuro_lex_id=None, - pre_cell=None, - pre_segment="0", - pre_fraction_along="0.5", - post_cell=None, - post_segment="0", - post_fraction_along="0.5", - pre_component=None, - post_component=None, - weight=None, + id: "a NonNegativeInteger (required)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + pre_cell: "a string (required)" = None, + pre_segment: "a NonNegativeInteger (optional)" = "0", + pre_fraction_along: "a ZeroToOne (optional)" = "0.5", + post_cell: "a string (required)" = None, + post_segment: "a NonNegativeInteger (optional)" = "0", + post_fraction_along: "a ZeroToOne (optional)" = "0.5", + pre_component: "a NmlId (required)" = None, + post_component: "a NmlId (required)" = None, + weight: "a float (required)" = None, gds_collector_=None, **kwargs_, ): @@ -67192,16 +67391,16 @@ class ElectricalConnectionInstanceW(ElectricalConnectionInstance): def __init__( self, - id=None, - neuro_lex_id=None, - pre_cell=None, - pre_segment="0", - pre_fraction_along="0.5", - post_cell=None, - post_segment="0", - post_fraction_along="0.5", - synapse=None, - weight=None, + id: "a NonNegativeInteger (required)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + pre_cell: "a string (required)" = None, + pre_segment: "a NonNegativeInteger (optional)" = "0", + pre_fraction_along: "a ZeroToOne (optional)" = "0.5", + post_cell: "a string (required)" = None, + post_segment: "a NonNegativeInteger (optional)" = "0", + post_fraction_along: "a ZeroToOne (optional)" = "0.5", + synapse: "a NmlId (required)" = None, + weight: "a float (required)" = None, gds_collector_=None, **kwargs_, ): @@ -67454,18 +67653,18 @@ class BlockingPlasticSynapse(ExpTwoSynapse): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - gbase=None, - erev=None, - tau_decay=None, - tau_rise=None, - plasticity_mechanism=None, - block_mechanism=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + gbase: "a Nml2Quantity_conductance (required)" = None, + erev: "a Nml2Quantity_voltage (required)" = None, + tau_decay: "a Nml2Quantity_time (required)" = None, + tau_rise: "a Nml2Quantity_time (required)" = None, + plasticity_mechanism: "a PlasticityMechanism (optional)" = None, + block_mechanism: "a BlockMechanism (optional)" = None, gds_collector_=None, **kwargs_, ): @@ -67743,29 +67942,29 @@ class EIF_cond_alpha_isfa_ista(EIF_cond_exp_isfa_ista): def __init__( self, - id=None, - metaid=None, - notes=None, - properties=None, - annotation=None, - neuro_lex_id=None, - cm=None, - i_offset=None, - tau_syn_E=None, - tau_syn_I=None, - v_init=None, - tau_m=None, - tau_refrac=None, - v_reset=None, - v_rest=None, - v_thresh=None, - e_rev_E=None, - e_rev_I=None, - a=None, - b=None, - delta_T=None, - tau_w=None, - v_spike=None, + id: "a NmlId (required)" = None, + metaid: "a MetaId (optional)" = None, + notes: "a string (optional)" = None, + properties: "list of Property(s) (optional)" = None, + annotation: "a Annotation (optional)" = None, + neuro_lex_id: "a NeuroLexId (optional)" = None, + cm: "a float (required)" = None, + i_offset: "a float (required)" = None, + tau_syn_E: "a float (required)" = None, + tau_syn_I: "a float (required)" = None, + v_init: "a float (required)" = None, + tau_m: "a float (required)" = None, + tau_refrac: "a float (required)" = None, + v_reset: "a float (required)" = None, + v_rest: "a float (required)" = None, + v_thresh: "a float (required)" = None, + e_rev_E: "a float (required)" = None, + e_rev_I: "a float (required)" = None, + a: "a float (required)" = None, + b: "a float (required)" = None, + delta_T: "a float (required)" = None, + tau_w: "a float (required)" = None, + v_spike: "a float (required)" = None, gds_collector_=None, **kwargs_, ): From ddb5c7b5683da887e0e0c645168be13dbef5d691 Mon Sep 17 00:00:00 2001 From: "Ankur Sinha (Ankur Sinha Gmail)" Date: Tue, 15 Oct 2024 16:42:14 +0100 Subject: [PATCH 7/8] fix(nml): correct detection of anyattributes_ There are two ways of doing this: - check the source in `__init__` as I've done here - create an object of the class to see if it has the attribute I expect the latter is more expensive, so I've used the first method for the moment. --- neuroml/nml/generatedssupersuper.py | 62 ++++++++++++++++++----------- 1 file changed, 38 insertions(+), 24 deletions(-) diff --git a/neuroml/nml/generatedssupersuper.py b/neuroml/nml/generatedssupersuper.py index e790cb6..cf26ce9 100644 --- a/neuroml/nml/generatedssupersuper.py +++ b/neuroml/nml/generatedssupersuper.py @@ -198,34 +198,48 @@ def component_factory(cls, component_type, validate=True, **kwargs): # handle Components that allow "anyAttributes_": these are included in # the schema to allow use of user-defined Components - comp_type_class_atts = inspect.getmembers(comp_type_class, inspect.isroutine) - cls.logger.debug(f"Atts for {comp_type_class} are: {comp_type_class_atts}") + comp_type_class_members = inspect.getmembers(comp_type_class, inspect.isroutine) + comp_type_class_init = None + for m in comp_type_class_members: + name, value = m + if name == "__init__": + comp_type_class_init = value + break + + # all component type classes should have a constructor + assert comp_type_class_init is not None + + cls.logger.debug(f"Got init method: {comp_type_class_init}") + init_source = inspect.getsource(comp_type_class_init) + cls.logger.debug(f"Got init source: {init_source}") comp_type_class_members = comp_type_class._get_members() - # if we do have an anyattribute, we need to split the kwargs into + # If we do have an anyattribute, we need to split the kwargs into # members and other bits that will populate the anyattribute because - # the anyattribute needs to be explicitly populated by us - for att in comp_type_class_atts: - atname = att[0] - if atname == "_exportAttributes": - new_comp_args = kwargs.copy() - member_args = {} - for m in comp_type_class_members: - try: - member_args[m.get_name()] = new_comp_args.pop(m.get_name()) - except KeyError: - cls.logger.error( - f"Error: {comp_type_class} requires {m.get_name()}" - ) + # the anyattribute needs to be explicitly populated by us. + + # Unfortunately, there isn't a better way of detecting if a class takes + # anyAttributes than to check its source. We could instantiate objects + # of each class, but that's going to be more expensive. + if "self.anyAttributes_ = {}" in init_source: + new_comp_args = kwargs.copy() + member_args = {} + for m in comp_type_class_members: + try: + member_args[m.get_name()] = new_comp_args.pop(m.get_name()) + except KeyError: + cls.logger.error( + f"Error: {comp_type_class} requires {m.get_name()}" + ) - # create new class with args that match members - comp = comp_type_class(**member_args) - # populate anyattributes with remaining kwargs - comp.anyAttributes_ = new_comp_args - logging.warning( - "New Component created. Note: This will NOT be validated against the schema." - ) - return comp + # create new class with args that match members + comp = comp_type_class(**member_args) + # populate anyattributes with remaining kwargs + comp.anyAttributes_ = new_comp_args + cls.logger.warning( + "New Component created. Note: This will NOT be validated against the schema." + ) + return comp # if it does not have an anyattribute, treat as general comp = comp_type_class(**kwargs) From eb37d3275e6df5aa17c3939a5f5526e79391f739 Mon Sep 17 00:00:00 2001 From: "Ankur Sinha (Ankur Sinha Gmail)" Date: Tue, 15 Oct 2024 18:28:49 +0100 Subject: [PATCH 8/8] chore: remove extra debug msgs --- neuroml/nml/generatedssupersuper.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/neuroml/nml/generatedssupersuper.py b/neuroml/nml/generatedssupersuper.py index cf26ce9..0bea3a7 100644 --- a/neuroml/nml/generatedssupersuper.py +++ b/neuroml/nml/generatedssupersuper.py @@ -209,9 +209,7 @@ def component_factory(cls, component_type, validate=True, **kwargs): # all component type classes should have a constructor assert comp_type_class_init is not None - cls.logger.debug(f"Got init method: {comp_type_class_init}") init_source = inspect.getsource(comp_type_class_init) - cls.logger.debug(f"Got init source: {init_source}") comp_type_class_members = comp_type_class._get_members() # If we do have an anyattribute, we need to split the kwargs into