コード例 #1
0
ファイル: component.py プロジェクト: apdavison/lib9ML
 def check_properties(self):
     # First check the names
     properties = set(self.property_names)
     parameters = set(self.component_class.parameter_names)
     msg = []
     diff_a = properties.difference(parameters)
     diff_b = parameters.difference(properties)
     if diff_a:
         msg.append("User properties of '{}' (url:{}) contain the "
                    "following parameters that are not present in the "
                    "definition of '{}' (url:{}): {}\n\n".format(
                        self.name, self.url, self.component_class.name,
                        self.component_class.url, ",".join(diff_a)))
     if diff_b:
         msg.append("Definition of '{}' (url:{}) contains the following "
                    "parameters that are not present in the user properties"
                    " of '{}' (url:{}): {}".format(
                        self.component_class.name, self.component_class.url,
                        self.name, self.url, ",".join(diff_b)))
     if msg:
         # need a more specific type of Exception
         raise NineMLUsageError(". ".join(msg))
     # Check dimensions match
     for param in self.component_class.parameters:
         prop_units = self.property(param.name).units
         prop_dimension = prop_units.dimension
         param_dimension = param.dimension
         if prop_dimension != param_dimension:
             raise NineMLUsageError(
                 "Dimensions for '{}' property, {}, in '{}' don't match "
                 "that of its definition in '{}', {}.".format(
                     param.name, prop_dimension, self.name,
                     self.component_class.name, param_dimension))
コード例 #2
0
ファイル: base.py プロジェクト: sshyran/nineml-python
 def nineml_expression(**kwargs):
     if isinstance(self.rhs,
                   (bool, int, float, BooleanTrue, BooleanFalse)):
         val = self.rhs
     else:
         if self.rhs.is_Boolean:
             try:
                 val = self.rhs.subs(kwargs)
             except Exception:
                 raise NineMLUsageError(
                     "Incorrect arguments provided to expression ('{}')"
                     ": '{}'\n".format(
                         "', '".join(self.rhs_symbol_names),
                         "', '".join(list(kwargs.keys()))))
         else:
             try:
                 val = self.rhs.evalf(subs=kwargs)
             except Exception:
                 raise NineMLUsageError(
                     "Incorrect arguments provided to expression '{}'"
                     ": '{}' (expected '{}')\n".format(
                         self.rhs, "', '".join(list(kwargs.keys())),
                         "', '".join(self.rhs_symbol_names)))
             try:
                 val = float(val)
             except TypeError:
                 try:
                     locals_dict = deepcopy(kwargs)
                     locals_dict.update(str_to_npfunc_map)
                     val = eval(str(val), {}, locals_dict)
                 except Exception:
                     raise NineMLUsageError(
                         "Could not evaluate expression: {}".format(
                             self.rhs_str))
     return val
コード例 #3
0
ファイル: reference.py プロジェクト: apdavison/lib9ML
 def __init__(self, target=None, name=None, url=None, document=None):
     super(BaseReference, self).__init__()
     if target is not None:
         assert isinstance(target, DocumentLevelObject)
         self._target = target
         if name is not None or url is not None or document is not None:
             raise NineMLUsageError(
                 "'name', 'url' and 'document' kwargs cannot be used in "
                 "conjunction with 'target'")
     else:
         assert name is not None
         document_url = document.url if document is not None else None
         if url is not None and url != document_url:
             if url.startswith('.'):
                 if document_url is None:
                     raise NineMLUsageError(
                         "Must supply a document with a non-None URL that "
                         "is being referenced from if definition is a "
                         "relative URL string, '{}'".format(url))
                 relative_to = os.path.dirname(document.url)
             else:
                 relative_to = None
             if (relative_to is not None and os.path.realpath(
                     os.path.join(relative_to, url)) == document_url):
                 remote_doc = document
             else:
                 remote_doc = nineml.read(url, relative_to=relative_to)
         else:
             remote_doc = document
         self._target = remote_doc[name]
