def __init__(self, name, parameters=(), aliases=(), constants=()):
self._name = validate_identifier(name)
BaseALObject.__init__(self)
DocumentLevelObject.__init__(self)
ContainerObject.__init__(self)
# Caches the dimension resolver so that it can be reused in subsequent
# calls
self._dimension_resolver = None
# Turn any strings in the parameter list into Parameters:
param_types = (basestring, Parameter)
param_td = filter_discrete_types(parameters, param_types)
params_from_strings = [Parameter(s) for s in param_td[basestring]]
parameters = param_td[Parameter] + params_from_strings
# Load the aliases as objects or strings:
aliases = normalise_parameter_as_list(aliases)
alias_td = filter_discrete_types(aliases, (basestring, Alias))
aliases_from_strs = [Alias.from_str(o) for o in alias_td[basestring]]
aliases = alias_td[Alias] + aliases_from_strs
constants = normalise_parameter_as_list(constants)
self.add(*parameters)
self.add(*aliases)
self.add(*constants)
def __init__(self, name, es, f, t):
AnnotatedNineMLObject.__init__(self)
ContainerObject.__init__(self)
self.name = name
self.add(*es)
self.f = f
self.t = t
def __init__(self, name, parameters=(), aliases=(), constants=()):
self._name = validate_identifier(name)
BaseALObject.__init__(self)
DocumentLevelObject.__init__(self)
ContainerObject.__init__(self)
# Caches the dimension resolver so that it can be reused in subsequent
# calls
self._dimension_resolver = None
# Turn any strings in the parameter list into Parameters:
param_types = (basestring, Parameter)
param_td = filter_discrete_types(parameters, param_types)
params_from_strings = [Parameter(s) for s in param_td[basestring]]
parameters = param_td[Parameter] + params_from_strings
# Load the aliases as objects or strings:
aliases = normalise_parameter_as_list(aliases)
alias_td = filter_discrete_types(aliases, (basestring, Alias))
aliases_from_strs = [Alias.from_str(o) for o in alias_td[basestring]]
aliases = alias_td[Alias] + aliases_from_strs
constants = normalise_parameter_as_list(constants)
self.add(*parameters)
self.add(*aliases)
self.add(*constants)
def __init__(self, name, es, f, t):
AnnotatedNineMLObject.__init__(self)
ContainerObject.__init__(self)
self.name = name
self.add(*es)
self.f = f
self.t = t
def __init__(self, name, definition, properties={}):
"""
Create a new component_class with the given name, definition and
properties, or create a prototype to another component_class that will
be resolved later.
"""
self._name = validate_identifier(name)
BaseULObject.__init__(self)
DocumentLevelObject.__init__(self)
ContainerObject.__init__(self)
if isinstance(definition, basestring):
if "#" in definition:
defn_url, name = definition.split("#")
else:
raise NineMLUsageError(
"Must provide name of class using '#' syntax when "
"providing definition as url string ('{}')".format(
definition))
definition = Definition(name=name, document=None, url=defn_url)
elif (isinstance(definition, ComponentClass)
or definition.nineml_type in ('Dynamics', 'MultiDynamics')):
definition = Definition(definition)
elif (isinstance(definition, Component) or definition.nineml_type
in ('DynamicsProperties', 'MultiDynamicsProperties')):
definition = Prototype(definition)
elif definition.nineml_type not in ('Definition', 'Prototype'):
raise ValueError("'definition' must be either a 'Definition', "
"'Prototype' element or url pointing to a "
"dynamics class")
self._definition = definition
if isinstance(properties, dict):
properties = (Property(name, qty)
for name, qty in properties.items())
self.add(*properties)
self.check_properties()
def __init__(self, name, a, bs, c, d, g):
ContainerObject.__init__(self)
self.name = name
DocumentLevelObject.__init__(self)
self.a = a
self.add(*bs)
self.c = c
self.d = d
self.g = g
def __init__(self, name, a, bs, c, d, g):
ContainerObject.__init__(self)
self.name = name
DocumentLevelObject.__init__(self)
self.a = a
self.add(*bs)
self.c = c
self.d = d
self.g = g
def __init__(self,
name,
pre,
post,
response,
delay,
connectivity=None,
connection_rule_properties=None,
plasticity=None,
port_connections=None,
analog_port_connections=None,
event_port_connections=None,
connectivity_class=Connectivity,
**kwargs):
"""
Create a new projection.
"""
self._name = validate_identifier(name)
BaseULObject.__init__(self)
ContainerObject.__init__(self)
DocumentLevelObject.__init__(self)
assert isinstance(name, basestring)
assert isinstance(delay, Quantity)
assert isinstance(pre, (Population, Selection))
assert isinstance(post, (Population, Selection))
assert isinstance(response, DynamicsProperties)
assert isinstance(plasticity, (DynamicsProperties, type(None)))
self._pre = pre
self._post = post
self._response = response
self._plasticity = plasticity
if connectivity is not None:
assert isinstance(connectivity, Connectivity)
if connection_rule_properties is not None:
raise NineMLUsageError(
"Cannot provide both connectivty and "
"connection_rule_properties as kwargs to projection class")
self._connectivity = connectivity
else:
self._connectivity = connectivity_class(connection_rule_properties,
pre.size, post.size,
**kwargs)
self._delay = delay
if port_connections is None:
port_connections = []
if analog_port_connections is None:
analog_port_connections = []
if event_port_connections is None:
event_port_connections = []
for port_connection in chain(port_connections, event_port_connections,
analog_port_connections):
if isinstance(port_connection, tuple):
port_connection = BasePortConnection.from_tuple(
port_connection, self)
port_connection.bind(self, to_roles=True)
self.add(port_connection)
def __init__(self, name, populations=[], projections=[], selections=[]):
# better would be *items, then sort by type, taking the name from the
# item
self._name = validate_identifier(name)
BaseULObject.__init__(self)
DocumentLevelObject.__init__(self)
ContainerObject.__init__(self)
self.add(*populations)
self.add(*projections)
self.add(*selections)
def __init__(self, *args, **kwargs):
BaseALObject.__init__(self)
ContainerObject.__init__(self)
valid_kwargs = ('name', 'transitions', 'on_events', 'on_conditions',
'time_derivatives', 'aliases')
for arg in kwargs:
if arg not in valid_kwargs:
err = 'Unexpected Arg: %s' % arg
raise NineMLUsageError(err)
name = kwargs.get('name', None)
if name is None:
self._name = 'default'
else:
self._name = validate_identifier(name)
validate_identifier(self._name)
# Get Time derivatives from args or kwargs
kw_tds = normalise_parameter_as_list(
kwargs.get('time_derivatives', None))
time_derivatives = list(args) + kw_tds
# Un-named arguments are time_derivatives:
time_derivatives = normalise_parameter_as_list(time_derivatives)
# time_derivatives.extend( args )
td_types = (basestring, TimeDerivative)
td_type_dict = filter_discrete_types(time_derivatives, td_types)
td_from_str = [TimeDerivative.from_str(o)
for o in td_type_dict[basestring]]
time_derivatives = td_type_dict[TimeDerivative] + td_from_str
# Check for double definitions:
td_dep_vars = [td.variable for td in time_derivatives]
assert_no_duplicates(
td_dep_vars,
("Multiple time derivatives found for the same state variable "
"in regime '{}' (found '{}')".format(
self.name,
"', '".join(td.variable for td in time_derivatives))))
self.add(*time_derivatives)
# We support passing in 'transitions', which is a list of both OnEvents
# and OnConditions as well as separate on_conditions and on_events.
transitions = normalise_parameter_as_list(
kwargs.get('transitions', None))
self.add(*transitions)
on_conditions = normalise_parameter_as_list(
kwargs.get('on_conditions', None))
self.add(*on_conditions)
on_events = normalise_parameter_as_list(
kwargs.get('on_events', None))
self.add(*on_events)
# Add regime specific aliases
aliases = normalise_parameter_as_list(kwargs.get('aliases', None))
self.add(*aliases)
def __init__(self, branches=None):
ContainerObject.__init__(self)
if isinstance(branches, OrderedDefaultListDict):
self._branches = branches
else:
self._branches = OrderedDefaultListDict()
if branches is not None:
for i, branch in enumerate(branches):
branch._abs_index = i
branch._rel_index = len(self._branches[(branch.name,
branch.ns)])
self._branches[(branch.name, branch.ns)].append(branch)
def __init__(self, name, dynamics_properties, synapse_propertiess=[],
connection_property_sets=[]):
# Initiate inherited base classes
BaseULObject.__init__(self)
DocumentLevelObject.__init__(self)
ContainerObject.__init__(self)
WithSynapsesProperties.__init__(self, name, dynamics_properties,
synapse_propertiess,
connection_property_sets)
# Create references to all dynamics member variables so that inherited
# MultiDynamicsProperties properties and methods can find them.
self._annotations = dynamics_properties._annotations
self._sub_components = dynamics_properties._sub_components
def __init__(self, name, dynamics_properties, port_connections=None,
analog_port_connections=None, event_port_connections=None):
super(SynapseProperties, self).__init__()
ContainerObject.__init__(self)
self._name = validate_identifier(name)
self._dynamics_properties = dynamics_properties.clone()
if port_connections is None:
port_connections = []
if analog_port_connections is None:
analog_port_connections = []
if event_port_connections is None:
event_port_connections = []
for port_conn in chain(port_connections, analog_port_connections,
event_port_connections):
self.add(port_conn.clone())
def __init__(self, name, dynamics_properties, synapses_properties=[],
connection_property_sets=[]):
WithSynapsesProperties.__init__(self, name, dynamics_properties,
synapses_properties,
connection_property_sets)
# Initiate inherited base classes
BaseULObject.__init__(self)
DocumentLevelObject.__init__(self, dynamics_properties.document)
ContainerObject.__init__(self)
# Create references to all dynamics member variables so that inherited
# DynamicsProperties properties and methods can find them.
self._annotations = dynamics_properties._annotations
self._properties = dynamics_properties._properties
self._initial_values = dynamics_properties._initial_values
self._initial_regime = dynamics_properties._initial_regime
def __init__(self,
name,
dynamics_properties,
synapse_propertiess=[],
connection_property_sets=[]):
# Initiate inherited base classes
BaseULObject.__init__(self)
DocumentLevelObject.__init__(self)
ContainerObject.__init__(self)
WithSynapsesProperties.__init__(self, name, dynamics_properties,
synapse_propertiess,
connection_property_sets)
# Create references to all dynamics member variables so that inherited
# MultiDynamicsProperties properties and methods can find them.
self._annotations = dynamics_properties._annotations
self._sub_components = dynamics_properties._sub_components
def __init__(self, name, pre, post, response, delay, connectivity=None,
connection_rule_properties=None,
plasticity=None, port_connections=None,
analog_port_connections=None, event_port_connections=None,
connectivity_class=Connectivity, **kwargs):
"""
Create a new projection.
"""
self._name = validate_identifier(name)
BaseULObject.__init__(self)
ContainerObject.__init__(self)
DocumentLevelObject.__init__(self)
assert isinstance(name, basestring)
assert isinstance(delay, Quantity)
assert isinstance(pre, (Population, Selection))
assert isinstance(post, (Population, Selection))
assert isinstance(response, DynamicsProperties)
assert isinstance(plasticity, (DynamicsProperties, type(None)))
self._pre = pre
self._post = post
self._response = response
self._plasticity = plasticity
if connectivity is not None:
assert isinstance(connectivity, Connectivity)
if connection_rule_properties is not None:
raise NineMLUsageError(
"Cannot provide both connectivty and "
"connection_rule_properties as kwargs to projection class")
self._connectivity = connectivity
else:
self._connectivity = connectivity_class(
connection_rule_properties, pre.size, post.size, **kwargs)
self._delay = delay
if port_connections is None:
port_connections = []
if analog_port_connections is None:
analog_port_connections = []
if event_port_connections is None:
event_port_connections = []
for port_connection in chain(port_connections,
event_port_connections,
analog_port_connections):
if isinstance(port_connection, tuple):
port_connection = BasePortConnection.from_tuple(
port_connection, self)
port_connection.bind(self, to_roles=True)
self.add(port_connection)
def __init__(self,
state_assignments=None,
output_events=None,
target_regime_name=None):
"""Abstract class representing a transition from one Regime to
another.
Transition objects are not created directly, but via the subclasses
OnEvent and OnCondition.
Parameters
----------
state_assignments: list(StateAssignment)
A list of the state-assignments performed
when this transition occurs. Objects in this list are either
`string` (e.g A = A+13) or StateAssignment objects.
output_events: list(OutputEvent)
A list of OutputEvent objects emitted when
this transition occurs.
target_regime_name: str | None
The name of the regime to go into after this
transition. `None` implies staying in the same regime. This has
to be specified as a string, not the object, because in general the
|Regime| object is not yet constructed. This is automatically
resolved by the Dynamics during construction.
"""
BaseALObject.__init__(self)
ContainerObject.__init__(self)
# Load state-assignment objects as strings or StateAssignment objects
state_assignments = state_assignments or []
sa_types = (basestring, StateAssignment)
sa_type_dict = filter_discrete_types(state_assignments, sa_types)
sa_from_str = [
StateAssignment.from_str(o) for o in sa_type_dict[basestring]
]
self.add(*(sa_type_dict[StateAssignment] + sa_from_str))
self.add(*normalise_parameter_as_list(output_events))
self._target_regime_name = (validate_identifier(target_regime_name) if
target_regime_name is not None else None)
self._target_regime = None
self._source_regime = None
def __init__(self, name, dynamics, synapses=[],
connection_parameter_sets=[]):
WithSynapses.__init__(self, name, dynamics, synapses,
connection_parameter_sets)
BaseALObject.__init__(self)
DocumentLevelObject.__init__(self, dynamics.document)
ContainerObject.__init__(self)
# Create references to all dynamics member variables so that inherited
# Dynamics properties and methods can find them.
self._annotations = dynamics._annotations
self._sub_components = dynamics._sub_components
self._analog_send_ports = dynamics._analog_send_ports
self._analog_receive_ports = dynamics._analog_receive_ports
self._analog_reduce_ports = dynamics._analog_reduce_ports
self._event_send_ports = dynamics._event_send_ports
self._event_receive_ports = dynamics._event_receive_ports
self._analog_port_connections = dynamics._analog_port_connections
self._event_port_connections = dynamics._event_port_connections
def __init__(self,
name,
dynamics_properties,
port_connections=None,
analog_port_connections=None,
event_port_connections=None):
super(SynapseProperties, self).__init__()
ContainerObject.__init__(self)
self._name = validate_identifier(name)
self._dynamics_properties = dynamics_properties.clone()
if port_connections is None:
port_connections = []
if analog_port_connections is None:
analog_port_connections = []
if event_port_connections is None:
event_port_connections = []
for port_conn in chain(port_connections, analog_port_connections,
event_port_connections):
self.add(port_conn.clone())
def __init__(self, state_assignments=None, output_events=None,
target_regime_name=None):
"""Abstract class representing a transition from one Regime to
another.
Transition objects are not created directly, but via the subclasses
OnEvent and OnCondition.
Parameters
----------
state_assignments: list(StateAssignment)
A list of the state-assignments performed
when this transition occurs. Objects in this list are either
`string` (e.g A = A+13) or StateAssignment objects.
output_events: list(OutputEvent)
A list of OutputEvent objects emitted when
this transition occurs.
target_regime_name: str | None
The name of the regime to go into after this
transition. `None` implies staying in the same regime. This has
to be specified as a string, not the object, because in general the
|Regime| object is not yet constructed. This is automatically
resolved by the Dynamics during construction.
"""
BaseALObject.__init__(self)
ContainerObject.__init__(self)
# Load state-assignment objects as strings or StateAssignment objects
state_assignments = state_assignments or []
sa_types = (basestring, StateAssignment)
sa_type_dict = filter_discrete_types(state_assignments, sa_types)
sa_from_str = [StateAssignment.from_str(o)
for o in sa_type_dict[basestring]]
self.add(*(sa_type_dict[StateAssignment] + sa_from_str))
self.add(*normalise_parameter_as_list(output_events))
self._target_regime_name = (
validate_identifier(target_regime_name)
if target_regime_name is not None else None)
self._target_regime = None
self._source_regime = None
def __init__(self, items, **kwargs):
BaseULObject.__init__(self, **kwargs)
ContainerObject.__init__(self, **kwargs)
items = list(items)
if all(isinstance(it, Item) for it in items):
indices = [it.index for it in items]
if min(indices) < 0 or max(indices) > len(indices):
raise NineMLUsageError(
"Indices are not contiguous, have duplicates, or don't "
"start from 0 ({})"
.format(', '.join(str(i) for i in indices)))
self.add(*items)
elif any(isinstance(it, Item) for it in items):
raise NineMLUsageError(
"Cannot mix Items and Populations/Selections in Concatenate "
"__init__ method ({})".format(', '.join(str(it)
for it in items)))
else:
self.add(*(Item(i, p) for i, p in enumerate(items)))
assert(self.num_items)
def __init__(self, name, definition, properties={}):
"""
Create a new component_class with the given name, definition and
properties, or create a prototype to another component_class that will
be resolved later.
"""
self._name = validate_identifier(name)
BaseULObject.__init__(self)
DocumentLevelObject.__init__(self)
ContainerObject.__init__(self)
if isinstance(definition, basestring):
if "#" in definition:
defn_url, name = definition.split("#")
else:
raise NineMLUsageError(
"Must provide name of class using '#' syntax when "
"providing definition as url string ('{}')"
.format(definition))
definition = Definition(
name=name,
document=None,
url=defn_url)
elif (isinstance(definition, ComponentClass) or
definition.nineml_type in ('Dynamics', 'MultiDynamics')):
definition = Definition(definition)
elif (isinstance(definition, Component) or
definition.nineml_type in ('DynamicsProperties',
'MultiDynamicsProperties')):
definition = Prototype(definition)
elif definition.nineml_type not in ('Definition', 'Prototype'):
raise ValueError("'definition' must be either a 'Definition', "
"'Prototype' element or url pointing to a "
"dynamics class")
self._definition = definition
if isinstance(properties, dict):
properties = (Property(name, qty)
for name, qty in properties.items())
self.add(*properties)
self.check_properties()
def __init__(self,
name,
dynamics,
synapses=[],
connection_parameter_sets=[]):
BaseALObject.__init__(self)
DocumentLevelObject.__init__(self)
ContainerObject.__init__(self)
WithSynapses.__init__(self, name, dynamics, synapses,
connection_parameter_sets)
# Create references to all dynamics member variables so that inherited
# Dynamics properties and methods can find them.
self._annotations = dynamics._annotations
self._sub_components = dynamics._sub_components
self._analog_send_port_exposures = dynamics._analog_send_port_exposures
self._analog_receive_port_exposures = (
dynamics._analog_receive_port_exposures)
self._analog_reduce_port_exposures = (
dynamics._analog_reduce_port_exposures)
self._event_send_port_exposures = dynamics._event_send_port_exposures
self._event_receive_port_exposures = (
dynamics._event_receive_port_exposures)
self._analog_port_connections = dynamics._analog_port_connections
self._event_port_connections = dynamics._event_port_connections
def __init__(self, port, properties):
super(ConnectionPropertySet, self).__init__()
ContainerObject.__init__(self)
self._port = validate_identifier(port)
for prop in properties:
self.add(prop.clone(as_class=Property))
def __init__(self, port, parameters):
super(ConnectionParameterSet, self).__init__()
ContainerObject.__init__(self)
self._port = validate_identifier(port)
for param in parameters:
self.add(param.clone(as_class=Parameter))
def __init__(self, port, properties):
super(ConnectionPropertySet, self).__init__()
ContainerObject.__init__(self)
self._port = validate_identifier(port)
for prop in properties:
self.add(prop.clone(as_class=Property))
def __init__(self, port, parameters):
super(ConnectionParameterSet, self).__init__()
ContainerObject.__init__(self)
self._port = validate_identifier(port)
for param in parameters:
self.add(param.clone(as_class=Parameter))
