Yields name (str), wire (Wire) for all wires on
        this link
425635
def wires(self):
        

        for k in dir(self):
            if isinstance(getattr(self, k), Wire):
                yield k, getattr(self, k)
1052287
def column(m, linkpart):
    '''
    
    '''
    assert linkpart in (0, 1, 2, 3)
    seen = set()
    for link in m.match():
        val = link[linkpart]
        if val not in seen:
            seen.add(val)
            yield val
782329
def get_links(self, text=None, *args, **kwargs):
        
        return helpers.find_all(
            self.parsed, _link_ptn, text=text, *args, **kwargs
        )
343043
def nodes_in(self, name) -> iter:
        """"""
        yield from (node for node in self.all_in(name) if self.is_node(node))
1308009
def cp(args):
    
    p = OptionParser(cp.__doc__)
    fp = sys.stdin

    for link_name in fp:
        link_name = link_name.strip()
        if not op.exists(link_name):
            continue

        source = get_abs_path(link_name)
        link_name = op.basename(link_name)
        if not op.exists(link_name):
            os.symlink(source, link_name)
        logging.debug(" => ".join((source, link_name)))
1096975
def str_def(self):
        
        return "classname={!r}; connect_retries={!r}; message={!r};". \
            format(self.__class__.__name__, self.connect_retries, self.args[0])
646211
def cut(self, name, disconnect=False):

        

        wire = getattr(self, name, None)
        if wire and isinstance(wire, Wire):
            if name != "main":
                delattr(self, name)
            if disconnect:
                wire.disconnect()
            wire.off("receive", self.on_receive)
            if self.main == wire:
                self.main = None
                self.set_main_wire()
217890
def _strslices(self):
        """"""
        pad = self.padding or 0
        for sli in self.slices():
            if sli.start + 1 == sli.stop:
                yield "%0*d" % (pad, sli.start)
            else:
                assert sli.step >= 0, "Internal error: sli.step < 0"
                if sli.step == 1:
                    yield "%0*d-%0*d" % (pad, sli.start, pad, sli.stop - 1)
                else:
                    yield "%0*d-%0*d/%d" % (pad, sli.start, pad, sli.stop - 1, \
                                            sli.step)
593716
def name(self):
        
        pattern = self.random_element(self.formats)
        return self.generator.parse(pattern)
1231695
def output(self, name: str, value: Any):
        
        self.outputs[name] = value
150806
def parse(self, node):
        
        self._attrs = {}
        vals = []
        yielded = False

        for x in self._read_parts(node):
            if isinstance(x, Field):
                yielded = True
                x.attrs = self._attrs
                yield x
            else:
                vals.append(ustr(x).strip(' \n\t'))

        joined = ' '.join([ x for x in vals if x ])
        if joined:
            yielded = True
            yield Field(node, guess_type(joined), self._attrs)

        if not yielded:
            yield Field(node, "", self._attrs)
1308839
function makeLinks (links, item) {
  var retLinks = {}

  _.each(links, function (value, name) {
    if (_.isFunction(value)) {
      retLinks[name] = value(item)
    } else {
      retLinks[name] = _(value).toString()
    }
  })

  return retLinks
}
277055
def apply_all_link_refs(
    bytecode: bytes, link_refs: List[Dict[str, Any]], attr_dict: Dict[str, str]
) -> bytes:
    
    if link_refs is None:
        return bytecode
    link_fns = (
        apply_link_ref(offset, ref["length"], attr_dict[ref["name"]])
        for ref in link_refs
        for offset in ref["offsets"]
    )
    linked_bytecode = pipe(bytecode, *link_fns)
    return linked_bytecode
127774
def all_as_href(self):
        
        if not self.is_any and not self.is_none:
            return [element for element in self.get(self.typeof)]
        return []
564993
private void generateDN() {
        if (names.length == 1) {
            dn = names[0].toString();
            return;
        }

        StringBuilder sb = new StringBuilder(48);
        if (names != null) {
            for (int i = names.length - 1; i >= 0; i--) {
                if (i != names.length - 1) {
                    sb.append(", ");
                }
                sb.append(names[i].toString());
            }
        }
        dn = sb.toString();
    }
977481
def connection_info(self):
        
        for key in self._connection_keys():
            if key in self._contents:
                yield key, self._contents[key]
44057
def handle_link(self, value):
        
        for s, p, o in self.graph.triples((value, None, None)):
            if p == LINK_ELEM:
                return unicode(o).replace('file://', '')