コード例 #4
0
ファイル: base.py プロジェクト: sshyran/nineml-python
 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)
コード例 #5
0
 def _check_ports(self):
     if not isinstance(self.send_port, EventSendPort):
         raise NineMLUsageError(
             "Send port '{}' must be an EventSendPort to be connected with"
             " an EventPortConnection".format(self.send_port.name))
     if not isinstance(self.receive_port, EventReceivePort):
         raise NineMLUsageError(
             "Send port '{}' must be an EventSendPort to be connected with"
             " an EventPortConnection".format(self.receive_port.name))
コード例 #6
0
 def from_tuple(cls, tple, container):
     # FIXME: Needs comments to explain what is going on and better
     #        exception messages
     sender, send_port, receiver, receive_port = tple
     init_kwargs = {}
     try:
         sender_dynamicss = getattr(container, sender).component_classes
         init_kwargs['sender_role'] = sender
     except AttributeError:
         try:
             sender_dynamicss = [container[sender].component_class]
             init_kwargs['sender_name'] = sender
         except (TypeError, KeyError) as e:
             raise NineMLUsageError(
                 "Did not find sender {} '{}' in '{}' container".format(
                     'name' if isinstance(e, KeyError) else 'role',
                     receiver, container.name))
     try:
         getattr(container, receiver).component_classes
         init_kwargs['receiver_role'] = receiver
     except AttributeError:
         try:
             container[receiver].component_class
             init_kwargs['receiver_name'] = receiver
         except (TypeError, KeyError) as e:
             raise NineMLUsageError(
                 "Did not find receiver {} '{}' in '{}' container".format(
                     'name' if isinstance(e, KeyError) else 'role',
                     receiver, container.name))
     port_type = None
     for dyn in sender_dynamicss:
         pt = dyn.port(send_port).nineml_type
         if port_type is None:
             port_type = pt
         elif port_type != pt:
             raise NineMLUsageError(
                 "Mismatching port types for '{}' port in populations in "
                 "Selection '{}'".format(send_port, container.name))
     if port_type in ('AnalogSendPort', 'AnalogSendPortExposure'):
         port_connection = AnalogPortConnection(
             receive_port_name=receive_port,
             send_port_name=send_port,
             **init_kwargs)
     elif port_type in ('EventSendPort', 'EventSendPortExposure'):
         port_connection = EventPortConnection(
             receive_port_name=receive_port,
             send_port_name=send_port,
             **init_kwargs)
     else:
         assert False, "'{}' should be a send port not '{}'".format(
             send_port, port_type)
     return port_connection
コード例 #7
0
ファイル: document.py プロジェクト: apdavison/lib9ML
    def add(self, nineml_obj, clone=True, cloner=None, **kwargs):
        """
        Adds a cloned version of the element to the document, setting the
        document reference (and the corresponding url) of clones to the
        document.

        Parameters
        ----------
        nineml_obj : DocumentLevelObject
            A document level object to add to the document
        clone : bool
            Whether to clone the element before adding it to the document
        clone_definitions : str
            Whether to clone definitions of user layer objects
        kwargs : dict
            Keyword arguments passed to the clone method
        """
        if not isinstance(nineml_obj, DocumentLevelObject):
            raise NineMLUsageError(
                "Cannot add {} element to document as it is not a \"document"
                "-level\" object".format(nineml_obj))
        if nineml_obj.name in self:
            # Ignore if the element is already added (this can happen
            # implictly when writing other elements that refer to this element)
            if nineml_obj is not self[nineml_obj.name]:
                if nineml_obj == self[nineml_obj.name]:
                    nineml_obj = self[nineml_obj.name]
                else:
                    nineml_obj.find_mismatch(self[nineml_obj.name])
                    raise NineMLNameError(
                        "Could not add '{}' as a different object with that "
                        "name already exists in the document '{}':\n{}"
                        .format(nineml_obj.name, self.url,
                                nineml_obj.find_mismatch(
                                    self[nineml_obj.name])))
        elif nineml_obj.document is not None and not clone:
            raise NineMLUsageError(
                "Attempting to add the same object '{}' {} to document"
                " '{}' document when it is already in another "
                "document, '{}' and 'clone' kwarg is False"
                .format(nineml_obj.name, nineml_obj.nineml_type,
                        self.url, nineml_obj.document.url))
        else:
            if clone:
                if cloner is None:
                    cloner = Cloner(**kwargs)
                nineml_obj = cloner.clone(nineml_obj, **kwargs)
            AddToDocumentVisitor(self).visit(nineml_obj, **kwargs)
        return nineml_obj
