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))