doctable.DocParser = class DocParser(builtins.object)
    Class that maintains convenient functions for parsing Spacy doc objects.
 
  Class methods defined here:
distribute_parse(texts, spacynlp, parsefunc=None, preprocessfunc=None, dt_inst=None, paragraph_sep=None, workers=None) from builtins.type
Distributes text parsing across multiple processes in chunks.
Args:
    texts (list): list of raw texts to process
    spacynlp (spacy nlp object): for applying .pipe() to doc chunks
    parsefunc (func): convert spacy doc object to storage represenation
        By defaut uses DocParser.tokenize_doc().
    preprocessfunc (func): process text before parsing. Uses 
        DocParser.preprocess() by default.
    dt_inst (doctable instance): if included, will pass to parsefunc as
        second argument. Usually to do this, you'll create a function
        which calls some overloaded version of .tokenize_doc() and then
        calls dt_inst.insert() to place in database.
    paragraph_sep (str or None): if defined, will distribute parsing across
        paragraphs and leave paragraph structure of docs in nested lists.
    workers (int): number of processes to create.
Returns:
    output of parsing
get_parsetrees(doc, parse_tok_func=None, info_func_map={}, merge_ents=False, spacy_ngram_matcher=None, merge_noun_chunks=False) from builtins.type
Extracts parsetree from spacy doc objects.
Args:
    doc (spacy.Doc object): doc to generate parsetree from.
    parse_tok_func (func): function used to convert token to 
        a string representation. Usually a lambda function 
        wrapping some variant of self.parse_tok().
    info_func_map (dict<str->func>): attribute to function 
        mapping. Functions take a token and output a property
        that will be stored in each parsetree node.
    merge_ents (bool): merge multi-word entities.
    spacy_ngram_matcher (Spacy Matcher): used to create ngrams
        with Spacy. Powerful wildcards etc.
    merge_noun_chunks (bool): merge noun chunks or not.
parse_text_chunks(text, nlp, parse_funcs={}, doc_transform=None, chunk_sents=1000, split_re='([\\?\\!\\.]+)(?=[\\WA-Z])') from builtins.type
Parse text in paragraph by sentences.
Args:
    text (str): (preprocessed) text document to parse
    nlp (spaCy parser): with .pipe() method to parse documents
    parse_funcs (list<func>): convert doc to 
    chunk_sents (int): number of sentences used in each chunk to 
        be parsed. Max size for single spacy doc is 1 million 
        chars. If av num chars per sent is 75-100, a size of
        3000 means each chunk will have approx 300k characters.
        Hopefully, on average small enough. Larger value means
        more memory but faster processing.
preprocess(text, replace_url=None, replace_xml=None, replace_digits=None) from builtins.type
Apply preprocessing step, modifies and returns text.
Args:
    text (str): document as a text string
    replace_url (str or None): if not None, replace url with string
    replace_xml (str or None): if not None, replace xml tags with string
    replace_digits (str or None): if not None, replace digits with string
tokenize_doc(doc, split_sents=False, merge_ents=False, merge_noun_chunks=False, ngrams=[], spacy_ngram_matcher=None, ngram_sep=' ', use_tok_func=None, parse_tok_func=None) from builtins.type
Parse spacy doc object.
Args:
    split_sents (bool): parse into list of sentence tokens using doc.sents.
    merge_ents (bool): merge multi_word entities into same token.
    ngrams (iter<iter<str>>): iterable of token tuples to merge after parsing.
    spacy_ngram_matcher (spacy Matcher): matcher object to use on the spacy doc.
        Normally will create using spacy.Matcher(nlp.vocab), see more details
        at https://spacy.io/usage/rule-based-matching And also note that the 
        nlp object must be the one used for parsing.
    use_tok_func (func): func used to decide to keep func or not. Default is
        cls.use_tok().
    parse_tok_func (func): func used to parse tokens. By default uses 
        cls.parse_tok().

Static methods defined here:
apply_doc_transform(doc, merge_ents=True, spacy_ngram_matcher=None, merge_noun_chunks=False)
Apply merges to doc object including entities, normal ngrams, and noun chunks.
merge_ngrams(toks, ngrams, ngram_sep=' ')
Merges manually specified consecutive tokens into single tokens.
parse_tok(tok, num_replacement=None, digit_replacement=None, lemmatize=False, normal_convert=None, format_ents=False, ent_convert=None)
Convert spacy token object to string.
Args:
    tok (spacy token or span): token object to convert to string.
    replace_num (str/None): Replace number following tok.like_num (includes "five", 
        or 5) with a special token (i.e. __NUM__). None means no replacement.
    replace_digit (str/None): Replace digit meeting tok.is_digit with special token. 
        Only used when replace_num is None.
    lemmatize (bool): return lemma instead of full word.
    normal_convert (func): custom conversion function to happen as last step
        for non-entities. This way can keep all other functionality.
    format_ents (bool): Replace whitespace with space and capitalize first 
        letter of ents.
    ent_convert (func): custom conversion function to happen as last step
        for entities. This way can keep all other functionality.
spacy_parse_chunks(text, nlp, parsefuncs=[], chunk_size=10)
Parses document in sentence chunks to reduce memory use.
use_tok(tok, filter_whitespace=True, filter_punct=False, filter_stop=False, filter_digit=False, filter_num=False, filter_all_ents=False, filter_ent_types=())
Decide to use token or not (can be overridden).
Args:
    no_whitespace (bool): exclude whitespace.
    no_punct (bool): exclude punctuation.
    no_num (bool): exclude numbers using tok.is_num.
    no_digit (bool): exclude digits using tok.is_digit.
    no_stop (bool): exclude stopwords.

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Data and other attributes defined here:
re_digits = re.compile('\\d*[-\\./,]*\\d+')
re_url = re.compile('http\\S+', re.MULTILINE)
re_xml_tag = re.compile('<[^<]+>', re.MULTILINE)