コード例 #8
0
ファイル: connectionrule.py プロジェクト: apdavison/lib9ML
 def __init__(self, rule_properties, source_size,
              destination_size, **kwargs):  # @UnusedVariable
     if (rule_properties.lib_type == 'OneToOne' and
             source_size != destination_size):
         raise NineMLUsageError(
             "Cannot connect to populations of different sizes "
             "({} and {}) with OneToOne connection rule"
             .format(source_size, destination_size))
     if not isinstance(rule_properties, ConnectionRuleProperties):
         raise NineMLUsageError(
             "'rule_properties' argument ({}) must be a "
             "ConnectcionRuleProperties instance".format(rule_properties))
     self._rule_properties = rule_properties
     self._source_size = source_size
     self._destination_size = destination_size
コード例 #9
0
ファイル: modifiers.py プロジェクト: apdavison/lib9ML
    def substitute(self, expr):
        """
        Substitute alias symbols in expression with equivalent expression
        of inputs, constants and reserved identifiers

        Parameters
        ----------
        nineml_obj : Expression
            An expression object to substitute alias symbols in
        """
        if expr.temporary:
            raise NineMLUsageError(
                "Attempting to substitute aliases using temporary object "
                "{}({})".format(type(expr).__name__, expr))
        assert isinstance(expr, Expression)
        try:
            rhs = self.cache[expr.id]
        except KeyError:
            for sym in list(expr.rhs_symbols):
                # Substitute all alias symbols with their RHS expresssions
                if str(sym) in self.component_class.alias_names:
                    alias = self.get_alias(str(sym))
                    expr.subs(sym, self.substitute(alias))
            self.cache[expr.id] = rhs = expr.rhs
        return rhs
コード例 #10
0
ファイル: component.py プロジェクト: apdavison/lib9ML
 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()
コード例 #11
0
ファイル: connection_group.py プロジェクト: apdavison/lib9ML
 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)
コード例 #12
0
ファイル: ports.py プロジェクト: apdavison/lib9ML
 def __init__(self, name, dimension=None, operator='+'):
     if operator not in list(self._operator_map.keys()):
         err = ("%s('%s')" + "specified undefined operator: '%s'") %\
               (self.__class__.__name__, name, str(operator))
         raise NineMLUsageError(err)
     super(AnalogReducePort, self).__init__(name, dimension)
     self._operator = str(operator)
コード例 #13
0
 def __getitem__(self, index):
     if self.value.is_array():
         return self._value.values[index] * self.units
     elif self.value.is_single():
         return self._value.value * self.units
     else:
         raise NineMLUsageError("Cannot get item from random distribution")
コード例 #14
0
 def from_sympy(self, expr):
     if expr == 1:
         return dimensionless
     elif not isinstance(expr, sympy.Basic):
         raise NineMLUsageError(
             "Cannot convert '{}' dimension, must be 1 or sympy expression".
             format(expr))
     powers = {}
     stack = [expr]
     while stack:
         expr = stack.pop()
         if isinstance(expr, sympy.Mul):
             stack.extend(expr.args)
         elif isinstance(expr, sympy.Pow):
             powers[str(expr.args[0])] = expr.args[1]
         else:
             powers[str(expr)] = 1
     name_num = []
     name_den = []
     for sym, p in powers.items():
         name = self.dimension_names[next(
             i for i, s in enumerate(self.dimension_symbols) if s == sym)]
         if abs(p) > 1:
             name += str(abs(p))
         if p > 0:
             name_num.append(name)
         else:
             name_den.append(name)
     name = '_'.join(name_num)
     if name_den:
         if name:
             name += '_'
         name += 'per_' + '_'.join(name_den)
     return Dimension(name, **powers)
