Splits name based on capitalization, dashes, and underscores.
        Example: 'GetFile' -> ['Get', 'File']
        Example: 'get_file' -> ['get', 'file']
487248
def split_words(name):
    
    all_words = []
    for word in re.split(_split_words_dashes_re, name):
        vals = _split_words_capitalization_re.findall(word)
        if vals:
            all_words.extend(vals)
        else:
            all_words.append(word)
    return all_words
122866
def convert_to_underscore(name):
    
    s1 = _first_cap_re.sub(r'\1_\2', name)
    return _all_cap_re.sub(r'\1_\2', s1).lower()
1033209
def full_name_natural_split(full_name):
    
    parts = full_name.strip().split(' ')
    first_name = ""
    if parts:
        first_name = parts.pop(0)
    if first_name.lower() == "el" and parts:
        first_name += " " + parts.pop(0)
    last_name = ""
    if parts:
        last_name = parts.pop()
    if (last_name.lower() == 'i' or last_name.lower() == 'ii'
        or last_name.lower() == 'iii' and parts):
        last_name = parts.pop() + " " + last_name
    middle_initials = ""
    for middle_name in parts:
        if middle_name:
            middle_initials += middle_name[0]
    return first_name, middle_initials, last_name
314865
def split_qname(qname):
        """"""
        res = qname.split(YinParser.ns_sep)
        if len(res) == 1:       # no namespace
            return None, res[0]
        else:
            return res
46697
def _split_tidy(self, string, maxsplit=None):
        """"""

        if maxsplit is None:
            return string.rstrip("\n").split("\t")
        else:
            return string.rstrip("\n").split("\t", maxsplit)
872843
def _process_underscores(self, tokens):
        ""
        groups = [[str(''.join(el))] if b else list(el)
                  for (b,el) in itertools.groupby(tokens, lambda k: k=='_')]
        flattened = [el for group in groups for el in group]
        processed = []
        for token in flattened:
            if token == '_':  continue
            if token.startswith('_'):
                token = str(token[1:])
            if token.endswith('_'):
                token = str(token[:-1])
            processed.append(token)
        return processed
1365663
def _ToJsonName(name):
  """"""
  capitalize_next = False
  result = []

  for c in name:
    if c == '_':
      capitalize_next = True
    elif capitalize_next:
      result.append(c.upper())
      capitalize_next = False
    else:
      result += c

  return ''.join(result)
300858
def _split_header(header):
        """"""
        params = {}
        parts = header.split(',')
        for param in parts:
            # Ignore realm parameter.
            if param.lower().startswith('realm='):
                continue
            # Remove whitespace.
            param = param.strip()
            # Split key-value.
            param_parts = param.split('=', 1)
            # Remove quotes and unescape the value.
            params[param_parts[0]] = unquote(param_parts[1].strip('\"'))
        return params
1262503
def capitalize(
    full_name,
    articles=None,
    separator_characters=None,
    ignore_worls=None,
):
    """"""
    if articles is None:
        articles = _ARTICLES
    if separator_characters is None:
        separator_characters = _SEPARATOR_CHARACTERS
    if ignore_worls is None:
        ignore_worls = _IGNORE_WORLS
    new_full_name = full_name
    if hasattr(new_full_name, 'strip'):
        new_full_name = new_full_name.strip()
    if not new_full_name:
        return full_name
    new_full_name = deep_unicode(new_full_name)
    list_full_name = []
    start_idx = 0
    for step_idx, char in enumerate(list(new_full_name)):
        if char in separator_characters:
            list_full_name.extend(
                [
                    _setting_word(
                        new_full_name[start_idx:step_idx],
                        separator_characters, ignore_worls,
                        articles if list_full_name else []
                    ),
                    char
                ]
            )
            start_idx = step_idx + 1
    list_full_name.append(
        _setting_word(
            new_full_name[start_idx:],
            separator_characters, ignore_worls, articles
        )
    )
    return ''.join(list_full_name)
452270
function splitCamelCase(name) {

    // first convert to PascalCase so each part starts with a capital letter
    name = name.substring(0, 1).toUpperCase() + name.substring(1);

    //TODO: bug here if string has two upper case characters right next to each other

    // then split into parts
    var parts = name.match(/[A-Z][a-z]+/g);
    var i;
    for (i = 0; i < parts.length; i++) {
        parts[i] = parts[i].toLowerCase();
    }

    return parts;
}
264017
function dashProperCase(str) {
        if ( !str.length ) {
            return str;
        }
        return str.split('-').map(function (piece) {
            if ( piece.length ) {
                return piece.substring(0, 1).toUpperCase() + piece.substring(1);
            }
            return piece;
        }).join('-');
    }
188444
def do_title(s):
    
    return ''.join(
        [item[0].upper() + item[1:].lower()
         for item in _word_beginning_split_re.split(soft_unicode(s))
         if item])
44630
def split_pks(cols):
  """"""
  pks = []
  others = []
  for name, col in cols.items():
    if col["is_primary_key"] == "t":
      pks.append(name)
    else:
      others.append(name)

  return (tuple(pks), tuple(others))
1064725
def parse_name_options(name, arg_split:':', **keywords)
			name,*options=name.split(arg_split)
			return name, parse_options(options, arg_split: arg_split, **keywords)
		end
1181991
function formatHeaderName(headerName) {
    var lowerCasedHeaderName = headerName.toLowerCase();
    if (headerNameSpecialCases.hasOwnProperty(lowerCasedHeaderName)) {
        return headerNameSpecialCases[lowerCasedHeaderName];
    } else {
        // Make sure that the first char and all chars following a dash are upper-case:
        return lowerCasedHeaderName.replace(/(^|-)([a-z])/g, function ($0, optionalLeadingDash, ch) {
            return optionalLeadingDash + ch.toUpperCase();
        });
    }
}
706806
def _clean_name(fname, data):
    
    for to_remove in dd.get_batches(data) + [dd.get_sample_name(data), data["sv"]["variantcaller"]]:
        for ext in ("-", "_"):
            if fname.startswith("%s%s" % (to_remove, ext)):
                fname = fname[len(to_remove) + len(ext):]
        if fname.startswith(to_remove):
            fname = fname[len(to_remove):]
    return fname
601686
def _name_matches(name, matches):
    '''
    
    '''
    for m in matches:
        if name.endswith(m):
            return True
        if name.lower().endswith('_' + m.lower()):
            return True
        if name.lower() == m.lower():
            return True
    return False