def __init__(self, name, dimension=None): """StateVariable Constructor :param name: The name of the state variable. """ super(StateVariable, self).__init__() self._name = validate_identifier(name) self._dimension = dimension if dimension is not None else dimensionless assert isinstance(self._dimension, Dimension) validate_identifier(self._name)
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, 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, 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): """ Port Constructor. `name` -- The name of the port, as a `string` """ super(Port, self).__init__() self._name = validate_identifier(name)
def __init__(self, name, source, destination, source_port, destination_port, delay, connectivity=None, connection_rule_properties=None, connectivity_class=Connectivity): self._name = validate_identifier(name) BaseULObject.__init__(self) DocumentLevelObject.__init__(self) self._source = source self._destination = destination self._source_port = source_port self._destination_port = destination_port if connectivity is not None: assert isinstance(connectivity, BaseConnectivity) 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: connectivity = connectivity_class( connection_rule_properties, source.size, destination.size) self._connectivity = connectivity self._delay = delay if isinstance(source_port, Port): self._check_ports(source_port, destination_port)
def __init__(self, name, dimension, power, offset=0.0): self._name = validate_identifier(name) AnnotatedNineMLObject.__init__(self) DocumentLevelObject.__init__(self) assert isinstance(dimension, Dimension) self._dimension = dimension self._power = power self._offset = offset
def __init__(self, name, size, dynamics_properties): self._name = validate_identifier(name) BaseULObject.__init__(self) DocumentLevelObject.__init__(self) self.size = size if not dynamics_properties.component_class.is_flat: dynamics_properties = dynamics_properties.flatten(name + '_flat_dyn') self._dynamics_properties = dynamics_properties
def __init__(self, lhs, rhs, assign_to_reserved=False): ExpressionWithLHS.__init__(self, rhs) if not is_single_symbol(lhs): err = 'Expecting a single symbol on the LHS; got: %s' % lhs raise NineMLUsageError(err) if not assign_to_reserved and not is_valid_lhs_target(lhs): err = 'Invalid LHS target: %s' % lhs raise NineMLUsageError(err) self._name = validate_identifier(lhs)
def __init__(self, name, size, dynamics_properties): self._name = validate_identifier(name) BaseULObject.__init__(self) DocumentLevelObject.__init__(self) self.size = size if not dynamics_properties.component_class.is_flat: dynamics_properties = dynamics_properties.flatten( name + '_flat_dyn') self._dynamics_properties = dynamics_properties
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, sub_component_name, port_name, name=None): super(BasePortExposure, self).__init__() assert isinstance(sub_component_name, basestring) self._sub_component_name = sub_component_name assert isinstance(port_name, basestring) self._port_name = port_name self._parent = None if name is None: name = self._default_name() self._name = validate_identifier(name)
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, name, dimension=None): """Parameter Constructor `name` -- The name of the parameter. """ super(Parameter, self).__init__() self._name = validate_identifier(name) self._dimension = dimension if dimension is not None else dimensionless assert isinstance(self._dimension, Dimension), ( "dimension must be None or a nineml.Dimension instance")
def __init__(self, name, ns, rel_index=None, abs_index=None, attr=None, branches=None, body=None): super(_AnnotationsBranch, self).__init__(branches) if attr is None: attr = {} self._name = validate_identifier(name) self._ns = ns self._abs_index = abs_index self._rel_index = rel_index self._attr = attr self._body = body
def __init__(self, name, dimensions=None, **kwargs): self._name = validate_identifier(name) AnnotatedNineMLObject.__init__(self) DocumentLevelObject.__init__(self) if dimensions is not None: assert len(dimensions) == 7, "Incorrect dimension length" self._dims = tuple(dimensions) else: self._dims = tuple(kwargs.pop(d, 0) for d in self.dimension_symbols) assert not len(kwargs), "Unrecognised kwargs ({})".format(kwargs)
def __init__(self, name, dimensions=None, **kwargs): self._name = validate_identifier(name) AnnotatedNineMLObject.__init__(self) DocumentLevelObject.__init__(self) if dimensions is not None: assert len(dimensions) == 7, "Incorrect dimension length" self._dims = tuple(dimensions) else: self._dims = tuple( kwargs.pop(d, 0) for d in self.dimension_symbols) assert not len(kwargs), "Unrecognised kwargs ({})".format(kwargs)
def __init__(self, port_name): """ Parameters ---------- port_name: str The name of the output EventPort that should transmit an event. An `EventPort` with a mode of 'send' must exist with a corresponding name in the component_class, otherwise a ``NineMLRuntimeException`` will be raised. """ super(OutputEvent, self).__init__() self._port_name = validate_identifier(port_name) self._port = None
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, src_port_name, state_assignments=None, output_events=None, target_regime_name=None): """ Constructor for ``OnEvent`` Parameters ---------- src_port_name: str The name of the |EventPort| that triggers this transition """ Transition.__init__(self, state_assignments=state_assignments, output_events=output_events, target_regime_name=target_regime_name) self._src_port_name = validate_identifier(src_port_name) self._port = None
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_properties, synapse_propertiess=[], connection_property_sets=[]): self._name = validate_identifier(name) self._dynamics_properties = dynamics_properties self.add(*synapse_propertiess) self.add(*connection_property_sets) # Extract the AL objects for the definition synapses = (Synapse(s.name, s.dynamics_properties.component_class, s.port_connections) for s in synapse_propertiess) connection_parameter_sets = ( ConnectionParameterSet( cp.port, [Parameter(p.name, p.units.dimension) for p in cp.properties]) for cp in connection_property_sets) self._definition = Definition( WithSynapses.wrap(dynamics_properties.component_class, synapses, connection_parameter_sets))
def __init__(self, name, dynamics_properties, synapse_propertiess=[], connection_property_sets=[]): self._name = validate_identifier(name) self._dynamics_properties = dynamics_properties self.add(*synapse_propertiess) self.add(*connection_property_sets) # Extract the AL objects for the definition synapses = (Synapse(s.name, s.dynamics_properties.component_class, s.port_connections) for s in synapse_propertiess) connection_parameter_sets = (ConnectionParameterSet( cp.port, [Parameter(p.name, p.units.dimension) for p in cp.properties]) for cp in connection_property_sets) self._definition = Definition( WithSynapses.wrap(dynamics_properties.component_class, synapses, connection_parameter_sets))
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, visitor, serial_elem, name, check_unprocessed=True, **options): super(NodeToUnserialize, self).__init__(visitor, serial_elem) self._name = validate_identifier(name) if check_unprocessed: self.unprocessed_attr = set( a for a in self.visitor.get_attr_keys(serial_elem, **options) if not a.startswith('@')) # Special attributes start with '@' self.unprocessed_children = set( n for n, _ in self.visitor.get_all_children( serial_elem, **options)) self.unprocessed_children.discard( self.visitor.node_name(Annotations)) self.unprocessed_body = ( self.visitor.get_body(serial_elem, **options) is not None) else: self.unprocessed_attr = set([]) self.unprocessed_children = set([]) self.unprocessed_body = False
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, visitor, serial_elem, name, check_unprocessed=True, **options): super(NodeToUnserialize, self).__init__(visitor, serial_elem) self._name = validate_identifier(name) if check_unprocessed: self.unprocessed_attr = set( a for a in self.visitor.get_attr_keys(serial_elem, **options) if not a.startswith('@')) # Special attributes start with '@' self.unprocessed_children = set( n for n, _ in self.visitor.get_all_children( serial_elem, **options)) self.unprocessed_children.discard( self.visitor.node_name(Annotations)) self.unprocessed_body = (self.visitor.get_body( serial_elem, **options) is not None) else: self.unprocessed_attr = set([]) self.unprocessed_children = set([]) self.unprocessed_body = False
def __init__(self, name, dynamics, synapses, connection_parameter_sets): assert isinstance(dynamics, (Dynamics, MultiDynamics)) # Initialise Dynamics/MultiDynamics base classes self._name = validate_identifier(name) self._dynamics = dynamics self.add(*synapses) self.add(*connection_parameter_sets) for conn_param in self.all_connection_parameters(): try: dyn_param = self._dynamics.parameter(conn_param.name) if conn_param.dimension != dyn_param.dimension: raise Pype9RuntimeError( "Inconsistent dimensions between connection parameter" " '{}' ({}) and parameter of the same name ({})" .format(conn_param.name, conn_param.dimension, dyn_param.dimension)) except NineMLNameError: raise Pype9RuntimeError( "Connection parameter '{}' does not refer to a parameter " "in the base MultiDynamics class ('{}')" .format(conn_param, "', '".join( sp.name for sp in self._dynamics.parameters))) self._dimension_resolver = None
def __init__(self, name, value, units=None): BaseALObject.__init__(self) self._name = validate_identifier(name) if isinstance(value, Quantity): if units is None: self._value = float(value._value) self._units = value.units elif units.dimension == value.units.dimension: self._value = float(value._value * 10 ** (units.power - value.units.power)) self._units = units else: raise NineMLDimensionError( "Dimensions do not match between provided quantity ({}) " "and units ({})".format(value.units.dimension, units.dimension)) else: self._value = float(value) self._units = units if units is not None else unitless if not isinstance(self._units, Unit): raise NineMLUsageError( "'units' in '{}' constant needs to be a Unit obj ({}). " "Supplied arguments were ({}, {}, {}).".format( self.name, self._units, name, value, units))
def __init__(self, name, value, units=None): BaseALObject.__init__(self) self._name = validate_identifier(name) if isinstance(value, Quantity): if units is None: self._value = float(value._value) self._units = value.units elif units.dimension == value.units.dimension: self._value = float(value._value * 10**(units.power - value.units.power)) self._units = units else: raise NineMLDimensionError( "Dimensions do not match between provided quantity ({}) " "and units ({})".format(value.units.dimension, units.dimension)) else: self._value = float(value) self._units = units if units is not None else unitless if not isinstance(self._units, Unit): raise NineMLUsageError( "'units' in '{}' constant needs to be a Unit obj ({}). " "Supplied arguments were ({}, {}, {}).".format( self.name, self._units, name, value, units))
def __init__(self, name, dynamics, synapses, connection_parameter_sets): assert isinstance(dynamics, (Dynamics, MultiDynamics)) # Initialise Dynamics/MultiDynamics base classes self._name = validate_identifier(name) self._dynamics = dynamics self.add(*synapses) self.add(*connection_parameter_sets) for conn_param in self.all_connection_parameters(): try: dyn_param = self._dynamics.parameter(conn_param.name) if conn_param.dimension != dyn_param.dimension: raise Pype9RuntimeError( "Inconsistent dimensions between connection parameter" " '{}' ({}) and parameter of the same name ({})". format(conn_param.name, conn_param.dimension, dyn_param.dimension)) except NineMLNameError: raise Pype9RuntimeError( "Connection parameter '{}' does not refer to a parameter " "in the base MultiDynamics class ('{}')".format( conn_param, "', '".join(sp.name for sp in self._dynamics.parameters))) self._dimension_resolver = None
def __init__(self, send_port_name, receive_port_name, sender_role=None, receiver_role=None, sender_name=None, receiver_name=None): """ `send_port` -- The name of the sending port `receiver_port` -- The name of the receiving port `sender_role` -- A reference to the sending object via the role it plays in the container `receiver_role` -- A reference to the receiving object via the role it plays in the container `sender_name` -- A reference to the sending object via its name, which uniquely identifies it within the container `receiver_name` -- A reference to the receiving object via its name, which uniquely identifies it within the container """ BaseULObject.__init__(self) assert isinstance(send_port_name, basestring) assert isinstance(receive_port_name, basestring) self._send_port_name = validate_identifier(send_port_name) self._send_port = None self._receive_port_name = validate_identifier(receive_port_name) self._receive_port = None if sender_role is not None: if sender_name is not None: raise NineMLUsageError( "Both 'sender_role' ({}) and 'sender_name' ({}) cannot" " be provided to PortConnection __init__" .format(sender_role, sender_name)) assert isinstance(sender_role, basestring) sender_role = str(sender_role) elif sender_name is not None: sender_name = validate_identifier(sender_name) else: raise NineMLUsageError( "Either 'sender_role' or 'sender_name' must be " "provided to PortConnection __init__") if receiver_role is not None: if receiver_name is not None: raise NineMLUsageError( "Both 'receiver_role' ({}) and 'receiver_name' ({}) cannot" " be provided to PortConnection __init__" .format(receiver_role, receiver_name)) assert isinstance(receiver_role, basestring) receiver_role = str(receiver_role) elif receiver_name is not None: receiver_name = validate_identifier(receiver_name) else: raise NineMLUsageError( "Either 'receiver_role' or 'receiver_name' must be " "provided to PortConnection __init__") self._sender_role = sender_role self._sender_name = sender_name self._receiver_name = receiver_name self._receiver_role = receiver_role # Initialise members that will hold the connected objects once they are # bound self._sender = None self._receiver = None # check to see if the ports are either all bound or all not bound, # raising an error if they are inconsistent self.is_bound()
def __init__(self, dependent_variable, independent_variable, rhs): ExpressionWithLHS.__init__(self, rhs) self._dependent_variable = validate_identifier(dependent_variable) self._independent_variable = validate_identifier(independent_variable)
def __init__(self, name, quantity): super(Property, self).__init__() assert isinstance(name, basestring) quantity = Quantity.parse(quantity) self._name = validate_identifier(name) self._quantity = quantity
def name(self, name): self._name = validate_identifier(name)
def __init__(self, send_port_name, receive_port_name, sender_role=None, receiver_role=None, sender_name=None, receiver_name=None): """ `send_port` -- The name of the sending port `receiver_port` -- The name of the receiving port `sender_role` -- A reference to the sending object via the role it plays in the container `receiver_role` -- A reference to the receiving object via the role it plays in the container `sender_name` -- A reference to the sending object via its name, which uniquely identifies it within the container `receiver_name` -- A reference to the receiving object via its name, which uniquely identifies it within the container """ BaseULObject.__init__(self) assert isinstance(send_port_name, basestring) assert isinstance(receive_port_name, basestring) self._send_port_name = validate_identifier(send_port_name) self._send_port = None self._receive_port_name = validate_identifier(receive_port_name) self._receive_port = None if sender_role is not None: if sender_name is not None: raise NineMLUsageError( "Both 'sender_role' ({}) and 'sender_name' ({}) cannot" " be provided to PortConnection __init__".format( sender_role, sender_name)) assert isinstance(sender_role, basestring) sender_role = str(sender_role) elif sender_name is not None: sender_name = validate_identifier(sender_name) else: raise NineMLUsageError( "Either 'sender_role' or 'sender_name' must be " "provided to PortConnection __init__") if receiver_role is not None: if receiver_name is not None: raise NineMLUsageError( "Both 'receiver_role' ({}) and 'receiver_name' ({}) cannot" " be provided to PortConnection __init__".format( receiver_role, receiver_name)) assert isinstance(receiver_role, basestring) receiver_role = str(receiver_role) elif receiver_name is not None: receiver_name = validate_identifier(receiver_name) else: raise NineMLUsageError( "Either 'receiver_role' or 'receiver_name' must be " "provided to PortConnection __init__") self._sender_role = sender_role self._sender_name = sender_name self._receiver_name = receiver_name self._receiver_role = receiver_role # Initialise members that will hold the connected objects once they are # bound self._sender = None self._receiver = None # check to see if the ports are either all bound or all not bound, # raising an error if they are inconsistent self.is_bound()
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, name, z): super(B, self).__init__() self._name = validate_identifier(name) self.z = z
def __init__(self, name, u, v): AnnotatedNineMLObject.__init__(self) self._name = validate_identifier(name) DocumentLevelObject.__init__(self) self.u = u self.v = v
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, name, operation, **kwargs): self._name = validate_identifier(name) BaseULObject.__init__(self, **kwargs) DocumentLevelObject.__init__(self) self._operation = operation
def __init__(self, name, x, y): AnnotatedNineMLObject.__init__(self) self._name = validate_identifier(name) DocumentLevelObject.__init__(self) self.x = x self.y = y