コード例 #15
0
 def check_initial_values(self):
     for var in self.definition.component_class.state_variables:
         try:
             initial_value = self.initial_value(var.name)
         except KeyError:
             raise NineMLUsageError(
                 "Initial value not specified for {}".format(var.name))
         initial_units = initial_value.units
         initial_dimension = initial_units.dimension
         var_dimension = var.dimension
         if initial_dimension != var_dimension:
             raise NineMLUsageError(
                 "Dimensions for '{}' initial value, {}, in '{}' don't "
                 "match that of its definition in '{}', {}.".format(
                     var.name, initial_dimension, self.name,
                     self.component_class.name, var_dimension))
コード例 #16
0
    def from_str(cls, alias_string):
        """Creates an Alias object from a string"""
        if not cls.is_alias_str(alias_string):
            errmsg = "Invalid Alias: %s" % alias_string
            raise NineMLUsageError(errmsg)

        lhs, rhs = alias_string.split(':=')
        return Alias(name=lhs.strip(), rhs=rhs.strip())
コード例 #17
0
ファイル: general.py プロジェクト: apdavison/lib9ML
 def __init__(self, component_class, **kwargs):  # @UnusedVariable
     BaseDynamicsVisitor.__init__(self)
     self.sv_declared = []
     self.time_derivatives_used = []
     self.visit(component_class)
     for td in self.time_derivatives_used:
         if td not in self.sv_declared:
             raise NineMLUsageError(
                 "StateVariable '{}' not declared".format(td))
コード例 #18
0
 def __pow__(self, power):
     "self ** expr"
     if self.offset != 0:
         raise NineMLUsageError(
             "Can't raise units to power with nonzero offsets ({})".format(
                 self))
     return Unit(Dimension.make_name([self.name], power=power),
                 dimension=(self.dimension**power),
                 power=(self.power * power))
コード例 #19
0
ファイル: general.py プロジェクト: apdavison/lib9ML
 def __init__(self, component_class, **kwargs):  # @UnusedVariable
     BaseDynamicsVisitor.__init__(self)
     self.sv_declared = []
     self.state_assignments_lhs = []
     self.visit(component_class)
     for sa in self.state_assignments_lhs:
         if sa not in self.sv_declared:
             raise NineMLUsageError(
                 "Not Assigning to state-variable: {}".format(sa))
コード例 #20
0
ファイル: names.py プロジェクト: apdavison/lib9ML
 def check_conflicting_symbol(self, symbol):
     symbol = symbol.lower()
     if symbol in self.symbols:
         raise NineMLUsageError(
             "Found duplication of '{}' symbol in {} "
             "(Note that symbols must be case-insensitively unique despite "
             "being case-sensitive in general)".format(
                 symbol, self.component_class))
     self.symbols.append(symbol)
コード例 #21
0
 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)
コード例 #22
0
 def _check_ports(self):
     if not isinstance(self.send_port, AnalogSendPort):
         raise NineMLUsageError(
             "Send port '{}' must be an AnalogSendPort to be connected with"
             " an AnalogPortConnection".format(self.send_port.name))
     if not isinstance(self.receive_port,
                       (AnalogReceivePort, AnalogReducePort)):
         raise NineMLUsageError(
             "Send port '{}' must be an AnalogSendPort to be connected with"
             " an AnalogPortConnection".format(self.receive_port.name))
     if self.send_port.dimension != self.receive_port.dimension:
         raise NineMLDimensionError(
             "Dimensions do not match in analog port connection: sender "
             "port"
             " '{}' has dimensions of '{}' and receive port '{}' has"
             " dimensions of '{}'".format(self.send_port.name,
                                          self.send_port.dimension,
                                          self.receive_port.name,
                                          self.receive_port.dimension))
