Source code for nameparser.parser

# -*- coding: utf-8 -*-
from __future__ import unicode_literals

import sys
import re
from operator import itemgetter
from itertools import groupby

from nameparser.util import u
from nameparser.util import text_types, binary_type
from nameparser.util import lc
from nameparser.util import log
from nameparser.config import CONSTANTS
from nameparser.config import Constants
from nameparser.config import DEFAULT_ENCODING

ENCODING = 'utf-8'

def group_contiguous_integers(data):
    return list of tuples containing first and last index
    position of contiguous numbers in a series
    ranges = []
    for key, group in groupby(enumerate(data), lambda i: i[0] - i[1]):
        group = list(map(itemgetter(1), group))
        if len(group) > 1:
            ranges.append((group[0], group[-1]))
    return ranges

[docs]class HumanName(object): """ Parse a person's name into individual components. Instantiation assigns to ``full_name``, and assignment to :py:attr:`full_name` triggers :py:func:`parse_full_name`. After parsing the name, these instance attributes are available. Alternatively, you can pass any of the instance attributes to the constructor method and skip the parsing process. If any of the the instance attributes are passed to the constructor as keywords, :py:func:`parse_full_name` will not be performed. **HumanName Instance Attributes** * :py:attr:`title` * :py:attr:`first` * :py:attr:`middle` * :py:attr:`last` * :py:attr:`suffix` * :py:attr:`nickname` * :py:attr:`surnames` :param str full_name: The name string to be parsed. :param constants constants: a :py:class:`~nameparser.config.Constants` instance. Pass ``None`` for `per-instance config <customize.html>`_. :param str encoding: string representing the encoding of your input :param str string_format: python string formatting :param str initials_format: python initials string formatting :param str initials_delimter: string delimiter for initials :param str first: first name :param str middle: middle name :param str last: last name :param str title: The title or prenominal :param str suffix: The suffix or postnominal :param str nickname: Nicknames """ C = CONSTANTS """ A reference to the configuration for this instance, which may or may not be a reference to the shared, module-wide instance at :py:mod:`~nameparser.config.CONSTANTS`. See `Customizing the Parser <customize.html>`_. """ original = '' """ The original string, untouched by the parser. """ _count = 0 _members = ['title', 'first', 'middle', 'last', 'suffix', 'nickname'] unparsable = True _full_name = ''
[docs] def __init__(self, full_name="", constants=CONSTANTS, encoding=DEFAULT_ENCODING, string_format=None, initials_format=None, initials_delimiter=None, first=None, middle=None, last=None, title=None, suffix=None, nickname=None): self.C = constants if type(self.C) is not type(CONSTANTS): self.C = Constants() self.encoding = encoding self.string_format = string_format or self.C.string_format self.initials_format = initials_format or self.C.initials_format self.initials_delimiter = initials_delimiter or self.C.initials_delimiter if (first or middle or last or title or suffix or nickname): self.first = first self.middle = middle self.last = last self.title = title self.suffix = suffix self.nickname = nickname self.unparsable = False else: # full_name setter triggers the parse self.full_name = full_name
def __iter__(self): return self def __len__(self): l = 0 for x in self: l += 1 return l
[docs] def __eq__(self, other): """ HumanName instances are equal to other objects whose lower case unicode representation is the same. """ return (u(self)).lower() == (u(other)).lower()
def __ne__(self, other): return not (u(self)).lower() == (u(other)).lower() def __getitem__(self, key): if isinstance(key, slice): return [getattr(self, x) for x in self._members[key]] else: return getattr(self, key) def __setitem__(self, key, value): if key in self._members: self._set_list(key, value) else: raise KeyError("Not a valid HumanName attribute", key) def next(self): return self.__next__() def __next__(self): if self._count >= len(self._members): self._count = 0 raise StopIteration else: c = self._count self._count = c + 1 return getattr(self, self._members[c]) or next(self) def __unicode__(self): if self.string_format: # string_format = "{title} {first} {middle} {last} {suffix} ({nickname})" _s = self.string_format.format(**self.as_dict()) # remove trailing punctuation from missing nicknames _s = _s.replace(str(self.C.empty_attribute_default), '').replace(" ()", "").replace(" ''", "").replace(' ""', "") return self.collapse_whitespace(_s).strip(', ') return " ".join(self) def __hash__(self): return hash(str(self)) def __str__(self): if sys.version_info[0] >= 3: return self.__unicode__() return self.__unicode__().encode(self.encoding) def __repr__(self): if self.unparsable: _string = "<%(class)s : [ Unparsable ] >" % {'class': self.__class__.__name__, } else: _string = "<%(class)s : [\n\ttitle: %(title)r \n\tfirst: %(first)r \n\tmiddle: %(middle)r \n\tlast: %(last)r \n\tsuffix: %(suffix)r\n\tnickname: %(nickname)r\n]>" % { 'class': self.__class__.__name__, 'title': self.title or '', 'first': self.first or '', 'middle': self.middle or '', 'last': self.last or '', 'suffix': self.suffix or '', 'nickname': self.nickname or '', } if sys.version_info[0] >= 3: return _string return _string.encode(self.encoding)
[docs] def as_dict(self, include_empty=True): """ Return the parsed name as a dictionary of its attributes. :param bool include_empty: Include keys in the dictionary for empty name attributes. :rtype: dict .. doctest:: >>> name = HumanName("Bob Dole") >>> name.as_dict() {'last': 'Dole', 'suffix': '', 'title': '', 'middle': '', 'nickname': '', 'first': 'Bob'} >>> name.as_dict(False) {'last': 'Dole', 'first': 'Bob'} """ d = {} for m in self._members: if include_empty: d[m] = getattr(self, m) else: val = getattr(self, m) if val: d[m] = val return d
def __process_initial__(self, name_part, firstname=False): """ Name parts may include prefixes or conjunctions. This function filters these from the name unless it is a first name, since first names cannot be conjunctions or prefixes. """ parts = name_part.split(" ") initials = [] if len(parts) and isinstance(parts, list): for part in parts: if not (self.is_prefix(part) or self.is_conjunction(part)) or firstname == True: initials.append(part[0]) if len(initials) > 0: return " ".join(initials) else: return self.C.empty_attribute_default
[docs] def initials_list(self): """ Returns the initials as a list .. doctest:: >>> name = HumanName("Sir Bob Andrew Dole") >>> name.initials_list() ["B", "A", "D"] >>> name = HumanName("J. Doe") >>> name.initials_list() ["J", "D"] """ first_initials_list = [self.__process_initial__(name, True) for name in self.first_list if name] middle_initials_list = [self.__process_initial__(name) for name in self.middle_list if name] last_initials_list = [self.__process_initial__(name) for name in self.last_list if name] return first_initials_list + middle_initials_list + last_initials_list
[docs] def initials(self): """ Return period-delimited initials of the first, middle and optionally last name. :param bool include_last_name: Include the last name as part of the initials :rtype: str .. doctest:: >>> name = HumanName("Sir Bob Andrew Dole") >>> name.initials() "B. A. D." >>> name = HumanName("Sir Bob Andrew Dole", initials_format="{first} {middle}") >>> name.initials() "B. A." """ first_initials_list = [self.__process_initial__(name, True) for name in self.first_list if name] middle_initials_list = [self.__process_initial__(name) for name in self.middle_list if name] last_initials_list = [self.__process_initial__(name) for name in self.last_list if name] initials_dict = { "first": (self.initials_delimiter + " ").join(first_initials_list) + self.initials_delimiter if len(first_initials_list) else self.C.empty_attribute_default, "middle": (self.initials_delimiter + " ").join(middle_initials_list) + self.initials_delimiter if len(middle_initials_list) else self.C.empty_attribute_default, "last": (self.initials_delimiter + " ").join(last_initials_list) + self.initials_delimiter if len(last_initials_list) else self.C.empty_attribute_default } _s = self.initials_format.format(**initials_dict) return self.collapse_whitespace(_s)
@property def has_own_config(self): """ True if this instance is not using the shared module-level configuration. """ return self.C is not CONSTANTS # attributes @property def title(self): """ The person's titles. Any string of consecutive pieces in :py:mod:`~nameparser.config.titles` or :py:mod:`~nameparser.config.conjunctions` at the beginning of :py:attr:`full_name`. """ return " ".join(self.title_list) or self.C.empty_attribute_default @property def first(self): """ The person's first name. The first name piece after any known :py:attr:`title` pieces parsed from :py:attr:`full_name`. """ return " ".join(self.first_list) or self.C.empty_attribute_default @property def middle(self): """ The person's middle names. All name pieces after the first name and before the last name parsed from :py:attr:`full_name`. """ return " ".join(self.middle_list) or self.C.empty_attribute_default @property def last(self): """ The person's last name. The last name piece parsed from :py:attr:`full_name`. """ return " ".join(self.last_list) or self.C.empty_attribute_default @property def suffix(self): """ The persons's suffixes. Pieces at the end of the name that are found in :py:mod:`~nameparser.config.suffixes`, or pieces that are at the end of comma separated formats, e.g. "Lastname, Title Firstname Middle[,] Suffix [, Suffix]" parsed from :py:attr:`full_name`. """ return ", ".join(self.suffix_list) or self.C.empty_attribute_default @property def nickname(self): """ The person's nicknames. Any text found inside of quotes (``""``) or parenthesis (``()``) """ return " ".join(self.nickname_list) or self.C.empty_attribute_default @property def surnames_list(self): """ List of middle names followed by last name. """ return self.middle_list + self.last_list @property def surnames(self): """ A string of all middle names followed by the last name. """ return " ".join(self.surnames_list) or self.C.empty_attribute_default # setter methods def _set_list(self, attr, value): if isinstance(value, list): val = value elif isinstance(value, text_types): val = [value] elif value is None: val = [] else: raise TypeError( "Can only assign strings, lists or None to name attributes." " Got {0}".format(type(value))) setattr(self, attr+"_list", self.parse_pieces(val)) @title.setter def title(self, value): self._set_list('title', value) @first.setter def first(self, value): self._set_list('first', value) @middle.setter def middle(self, value): self._set_list('middle', value) @last.setter def last(self, value): self._set_list('last', value) @suffix.setter def suffix(self, value): self._set_list('suffix', value) @nickname.setter def nickname(self, value): self._set_list('nickname', value) # Parse helpers
[docs] def is_title(self, value): """Is in the :py:data:`~nameparser.config.titles.TITLES` set.""" return lc(value) in self.C.titles
[docs] def is_conjunction(self, piece): """Is in the conjunctions set and not :py:func:`is_an_initial()`.""" if isinstance(piece, list): for item in piece: if self.is_conjunction(item): return True else: return piece.lower() in self.C.conjunctions and not self.is_an_initial(piece)
[docs] def is_prefix(self, piece): """ Lowercase and no periods version of piece is in the :py:data:`~nameparser.config.prefixes.PREFIXES` set. """ if isinstance(piece, list): for item in piece: if self.is_prefix(item): return True else: return lc(piece) in self.C.prefixes
[docs] def is_roman_numeral(self, value): """ Matches the ``roman_numeral`` regular expression in :py:data:`~nameparser.config.regexes.REGEXES`. """ return bool(self.C.regexes.roman_numeral.match(value))
[docs] def is_suffix(self, piece): """ Is in the suffixes set and not :py:func:`is_an_initial()`. Some suffixes may be acronyms (M.B.A) while some are not (Jr.), so we remove the periods from `piece` when testing against `C.suffix_acronyms`. """ # suffixes may have periods inside them like "M.D." if isinstance(piece, list): for item in piece: if self.is_suffix(item): return True else: return ((lc(piece).replace('.', '') in self.C.suffix_acronyms) or (lc(piece) in self.C.suffix_not_acronyms)) \ and not self.is_an_initial(piece)
[docs] def are_suffixes(self, pieces): """Return True if all pieces are suffixes.""" for piece in pieces: if not self.is_suffix(piece): return False return True
[docs] def is_rootname(self, piece): """ Is not a known title, suffix or prefix. Just first, middle, last names. """ return lc(piece) not in self.C.suffixes_prefixes_titles \ and not self.is_an_initial(piece)
[docs] def is_an_initial(self, value): """ Words with a single period at the end, or a single uppercase letter. Matches the ``initial`` regular expression in :py:data:`~nameparser.config.regexes.REGEXES`. """ return bool(self.C.regexes.initial.match(value))
# full_name parser @property def full_name(self): """The string output of the HumanName instance.""" return self.__str__() @full_name.setter def full_name(self, value): self.original = value self._full_name = value if isinstance(value, binary_type): self._full_name = value.decode(self.encoding) self.parse_full_name() def collapse_whitespace(self, string): # collapse multiple spaces into single space string = self.C.regexes.spaces.sub(" ", string.strip()) if string.endswith(","): string = string[:-1] return string
[docs] def pre_process(self): """ This method happens at the beginning of the :py:func:`parse_full_name` before any other processing of the string aside from unicode normalization, so it's a good place to do any custom handling in a subclass. Runs :py:func:`parse_nicknames` and :py:func:`squash_emoji`. """ self.fix_phd() self.parse_nicknames() self.squash_emoji()
[docs] def post_process(self): """ This happens at the end of the :py:func:`parse_full_name` after all other processing has taken place. Runs :py:func:`handle_firstnames` and :py:func:`handle_capitalization`. """ self.handle_firstnames() self.handle_capitalization()
def fix_phd(self): try: _re = match = if match: self.suffix_list.append( self._full_name = _re.sub('', self._full_name) except AttributeError: pass
[docs] def parse_nicknames(self): """ The content of parenthesis or quotes in the name will be added to the nicknames list. This happens before any other processing of the name. Single quotes cannot span white space characters and must border white space to allow for quotes in names like O'Connor and Kawai'ae'a. Double quotes and parenthesis can span white space. Loops through 3 :py:data:`~nameparser.config.regexes.REGEXES`; `quoted_word`, `double_quotes` and `parenthesis`. """ empty_re = re.compile("") re_quoted_word = self.C.regexes.quoted_word or empty_re re_double_quotes = self.C.regexes.double_quotes or empty_re re_parenthesis = self.C.regexes.parenthesis or empty_re for _re in (re_quoted_word, re_double_quotes, re_parenthesis): if self.nickname_list += [x for x in _re.findall(self._full_name)] self._full_name = _re.sub('', self._full_name)
[docs] def squash_emoji(self): """ Remove emoji from the input string. """ re_emoji = self.C.regexes.emoji if re_emoji and self._full_name = re_emoji.sub('', self._full_name)
[docs] def handle_firstnames(self): """ If there are only two parts and one is a title, assume it's a last name instead of a first name. e.g. Mr. Johnson. Unless it's a special title like "Sir", then when it's followed by a single name that name is always a first name. """ if self.title \ and len(self) == 2 \ and not lc(self.title) in self.C.first_name_titles: self.last, self.first = self.first, self.last
[docs] def parse_full_name(self): """ The main parse method for the parser. This method is run upon assignment to the :py:attr:`full_name` attribute or instantiation. Basic flow is to hand off to :py:func:`pre_process` to handle nicknames. It then splits on commas and chooses a code path depending on the number of commas. :py:func:`parse_pieces` then splits those parts on spaces and :py:func:`join_on_conjunctions` joins any pieces next to conjunctions. """ self.title_list = [] self.first_list = [] self.middle_list = [] self.last_list = [] self.suffix_list = [] self.nickname_list = [] self.unparsable = True self.pre_process() self._full_name = self.collapse_whitespace(self._full_name) # break up full_name by commas parts = [x.strip() for x in self._full_name.split(",")] log.debug("full_name: %s", self._full_name) log.debug("parts: %s", parts) if len(parts) == 1: # no commas, title first middle middle middle last suffix # part[0] pieces = self.parse_pieces(parts) p_len = len(pieces) for i, piece in enumerate(pieces): try: nxt = pieces[i + 1] except IndexError: nxt = None # title must have a next piece, unless it's just a title if not self.first \ and (nxt or p_len == 1) \ and self.is_title(piece): self.title_list.append(piece) continue if not self.first: if p_len == 1 and self.nickname: self.last_list.append(piece) continue self.first_list.append(piece) continue if self.are_suffixes(pieces[i+1:]) or \ ( # if the next piece is the last piece and a roman # numeral but this piece is not an initial self.is_roman_numeral(nxt) and i == p_len - 2 and not self.is_an_initial(piece) ): self.last_list.append(piece) self.suffix_list += pieces[i+1:] break if not nxt: self.last_list.append(piece) continue self.middle_list.append(piece) else: # if all the end parts are suffixes and there is more than one piece # in the first part. (Suffixes will never appear after last names # only, and allows potential first names to be in suffixes, e.g. # "Johnson, Bart" post_comma_pieces = self.parse_pieces(parts[1].split(' '), 1) if self.are_suffixes(parts[1].split(' ')) \ and len(parts[0].split(' ')) > 1: # suffix comma: # title first middle last [suffix], suffix [suffix] [, suffix] # parts[0], parts[1:...] self.suffix_list += parts[1:] pieces = self.parse_pieces(parts[0].split(' ')) log.debug("pieces: %s", u(pieces)) for i, piece in enumerate(pieces): try: nxt = pieces[i + 1] except IndexError: nxt = None if not self.first \ and (nxt or len(pieces) == 1) \ and self.is_title(piece): self.title_list.append(piece) continue if not self.first: self.first_list.append(piece) continue if self.are_suffixes(pieces[i+1:]): self.last_list.append(piece) self.suffix_list = pieces[i+1:] + self.suffix_list break if not nxt: self.last_list.append(piece) continue self.middle_list.append(piece) else: # lastname comma: # last [suffix], title first middles[,] suffix [,suffix] # parts[0], parts[1], parts[2:...] log.debug("post-comma pieces: %s", u(post_comma_pieces)) # lastname part may have suffixes in it lastname_pieces = self.parse_pieces(parts[0].split(' '), 1) for piece in lastname_pieces: # the first one is always a last name, even if it looks like # a suffix if self.is_suffix(piece) and len(self.last_list) > 0: self.suffix_list.append(piece) else: self.last_list.append(piece) for i, piece in enumerate(post_comma_pieces): try: nxt = post_comma_pieces[i + 1] except IndexError: nxt = None if not self.first \ and (nxt or len(post_comma_pieces) == 1) \ and self.is_title(piece): self.title_list.append(piece) continue if not self.first: self.first_list.append(piece) continue if self.is_suffix(piece): self.suffix_list.append(piece) continue self.middle_list.append(piece) try: if parts[2]: self.suffix_list += parts[2:] except IndexError: pass if len(self) < 0:"Unparsable: \"%s\" ", self.original) else: self.unparsable = False self.post_process()
[docs] def parse_pieces(self, parts, additional_parts_count=0): """ Split parts on spaces and remove commas, join on conjunctions and lastname prefixes. If parts have periods in the middle, try splitting on periods and check if the parts are titles or suffixes. If they are add to the constant so they will be found. :param list parts: name part strings from the comma split :param int additional_parts_count: if the comma format contains other parts, we need to know how many there are to decide if things should be considered a conjunction. :return: pieces split on spaces and joined on conjunctions :rtype: list """ output = [] for part in parts: if not isinstance(part, text_types): raise TypeError("Name parts must be strings. " "Got {0}".format(type(part))) output += [x.strip(' ,') for x in part.split(' ')] # If part contains periods, check if it's multiple titles or suffixes # together without spaces if so, add the new part with periods to the # constants so they get parsed correctly later for part in output: # if this part has a period not at the beginning or end if self.C.regexes.period_not_at_end and self.C.regexes.period_not_at_end.match(part): # split on periods, any of the split pieces titles or suffixes? # ("Lt.Gov.") period_chunks = part.split(".") titles = list(filter(self.is_title, period_chunks)) suffixes = list(filter(self.is_suffix, period_chunks)) # add the part to the constant so it will be found if len(list(titles)): self.C.titles.add(part) continue if len(list(suffixes)): self.C.suffix_not_acronyms.add(part) continue return self.join_on_conjunctions(output, additional_parts_count)
[docs] def join_on_conjunctions(self, pieces, additional_parts_count=0): """ Join conjunctions to surrounding pieces. Title- and prefix-aware. e.g.: ['Mr.', 'and'. 'Mrs.', 'John', 'Doe'] ==> ['Mr. and Mrs.', 'John', 'Doe'] ['The', 'Secretary', 'of', 'State', 'Hillary', 'Clinton'] ==> ['The Secretary of State', 'Hillary', 'Clinton'] When joining titles, saves newly formed piece to the instance's titles constant so they will be parsed correctly later. E.g. after parsing the example names above, 'The Secretary of State' and 'Mr. and Mrs.' would be present in the titles constant set. :param list pieces: name pieces strings after split on spaces :param int additional_parts_count: :return: new list with piece next to conjunctions merged into one piece with spaces in it. :rtype: list """ length = len(pieces) + additional_parts_count # don't join on conjunctions if there's only 2 parts if length < 3: return pieces rootname_pieces = [p for p in pieces if self.is_rootname(p)] total_length = len(rootname_pieces) + additional_parts_count # find all the conjunctions, join any conjunctions that are next to each # other, then join those newly joined conjunctions and any single # conjunctions to the piece before and after it conj_index = [i for i, piece in enumerate(pieces) if self.is_conjunction(piece)] contiguous_conj_i = [] for i, val in enumerate(conj_index): try: if conj_index[i+1] == val+1: contiguous_conj_i += [val] except IndexError: pass contiguous_conj_i = group_contiguous_integers(conj_index) delete_i = [] for i in contiguous_conj_i: if type(i) == tuple: new_piece = " ".join(pieces[i[0]: i[1]+1]) delete_i += list(range(i[0]+1, i[1]+1)) pieces[i[0]] = new_piece else: new_piece = " ".join(pieces[i: i+2]) delete_i += [i+1] pieces[i] = new_piece # add newly joined conjunctions to constants to be found later self.C.conjunctions.add(new_piece) for i in reversed(delete_i): # delete pieces in reverse order or the index changes on each delete del pieces[i] if len(pieces) == 1: # if there's only one piece left, nothing left to do return pieces # refresh conjunction index locations conj_index = [i for i, piece in enumerate(pieces) if self.is_conjunction(piece)] for i in conj_index: if len(pieces[i]) == 1 and total_length < 4: # if there are only 3 total parts (minus known titles, suffixes # and prefixes) and this conjunction is a single letter, prefer # treating it as an initial rather than a conjunction. # continue if i == 0: new_piece = " ".join(pieces[i:i+2]) if self.is_title(pieces[i+1]): # when joining to a title, make new_piece a title too self.C.titles.add(new_piece) pieces[i] = new_piece pieces.pop(i+1) # subtract 1 from the index of all the remaining conjunctions for j, val in enumerate(conj_index): if val > i: conj_index[j] = val-1 else: new_piece = " ".join(pieces[i-1:i+2]) if self.is_title(pieces[i-1]): # when joining to a title, make new_piece a title too self.C.titles.add(new_piece) pieces[i-1] = new_piece pieces.pop(i) rm_count = 2 try: pieces.pop(i) except IndexError: rm_count = 1 # subtract the number of removed pieces from the index # of all the remaining conjunctions for j, val in enumerate(conj_index): if val > i: conj_index[j] = val - rm_count # join prefixes to following lastnames: ['de la Vega'], ['van Buren'] prefixes = list(filter(self.is_prefix, pieces)) if prefixes: for prefix in prefixes: try: i = pieces.index(prefix) except ValueError: # If the prefix is no longer in pieces, it's because it has been # combined with the prefix that appears right before (or before that when # chained together) in the last loop, so the index of that newly created # piece is the same as in the last loop, i==i still, and we want to join # it to the next piece. pass new_piece = '' # join everything after the prefix until the next prefix or suffix try: if i == 0 and total_length >= 1: # If it's the first piece and there are more than 1 rootnames, assume it's a first name continue next_prefix = next(iter(filter(self.is_prefix, pieces[i + 1:]))) j = pieces.index(next_prefix, i + 1) if j == i + 1: # if there are two prefixes in sequence, join to the following piece j += 1 new_piece = ' '.join(pieces[i:j]) pieces = pieces[:i] + [new_piece] + pieces[j:] except StopIteration: try: # if there are no more prefixes, look for a suffix to stop at stop_at = next(iter(filter(self.is_suffix, pieces[i + 1:]))) j = pieces.index(stop_at) new_piece = ' '.join(pieces[i:j]) pieces = pieces[:i] + [new_piece] + pieces[j:] except StopIteration: # if there were no suffixes, nothing to stop at so join all # remaining pieces new_piece = ' '.join(pieces[i:]) pieces = pieces[:i] + [new_piece] log.debug("pieces: %s", pieces) return pieces
# Capitalization Support def cap_word(self, word, attribute): if (self.is_prefix(word) and attribute in ('last', 'middle')) \ or self.is_conjunction(word): return word.lower() exceptions = self.C.capitalization_exceptions if lc(word) in exceptions: return exceptions[lc(word)] mac_match = self.C.regexes.mac.match(word) if mac_match: def cap_after_mac(m): return + return self.C.regexes.mac.sub(cap_after_mac, word) else: return word.capitalize() def cap_piece(self, piece, attribute): if not piece: return "" def replacement(m): return self.cap_word(, attribute) return self.C.regexes.word.sub(replacement, piece)
[docs] def capitalize(self, force=None): """ The HumanName class can try to guess the correct capitalization of name entered in all upper or lower case. By default, it will not adjust the case of names entered in mixed case. To run capitalization on all names pass the parameter `force=True`. :param bool force: Forces capitalization of mixed case strings. This parameter overrides rules set within :py:class:`~nameparser.config.CONSTANTS`. **Usage** .. doctest:: capitalize >>> name = HumanName('bob v. de la macdole-eisenhower phd') >>> name.capitalize() >>> str(name) 'Bob V. de la MacDole-Eisenhower Ph.D.' >>> # Don't touch good names >>> name = HumanName('Shirley Maclaine') >>> name.capitalize() >>> str(name) 'Shirley Maclaine' >>> name.capitalize(force=True) >>> str(name) 'Shirley MacLaine' """ name = u(self) force = self.C.force_mixed_case_capitalization \ if force is None else force if not force and not (name == name.upper() or name == name.lower()): return self.title_list = self.cap_piece(self.title, 'title').split(' ') self.first_list = self.cap_piece(self.first, 'first').split(' ') self.middle_list = self.cap_piece(self.middle, 'middle').split(' ') self.last_list = self.cap_piece(self.last, 'last').split(' ') self.suffix_list = self.cap_piece(self.suffix, 'suffix').split(', ')
[docs] def handle_capitalization(self): """ Handles capitalization configurations set within :py:class:`~nameparser.config.CONSTANTS`. """ if self.C.capitalize_name: self.capitalize()