Yield ordered list of connections to one child.

        Each result is a ((component, output), (component, input)) tuple.

        :param string name: the component whose output connections are
            wanted.
499207
def output_connections(self, name):
        
        for output_name in self._compound_children[name].outputs:
            src = name, output_name
            if src in self._compound_linkages:
                dests = self._compound_linkages[src]
                if isinstance(dests[0], six.string_types):
                    dests = zip(dests[0::2], dests[1::2])
                for dest in dests:
                    yield src, dest
65093
def iter_variants_by_names(self, names):
        
        for name in names:
            for result in self.get_variant_by_name(name):
                yield result
307864
def _get_generator(self, name):
        
        for ep in pkg_resources.iter_entry_points(self.group, name=None):
            if ep.name == name:
                generator = ep.load()
                return generator
1124215
def get(self):
        ''
        # If you attempt to use a generator comprehension below, it will
        # consume the StopIteration exception and just return an empty tuple,
        # instead of stopping iteration normally
        return tuple([(x.name(), x.get()) for x in self._generators])
594212
def connect(*args, **kwargs):
    """"""
    from .connections import Connection
    conn = Connection(*args, **kwargs)
    yield conn.connect()
    raise gen.Return(conn)
102302
def dev_from_name(self, name):
        
        try:
            return next(iface for iface in six.itervalues(self)
                        if (iface.name == name or iface.description == name))
        except (StopIteration, RuntimeError):
            raise ValueError("Unknown network interface %r" % name)
1279375
def concat_namedtuples(*tup, **kwargs):
    '''
    
    '''
    name = kwargs['name'] if 'name' in kwargs else None

    # filter out empty elements
    filtered = [i for i in filter(None, tup)]
    if filtered:
        if len(filtered) == 1:
            return filtered[0]
        else:
            fields = chain(*(t._fields for t in filtered))
            values = chain(*(t for t in filtered))
            if not name:
                name = 'SDMXNamedTuple'
            ConcatType = namedtuple_factory(name, fields)
            return ConcatType(*values)
    else:
        return ()
302513
def iter(self, string):
		
		state = self.root
		for index, c in enumerate(string):
			while c not in state.children:
				state = state.fail

			state = state.children.get(c, self.root)

			tmp = state
			output = []
			while tmp is not nil:
				if tmp.output is not nil:
					output.append(tmp.output)

				tmp = tmp.fail

			if output:
				yield (index, output)
725303
def from_tuple(cls, components: tuple) -> 'ComponentRef':
        

        component_ref = ComponentRef(name=components[0], child=[])
        c = component_ref
        for component in components[1:]:
            c.child.append(ComponentRef(name=component, child=[]))
            c = c.child[0]
        return component_ref
793086
def get_targets(conn=None):
    
    targets = RBT
    results = targets.run(conn)
    for item in results:
        yield item
1122162
def iter_components(self):
        """"""

        names = self.list_components()

        for name in names:
            yield self.get_component(name)
274599
def named_tuple(
        element_name,  # type: Text
        tuple_type,  # type: Type[Tuple]
        child_processors,  # type: List[Processor]
        required=True,  # type: bool
        alias=None,  # type: Optional[Text]
        hooks=None  # type: Optional[Hooks]
):
    # type: (...) -> RootProcessor
    
    converter = _named_tuple_converter(tuple_type)
    processor = _Aggregate(element_name, converter, child_processors, required, alias)
    return _processor_wrap_if_hooks(processor, hooks)
378185
def get_unique_named_object(root, name):
    
    a = get_children(lambda x: hasattr(x, 'name') and x.name == name, root)
    assert len(a) == 1
    return a[0]
907848
def get_all_connections(self, id, connection_name, **args):
        
        while True:
            page = self.get_connections(id, connection_name, **args)
            for post in page["data"]:
                yield post
            next = page.get("paging", {}).get("next")
            if not next:
                return
            args = parse_qs(urlparse(next).query)
            del args["access_token"]
343043
def nodes_in(self, name) -> iter:
        """"""
        yield from (node for node in self.all_in(name) if self.is_node(node))
768923
def in_order(self) -> Iterator["BSP"]:
        
        if self.children:
            yield from self.children[0].in_order()
            yield self
            yield from self.children[1].in_order()
        else:
            yield self
156870
def get_connection(self, name):
        
        name = quote(name, '')
        path = Client.urls['connections_by_name'] % name
        conn = self._call(path, 'GET')
        return conn