コード例 #23
0
ファイル: names.py プロジェクト: apdavison/lib9ML
 def check_conflicting_dimension(self, dimension):
     try:
         if dimension != self.dimensions[dimension.name]:
             err = ("Duplication of dimension name '{}' for differing "
                    "dimensions ('{}', '{}')".format(
                        dimension.name, dimension,
                        self.dimensions[dimension.name]))
             raise NineMLUsageError(err)
     except KeyError:
         self.dimensions[dimension.name] = dimension
コード例 #24
0
    def __init__(self, component_class, **kwargs):  # @UnusedVariable
        super(EventPortsDynamicsValidator, self).__init__()

        # Mapping component_class to list of events/eventports at that
        # component_class
        self.event_send_ports = {}
        self.event_receive_ports = {}
        self.output_events = []
        self.input_events = []

        # Visit all elements of the component class
        self.visit(component_class)

        # Check that each output event has a corresponding event_port with a
        # send mode:
        for output_event in self.output_events:
            if output_event not in self.event_send_ports:
                raise NineMLUsageError(
                    "Can't find port definition matching OutputEvent: {}"
                    .format(output_event))

        # Check that each input event has a corresponding event_port with a
        # recv/reduce mode:
        for input_event in self.input_events:
            if input_event not in self.event_receive_ports:
                raise NineMLUsageError(
                    "Can't find port definition matching input event: {}"
                    .format(input_event))

        # Check that each EventSendPort emits at least one output event
        for port_name in list(self.event_send_ports.keys()):
            if port_name not in self.output_events:
                raise NineMLUsageError(
                    "Unable to find events generated for '{}' in '{}'"
                    .format(port_name, component_class.name))

        # Check that each Event port emits/recieves at least one
        for port_name in list(self.event_receive_ports.keys()):
            if port_name not in self.input_events:
                raise NineMLUsageError(
                    "Unable to find event transitions triggered by '{}' in "
                    "'{}'".format(port_name, component_class.name))
コード例 #25
0
 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)
コード例 #26
0
    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)
コード例 #27
0
 def default_action(self, obj, **kwargs):  # @UnusedVariable
     if obj.id in self.ids:
         raise NineMLUsageError(
             "ID of {} {} ({}) already seen [{}]".format(
                 type(obj).__name__, obj, obj.id, self.context_str()))
     if self.print_all:
         print('{}: {}, {} [{}]'.format(obj.id, type(obj).__name__, obj,
                                        self.context_str()))
     self.ids.append(obj.id)
     if obj.temporary:
         self.temp_mem_address.add(id(obj))
コード例 #28
0
 def __mul__(self, other):
     "self * other"
     try:
         if (self.offset != 0 or other.offset != 0):
             raise NineMLUsageError(
                 "Can't multiply units with nonzero offsets ({} and {})".
                 format(self, other))
         return Unit(Dimension.make_name([self.name, other.name]),
                     dimension=self.dimension * other.dimension,
                     power=(self.power + other.power))
     except AttributeError:
         return Quantity(other, self)
コード例 #29
0
ファイル: modifiers.py プロジェクト: apdavison/lib9ML
 def get_alias(self, name):
     alias = None
     for context in reversed(self.contexts):
         try:
             alias = context.parent.alias(name)
             break
         except (NineMLNameError, AttributeError):
             continue
     if alias is None:
         raise NineMLUsageError("Did not find alias '{}' in any "
                                "context".format(name))
     return alias
コード例 #30
0
 def __init__(self, component_class, **kwargs):  # @UnusedVariable
     super(OutputAnalogPortsDynamicsValidator, self).__init__()
     self.output_analogports = []
     self.available_symbols = []
     self.component_class = component_class
     self.visit(component_class)
     for ap in self.output_analogports:
         if ap not in self.available_symbols:
             raise NineMLUsageError(
                 "Unable to find an Alias or State variable for "
                 "analog-port '{}' (available '{}')"
                 .format(ap, "', '".join(self.available_symbols)))