def add_message_handlers(self, message_handlers): """Add message handlers. :param message_handlers: A list/tuple of :class:`MessageHandler`. """ if not typecheck.is_list(message_handlers): raise TypeError('message_handlers has to be a list') for handler in message_handlers: if isinstance(handler, MessageHandler): self.add_message_handler(handler) else: if not typecheck.is_tuple(handler): raise TypeError("handler must be a tuple: %s" % type(handler)) if len(handler) < 2: raise Exception("Handler should have more than two parameters") handler = list(handler) if typecheck.is_tuple(handler[1]): handler[1] = Message(*handler[1]) else: raise TypeError() if len(handler) > 2: if typecheck.is_tuple(handler[2]): handler[2] = Message(*handler[2]) else: raise TypeError() handler = MessageHandler(*handler) self.add_message_handler(handler) return self
def set_fields(self, fields): """Sets message fields. :param fields: A list of :class:`Field` instances. :raises: TypeError """ self._fields = [] if not typecheck.is_list(fields) and not typecheck.is_tuple(fields): raise TypeError("`fields` has to be list or tuple: %s" % fields) for field in fields: if typecheck.is_list(field) or typecheck.is_tuple(field): field = self.field_type(field[0], field[1]) elif not isinstance(field, self.field_type): field = self.field_type(field) self._fields.append(field)
def add_dependency(self, dep): rule = None if typecheck.is_tuple(dep) or typecheck.is_list(dep): rule = Fork(name="r%d" % hash(dep), deps=dep) else: rule = isinstance(dep, Rule) and dep or parse_address(dep) if rule: dep = rule else: if callable(dep): dep = new.instancemethod(dep, self, self.__class__) extra_deps = dep(self.target) if extra_deps: self.add_dependencies(extra_deps) return dependency_graph.add_edge(self, dep) self._dependencies.append(dep)
def _gen_preprocess_macro_options(self, macros): """Macros is the usual thing, a list of 1- or 2-tuples, where (name,) means undefine (-U) macro 'name', and (name, value) means define (-D) macro 'name' to 'value'. """ options = [] for macro in macros: if not (typecheck.is_tuple(macro) and 1 <= len(macro) <= 2): raise TypeError("bad macro definition " + repr(macro) + ": " + "each element of 'macros' list must be a 1- or 2-tuple") if len (macro) == 1: # undefine this macro options.append("-U%s" % macro[0]) elif len (macro) == 2: if macro[1] is None: # define with no explicit value options.append("-D%s" % macro[0]) else: # XXX *don't* need to be clever about quoting the # macro value here, because we're going to avoid the # shell at all costs when we spawn the command! options.append("-D%s=%s" % macro) return options
def add_edge(self, sender, receiver, key=None, attr_dict=None, **attrs): """Create an edge between sender and receiver. Return an edge represented by :class:`NetworkXEdge` instance which is mainly replacing a tuple (sender, receiver, key, attrs). `sender` and `receiver` can be represented by a tuple of mapping and target communication device. `key` is an optional hashable identifier. By default it has :const:`NetworkXEdge.KEY_FORMAT` format. Note, this key has to be unique in order to distinguish multiedges between a pair of nodes. At the same time edge's label equals to the key. By default label equals to the key value but can be changes by using associated data as follows:: edge = network.add_edge(Mapping("M1"), Mapping("M2"), label="My serial connection") or:: edge = network.add_edge(Mapping("M1"), Mapping("M2")) edge.set_label("My serial connection") Note, the nodes for sender and receiver mappings will be automatically added if they are not already in the graph. """ # Analyse incomming arguments if typecheck.is_tuple(sender): (sender, sending_device) = sender if typecheck.is_tuple(receiver): (receiver, receiving_device) = receiver # Setup dictionary of attributes if attr_dict is None: attr_dict = attrs if not self.has_node(sender): self.add_node(sender) if not self.has_node(receiver): self.add_node(receiver) # Define hashable identifier if not key: key_format = attr_dict.get("key_format", None) or \ NetworkXEdge.KEY_FORMAT if not typecheck.is_string(key_format): raise TypeError("Has to be string") key = key_format % self.number_of_edges(sender, receiver) else: if not typecheck.is_string(key): raise TypeError("Has to be string") if self.has_edge(sender, receiver, key): raise Exception("Edge %s already exists between %s and %s" % (key, sender, receiver)) # Define edge label if not attr_dict.get("label", None): attr_dict["label"] = key else: if not typecheck.is_string(attr_dict.get("label")): raise TypeError("Has to be string") # Use super method networkx.MultiDiGraph.add_edge(self, sender, receiver, key=key, attr_dict=attr_dict) return NetworkXEdge(sender, receiver, key, self.get_edge_data(sender, receiver, key=key))
def add_dependencies(self, deps): if not typecheck.is_list(deps) and not typecheck.is_tuple(deps): raise TypeError("%s: deps has to be a list or tuple, got %s" % (self, type(deps))) for dep in deps: self.add_dependency(dep)