Gets the part of speech name for *code*.

    Joins the names together with *delimiter* if *name* is ``'all'``.

    See :func:``pynlpir.pos_map.get_pos_name`` for more information.
172775
def _get_pos_name(code, name='parent', english=True, delimiter=':',
                  pos_tags=pos_map.POS_MAP):
    
    pos_name = pos_map.get_pos_name(code, name, english, pos_tags=pos_tags)
    return delimiter.join(pos_name) if name == 'all' else pos_name
1142880
public String getNameAsSingleString() {
    List<StringType> nameParts = new ArrayList<StringType>();
    nameParts.addAll(getPrefix());
    nameParts.addAll(getGiven());
    nameParts.add(getFamilyElement());
    nameParts.addAll(getSuffix());
    if (nameParts.size() > 0) {
      return joinStringsSpaceSeparated(nameParts);
    } else {
      return getTextElement().getValue();
    }
  }
578321
def _extract_common_name(cls, dn):
        
        dn = dn.lower().replace(" ", "_")
        return dn.split(",")[0].split("=")[1]
1238395
def p_identifier_name_string(self, p):
        
        p[0] = asttypes.PropIdentifier(p[1].value)
        # manually clone the position attributes.
        for k in ('_token_map', 'lexpos', 'lineno', 'colno'):
            setattr(p[0], k, getattr(p[1], k))
1272639
def get_coding(text):
    
    for line in text.splitlines()[:2]:
        result = CODING_RE.search(to_text_string(line))
        if result:
            return result.group(1)
    return None
213034
def full_name(self):
        
        import ibis.expr.operations as ops

        return ops.DayOfWeekName(self.op().arg).to_expr()
107634
def parse_name(self, line):
        """"""
        end = self.idx
        for char in line[self.idx:]:
            if not char.isalnum() and char not in '\'"_':
                break
            end += 1

        word = line[self.idx:end]

        self.idx = end - 1
        # Update iterator, minus first character which was already read
        self.characters = itertools.islice(self.characters, len(word) - 1,
                                           None)
        self.update_chars()

        return word
357513
def get_names():
    
    return [n.strip() for n in codecs.open(os.path.join("data", "names.txt"),"rb",'utf8').readlines()]
13592
def parse_call(self):
        
        assert self.pos < len(self.string)
        assert self.string[self.pos] == FUNC_DELIM

        start_pos = self.pos
        self.pos += 1

        ident = self._parse_ident()
        if not ident:
            # No function name.
            self.parts.append(FUNC_DELIM)
            return

        if self.pos >= len(self.string):
            # Identifier terminates string.
            self.parts.append(self.string[start_pos:self.pos])
            return

        if self.string[self.pos] != GROUP_OPEN:
            # Argument list not opened.
            self.parts.append(self.string[start_pos:self.pos])
            return

        # Skip past opening brace and try to parse an argument list.
        self.pos += 1
        args = self.parse_argument_list()
        if self.pos >= len(self.string) or \
           self.string[self.pos] != GROUP_CLOSE:
            # Arguments unclosed.
            self.parts.append(self.string[start_pos:self.pos])
            return

        self.pos += 1  # Move past closing brace.
        self.parts.append(Call(ident, args, self.string[start_pos:self.pos]))
570233
def _parse_ident(self):
        
        remainder = self.string[self.pos:]
        ident = re.match(r'\w*', remainder).group(0)
        self.pos += len(ident)
        return ident
170023
def get_known_name(s: str) -> Optional[Tuple[str, ColorArg]]:
    

    if not s.endswith('m'):
        # All codes end with 'm', so...
        return None
    if s.startswith('\033[38;5;'):
        # Extended fore.
        name = codes_reverse['fore'].get(s, None)
        if name is None:
            num = get_code_num(s)
            return ('extended fore', num)
        else:
            return ('extended fore', name)
    elif s.startswith('\033[48;5;'):
        # Extended back.
        name = codes_reverse['back'].get(s, None)
        if name is None:
            num = get_code_num(s)
            return ('extended back', num)
        else:
            return ('extended back', name)
    elif s.startswith('\033[38;2'):
        # RGB fore.
        vals = get_code_num_rgb(s)
        if vals is not None:
            return ('rgb fore', vals)
    elif s.startswith('\033[48;2'):
        # RGB back.
        vals = get_code_num_rgb(s)
        if vals is not None:
            return ('rgb back', vals)
    elif s.startswith('\033['):
        # Fore, back, style.
        number = get_code_num(s)
        # Get code type based on number.
        if (number <= 7) or (number == 22):
            codetype = 'style'
        elif (((number >= 30) and (number < 40)) or
                ((number >= 90) and (number < 100))):
            codetype = 'fore'
        elif (((number >= 40) and (number < 50)) or
                ((number >= 100) and (number < 110))):
            codetype = 'back'
        else:
            raise InvalidEscapeCode(
                number,
                'Expecting 0-7, 22, 30-39, or 40-49 for escape code',
            )

        name = codes_reverse[codetype].get(s, None)
        if name is not None:
            return (codetype, name)

    # Not a known escape code.
    return None
568160
def rpc_get_all_names( self, offset, count, **con_info ):
        
        if not check_offset(offset):
            return {'error': 'invalid offset', 'http_status': 400}

        if not check_count(count, 100):
            return {'error': 'invalid count', 'http_status': 400}

        db = get_db_state(self.working_dir)
        num_domains = db.get_num_names()
        if num_domains > offset:
           all_domains = db.get_all_names( offset=offset, count=count )
        else:
           all_domains = []
        db.close()

        return self.success_response( {'names': all_domains} )
808854
private static String getFullPathName(INode[] inodes, int pos) {
    StringBuilder fullPathName = new StringBuilder();
    for (int i=1; i<=pos; i++) {
      fullPathName.append(Path.SEPARATOR_CHAR).append(inodes[i].getLocalName());
    }
    return fullPathName.toString();
  }
386908
def _conv_name(x):
    '''
    
    '''
    if '}' in x:
        comps = x.split('}')
        name = comps[1]
        return name
    return x
1359031
def join_name(parts,
                  separator: ObjectInspector.configuration.name_separator)
      the_parts = Array(parts).tap(&:compact!)
      the_parts.join(separator) if the_parts.any?
    end
894270
def _GetFrameCodeObjectName(frame):
  
  # This functions under the assumption that member functions will name their
  # first parameter argument 'self' but has some edge-cases.
  if frame.f_code.co_argcount >= 1 and 'self' == frame.f_code.co_varnames[0]:
    return (frame.f_locals['self'].__class__.__name__ +
            '.' + frame.f_code.co_name)
  else:
    return frame.f_code.co_name
434279
def get_name(self):
        
        if self.name_idx_value == None:
            self.name_idx_value = self.CM.get_string(self.name_idx)

        return self.name_idx_value