2016-12-19 00:33:53 +03:00
|
|
|
|
# cython: infer_types=True
|
2017-04-15 14:05:15 +03:00
|
|
|
|
# coding: utf8
|
2016-12-19 00:33:53 +03:00
|
|
|
|
from __future__ import unicode_literals
|
|
|
|
|
|
2015-07-13 20:20:48 +03:00
|
|
|
|
from libc.string cimport memcpy
|
|
|
|
|
from cpython.mem cimport PyMem_Malloc, PyMem_Free
|
|
|
|
|
# Compiler crashes on memory view coercion without this. Should report bug.
|
|
|
|
|
from cython.view cimport array as cvarray
|
2015-07-13 21:20:58 +03:00
|
|
|
|
cimport numpy as np
|
|
|
|
|
np.import_array()
|
|
|
|
|
import numpy
|
|
|
|
|
|
2016-09-23 15:22:06 +03:00
|
|
|
|
from ..typedefs cimport hash_t
|
2015-09-06 20:45:15 +03:00
|
|
|
|
from ..lexeme cimport Lexeme
|
2015-10-10 09:55:55 +03:00
|
|
|
|
from .. import parts_of_speech
|
2015-07-26 17:37:16 +03:00
|
|
|
|
from ..attrs cimport IS_ALPHA, IS_ASCII, IS_DIGIT, IS_LOWER, IS_PUNCT, IS_SPACE
|
2017-05-13 14:04:40 +03:00
|
|
|
|
from ..attrs cimport IS_BRACKET, IS_QUOTE, IS_LEFT_PUNCT, IS_RIGHT_PUNCT, IS_OOV
|
2015-07-26 17:37:16 +03:00
|
|
|
|
from ..attrs cimport IS_TITLE, IS_UPPER, LIKE_URL, LIKE_NUM, LIKE_EMAIL, IS_STOP
|
2017-05-13 14:04:40 +03:00
|
|
|
|
from ..attrs cimport ID, ORTH, NORM, LOWER, SHAPE, PREFIX, SUFFIX, LENGTH, CLUSTER
|
|
|
|
|
from ..attrs cimport LEMMA, POS, TAG, DEP
|
2017-04-15 14:05:15 +03:00
|
|
|
|
from ..compat import is_config
|
2017-05-13 14:05:47 +03:00
|
|
|
|
from .. import about
|
2017-10-07 19:56:01 +03:00
|
|
|
|
from .underscore import Underscore
|
2015-08-23 21:49:18 +03:00
|
|
|
|
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
|
|
|
|
cdef class Token:
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""An individual token – i.e. a word, punctuation symbol, whitespace, etc."""
|
2017-10-07 19:56:01 +03:00
|
|
|
|
@classmethod
|
|
|
|
|
def set_extension(cls, name, default=None, method=None,
|
|
|
|
|
getter=None, setter=None):
|
2017-10-10 05:15:14 +03:00
|
|
|
|
Underscore.token_extensions[name] = (default, method, getter, setter)
|
2017-10-07 19:56:01 +03:00
|
|
|
|
|
|
|
|
|
@classmethod
|
|
|
|
|
def get_extension(cls, name):
|
|
|
|
|
return Underscore.span_extensions.get(name)
|
|
|
|
|
|
|
|
|
|
@classmethod
|
|
|
|
|
def has_extension(cls, name):
|
|
|
|
|
return name in Underscore.span_extensions
|
|
|
|
|
|
2015-07-14 01:10:11 +03:00
|
|
|
|
def __cinit__(self, Vocab vocab, Doc doc, int offset):
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""Construct a `Token` object.
|
|
|
|
|
|
|
|
|
|
vocab (Vocab): A storage container for lexical types.
|
|
|
|
|
doc (Doc): The parent document.
|
|
|
|
|
offset (int): The index of the token within the document.
|
|
|
|
|
"""
|
2015-07-13 20:20:48 +03:00
|
|
|
|
self.vocab = vocab
|
2015-07-14 01:10:11 +03:00
|
|
|
|
self.doc = doc
|
2015-11-03 16:15:14 +03:00
|
|
|
|
self.c = &self.doc.c[offset]
|
2015-07-14 01:10:11 +03:00
|
|
|
|
self.i = offset
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
2017-01-16 15:27:57 +03:00
|
|
|
|
def __hash__(self):
|
|
|
|
|
return hash((self.doc, self.i))
|
|
|
|
|
|
2015-07-13 20:20:48 +03:00
|
|
|
|
def __len__(self):
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""The number of unicode characters in the token, i.e. `token.text`.
|
|
|
|
|
|
|
|
|
|
RETURNS (int): The number of unicode characters in the token.
|
2017-04-15 14:05:15 +03:00
|
|
|
|
"""
|
2015-07-13 20:20:48 +03:00
|
|
|
|
return self.c.lex.length
|
|
|
|
|
|
|
|
|
|
def __unicode__(self):
|
2016-10-17 15:02:47 +03:00
|
|
|
|
return self.text
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
2015-11-02 21:22:18 +03:00
|
|
|
|
def __bytes__(self):
|
2016-10-17 15:02:47 +03:00
|
|
|
|
return self.text.encode('utf8')
|
2015-11-02 21:22:18 +03:00
|
|
|
|
|
2015-07-24 04:49:30 +03:00
|
|
|
|
def __str__(self):
|
2017-04-15 14:05:15 +03:00
|
|
|
|
if is_config(python3=True):
|
2015-11-02 21:22:18 +03:00
|
|
|
|
return self.__unicode__()
|
|
|
|
|
return self.__bytes__()
|
2015-07-24 04:49:30 +03:00
|
|
|
|
|
2015-10-21 14:11:46 +03:00
|
|
|
|
def __repr__(self):
|
2015-11-02 21:22:18 +03:00
|
|
|
|
return self.__str__()
|
2015-10-21 14:11:46 +03:00
|
|
|
|
|
2017-01-11 15:03:32 +03:00
|
|
|
|
def __richcmp__(self, Token other, int op):
|
2017-01-09 21:30:31 +03:00
|
|
|
|
# http://cython.readthedocs.io/en/latest/src/userguide/special_methods.html
|
2017-08-19 17:39:32 +03:00
|
|
|
|
cdef Doc my_doc = self.doc
|
|
|
|
|
cdef Doc other_doc = other.doc
|
2017-01-09 21:30:31 +03:00
|
|
|
|
my = self.idx
|
2017-01-11 15:03:32 +03:00
|
|
|
|
their = other.idx if other is not None else None
|
2017-01-09 21:30:31 +03:00
|
|
|
|
if op == 0:
|
|
|
|
|
return my < their
|
|
|
|
|
elif op == 2:
|
2017-08-19 17:39:32 +03:00
|
|
|
|
if my_doc is other_doc:
|
|
|
|
|
return my == their
|
|
|
|
|
else:
|
|
|
|
|
return False
|
2017-01-09 21:30:31 +03:00
|
|
|
|
elif op == 4:
|
|
|
|
|
return my > their
|
|
|
|
|
elif op == 1:
|
|
|
|
|
return my <= their
|
|
|
|
|
elif op == 3:
|
2017-08-19 17:39:32 +03:00
|
|
|
|
if my_doc is other_doc:
|
|
|
|
|
return my != their
|
|
|
|
|
else:
|
|
|
|
|
return True
|
2017-01-09 21:30:31 +03:00
|
|
|
|
elif op == 5:
|
|
|
|
|
return my >= their
|
|
|
|
|
else:
|
|
|
|
|
raise ValueError(op)
|
|
|
|
|
|
2017-10-07 19:56:01 +03:00
|
|
|
|
@property
|
|
|
|
|
def _(self):
|
|
|
|
|
return Underscore(Underscore.token_extensions, self,
|
|
|
|
|
start=self.idx, end=None)
|
|
|
|
|
|
2015-07-13 20:20:48 +03:00
|
|
|
|
cpdef bint check_flag(self, attr_id_t flag_id) except -1:
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""Check the value of a boolean flag.
|
|
|
|
|
|
|
|
|
|
flag_id (int): The ID of the flag attribute.
|
|
|
|
|
RETURNS (bool): Whether the flag is set.
|
2017-02-27 00:27:11 +03:00
|
|
|
|
|
2017-05-19 19:47:56 +03:00
|
|
|
|
EXAMPLE:
|
|
|
|
|
>>> from spacy.attrs import IS_TITLE
|
|
|
|
|
>>> doc = nlp(u'Give it back! He pleaded.')
|
|
|
|
|
>>> token = doc[0]
|
|
|
|
|
>>> token.check_flag(IS_TITLE)
|
|
|
|
|
True
|
2017-04-15 14:05:15 +03:00
|
|
|
|
"""
|
2015-09-15 06:06:18 +03:00
|
|
|
|
return Lexeme.c_check_flag(self.c.lex, flag_id)
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
|
|
|
|
def nbor(self, int i=1):
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""Get a neighboring token.
|
2016-11-01 14:25:36 +03:00
|
|
|
|
|
2017-05-19 19:47:56 +03:00
|
|
|
|
i (int): The relative position of the token to get. Defaults to 1.
|
|
|
|
|
RETURNS (Token): The token at position `self.doc[self.i+i]`.
|
2017-04-15 14:05:15 +03:00
|
|
|
|
"""
|
2017-10-24 13:10:39 +03:00
|
|
|
|
if self.i+i < 0 or (self.i+i >= len(self.doc)):
|
|
|
|
|
msg = "Error accessing doc[%d].nbor(%d), for doc of length %d"
|
|
|
|
|
raise IndexError(msg % (self.i, i, len(self.doc)))
|
2015-07-14 01:10:11 +03:00
|
|
|
|
return self.doc[self.i+i]
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
2015-09-14 10:49:58 +03:00
|
|
|
|
def similarity(self, other):
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""Make a semantic similarity estimate. The default estimate is cosine
|
|
|
|
|
similarity using an average of word vectors.
|
|
|
|
|
|
|
|
|
|
other (object): The object to compare with. By default, accepts `Doc`,
|
|
|
|
|
`Span`, `Token` and `Lexeme` objects.
|
|
|
|
|
RETURNS (float): A scalar similarity score. Higher is more similar.
|
2017-04-15 14:05:15 +03:00
|
|
|
|
"""
|
2016-10-19 21:54:03 +03:00
|
|
|
|
if 'similarity' in self.doc.user_token_hooks:
|
2017-05-31 00:35:17 +03:00
|
|
|
|
return self.doc.user_token_hooks['similarity'](self)
|
2015-09-22 03:10:01 +03:00
|
|
|
|
if self.vector_norm == 0 or other.vector_norm == 0:
|
|
|
|
|
return 0.0
|
2015-09-14 10:49:58 +03:00
|
|
|
|
return numpy.dot(self.vector, other.vector) / (self.vector_norm * other.vector_norm)
|
|
|
|
|
|
2015-07-13 20:20:48 +03:00
|
|
|
|
property lex_id:
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""ID of the token's lexical type.
|
|
|
|
|
|
|
|
|
|
RETURNS (int): ID of the token's lexical type."""
|
2015-07-13 20:20:48 +03:00
|
|
|
|
def __get__(self):
|
|
|
|
|
return self.c.lex.id
|
|
|
|
|
|
2015-11-08 18:18:25 +03:00
|
|
|
|
property rank:
|
2017-05-19 19:47:56 +03:00
|
|
|
|
# TODO: add docstring
|
2015-11-08 18:18:25 +03:00
|
|
|
|
def __get__(self):
|
|
|
|
|
return self.c.lex.id
|
|
|
|
|
|
2015-07-13 20:20:48 +03:00
|
|
|
|
property string:
|
|
|
|
|
def __get__(self):
|
2016-01-16 19:14:34 +03:00
|
|
|
|
return self.text_with_ws
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
2015-09-13 03:27:42 +03:00
|
|
|
|
property text:
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""A unicode representation of the token text.
|
|
|
|
|
|
|
|
|
|
RETURNS (unicode): The original verbatim text of the token.
|
|
|
|
|
"""
|
2015-09-13 03:27:42 +03:00
|
|
|
|
def __get__(self):
|
|
|
|
|
return self.orth_
|
|
|
|
|
|
|
|
|
|
property text_with_ws:
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""The text content of the token with a trailing whitespace character if
|
|
|
|
|
it has one.
|
|
|
|
|
|
|
|
|
|
RETURNS (unicode): The text content of the span (with trailing whitespace).
|
|
|
|
|
"""
|
2015-09-13 03:27:42 +03:00
|
|
|
|
def __get__(self):
|
2016-09-30 21:20:22 +03:00
|
|
|
|
cdef unicode orth = self.vocab.strings[self.c.lex.orth]
|
2015-09-13 03:27:42 +03:00
|
|
|
|
if self.c.spacy:
|
2016-09-30 21:20:22 +03:00
|
|
|
|
return orth + u' '
|
2015-09-13 03:27:42 +03:00
|
|
|
|
else:
|
2016-09-30 21:20:22 +03:00
|
|
|
|
return orth
|
2015-09-13 03:27:42 +03:00
|
|
|
|
|
2015-07-13 20:20:48 +03:00
|
|
|
|
property prob:
|
|
|
|
|
def __get__(self):
|
|
|
|
|
return self.c.lex.prob
|
|
|
|
|
|
2016-10-19 21:54:03 +03:00
|
|
|
|
property sentiment:
|
|
|
|
|
def __get__(self):
|
|
|
|
|
if 'sentiment' in self.doc.user_token_hooks:
|
|
|
|
|
return self.doc.user_token_hooks['sentiment'](self)
|
|
|
|
|
return self.c.lex.sentiment
|
|
|
|
|
|
2016-03-10 15:01:34 +03:00
|
|
|
|
property lang:
|
|
|
|
|
def __get__(self):
|
|
|
|
|
return self.c.lex.lang
|
|
|
|
|
|
2015-07-13 20:20:48 +03:00
|
|
|
|
property idx:
|
|
|
|
|
def __get__(self):
|
|
|
|
|
return self.c.idx
|
|
|
|
|
|
|
|
|
|
property cluster:
|
|
|
|
|
def __get__(self):
|
|
|
|
|
return self.c.lex.cluster
|
|
|
|
|
|
|
|
|
|
property orth:
|
|
|
|
|
def __get__(self):
|
|
|
|
|
return self.c.lex.orth
|
|
|
|
|
|
|
|
|
|
property lower:
|
|
|
|
|
def __get__(self):
|
|
|
|
|
return self.c.lex.lower
|
|
|
|
|
|
|
|
|
|
property norm:
|
|
|
|
|
def __get__(self):
|
|
|
|
|
return self.c.lex.norm
|
|
|
|
|
|
|
|
|
|
property shape:
|
|
|
|
|
def __get__(self):
|
|
|
|
|
return self.c.lex.shape
|
|
|
|
|
|
|
|
|
|
property prefix:
|
|
|
|
|
def __get__(self):
|
|
|
|
|
return self.c.lex.prefix
|
|
|
|
|
|
|
|
|
|
property suffix:
|
|
|
|
|
def __get__(self):
|
|
|
|
|
return self.c.lex.suffix
|
|
|
|
|
|
|
|
|
|
property lemma:
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""Base form of the word, with no inflectional suffixes.
|
|
|
|
|
|
2017-05-28 16:10:22 +03:00
|
|
|
|
RETURNS (uint64): Token lemma.
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""
|
2015-07-13 20:20:48 +03:00
|
|
|
|
def __get__(self):
|
|
|
|
|
return self.c.lemma
|
2017-05-28 16:10:22 +03:00
|
|
|
|
def __set__(self, attr_t lemma):
|
2017-04-16 19:07:53 +03:00
|
|
|
|
self.c.lemma = lemma
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
|
|
|
|
property pos:
|
|
|
|
|
def __get__(self):
|
|
|
|
|
return self.c.pos
|
|
|
|
|
|
|
|
|
|
property tag:
|
|
|
|
|
def __get__(self):
|
|
|
|
|
return self.c.tag
|
2017-05-28 16:10:22 +03:00
|
|
|
|
def __set__(self, attr_t tag):
|
2016-11-04 02:29:07 +03:00
|
|
|
|
self.vocab.morphology.assign_tag(self.c, tag)
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
|
|
|
|
property dep:
|
|
|
|
|
def __get__(self):
|
|
|
|
|
return self.c.dep
|
2017-05-28 16:10:22 +03:00
|
|
|
|
def __set__(self, attr_t label):
|
2016-03-11 19:31:06 +03:00
|
|
|
|
self.c.dep = label
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
2015-09-21 12:52:43 +03:00
|
|
|
|
property has_vector:
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""A boolean value indicating whether a word vector is associated with
|
|
|
|
|
the object.
|
|
|
|
|
|
|
|
|
|
RETURNS (bool): Whether a word vector is associated with the object.
|
2017-04-15 14:05:15 +03:00
|
|
|
|
"""
|
2015-09-21 12:52:43 +03:00
|
|
|
|
def __get__(self):
|
2016-10-19 21:54:03 +03:00
|
|
|
|
if 'has_vector' in self.doc.user_token_hooks:
|
|
|
|
|
return self.doc.user_token_hooks['has_vector'](self)
|
2017-06-04 22:19:58 +03:00
|
|
|
|
return self.vocab.has_vector(self.c.lex.orth)
|
2015-09-21 12:52:43 +03:00
|
|
|
|
|
2015-09-14 10:49:58 +03:00
|
|
|
|
property vector:
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""A real-valued meaning representation.
|
2017-02-27 00:27:11 +03:00
|
|
|
|
|
2017-05-19 19:47:56 +03:00
|
|
|
|
RETURNS (numpy.ndarray[ndim=1, dtype='float32']): A 1D numpy array
|
|
|
|
|
representing the token's semantics.
|
2017-04-15 14:05:15 +03:00
|
|
|
|
"""
|
2015-07-13 20:20:48 +03:00
|
|
|
|
def __get__(self):
|
2016-10-19 21:54:03 +03:00
|
|
|
|
if 'vector' in self.doc.user_token_hooks:
|
|
|
|
|
return self.doc.user_token_hooks['vector'](self)
|
2017-05-31 00:35:17 +03:00
|
|
|
|
if self.has_vector:
|
|
|
|
|
return self.vocab.get_vector(self.c.lex.orth)
|
|
|
|
|
else:
|
|
|
|
|
return self.doc.tensor[self.i]
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
2015-09-14 10:49:58 +03:00
|
|
|
|
property vector_norm:
|
2017-05-20 16:13:33 +03:00
|
|
|
|
"""The L2 norm of the token's vector representation.
|
2017-05-19 19:47:56 +03:00
|
|
|
|
|
|
|
|
|
RETURNS (float): The L2 norm of the vector representation.
|
|
|
|
|
"""
|
2015-09-14 10:49:58 +03:00
|
|
|
|
def __get__(self):
|
2016-10-19 21:54:03 +03:00
|
|
|
|
if 'vector_norm' in self.doc.user_token_hooks:
|
|
|
|
|
return self.doc.user_token_hooks['vector_norm'](self)
|
2017-10-10 05:15:14 +03:00
|
|
|
|
vector = self.vector
|
2017-05-28 12:46:10 +03:00
|
|
|
|
return numpy.sqrt((vector ** 2).sum())
|
2015-09-14 10:49:58 +03:00
|
|
|
|
|
2015-07-13 20:20:48 +03:00
|
|
|
|
property n_lefts:
|
|
|
|
|
def __get__(self):
|
2016-03-21 18:10:25 +03:00
|
|
|
|
return self.c.l_kids
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
|
|
|
|
property n_rights:
|
|
|
|
|
def __get__(self):
|
2016-03-21 18:10:25 +03:00
|
|
|
|
return self.c.r_kids
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
2016-05-05 12:53:20 +03:00
|
|
|
|
property sent_start:
|
|
|
|
|
def __get__(self):
|
|
|
|
|
return self.c.sent_start
|
|
|
|
|
|
2017-10-09 00:51:58 +03:00
|
|
|
|
def __set__(self, value):
|
2016-05-05 12:53:20 +03:00
|
|
|
|
if self.doc.is_parsed:
|
|
|
|
|
raise ValueError(
|
|
|
|
|
'Refusing to write to token.sent_start if its document is parsed, '
|
|
|
|
|
'because this may cause inconsistent state. '
|
|
|
|
|
'See https://github.com/spacy-io/spaCy/issues/235 for workarounds.')
|
2017-10-09 00:51:58 +03:00
|
|
|
|
if value is None:
|
|
|
|
|
self.c.sent_start = 0
|
|
|
|
|
elif value is True:
|
|
|
|
|
self.c.sent_start = 1
|
|
|
|
|
elif value is False:
|
|
|
|
|
self.c.sent_start = -1
|
|
|
|
|
else:
|
|
|
|
|
raise ValueError("Invalid value for token.sent_start -- must be one of "
|
|
|
|
|
"None, True, False")
|
2016-05-05 12:53:20 +03:00
|
|
|
|
|
2015-07-13 20:20:48 +03:00
|
|
|
|
property lefts:
|
|
|
|
|
def __get__(self):
|
2017-04-15 14:05:15 +03:00
|
|
|
|
"""
|
|
|
|
|
The leftward immediate children of the word, in the syntactic
|
2015-07-13 20:20:48 +03:00
|
|
|
|
dependency parse.
|
|
|
|
|
"""
|
2016-01-16 18:18:17 +03:00
|
|
|
|
cdef int nr_iter = 0
|
2015-09-06 11:48:36 +03:00
|
|
|
|
cdef const TokenC* ptr = self.c - (self.i - self.c.l_edge)
|
2015-07-13 20:20:48 +03:00
|
|
|
|
while ptr < self.c:
|
2016-03-01 12:09:08 +03:00
|
|
|
|
if ptr + ptr.head == self.c:
|
2015-07-14 01:10:11 +03:00
|
|
|
|
yield self.doc[ptr - (self.c - self.i)]
|
2016-03-01 12:09:08 +03:00
|
|
|
|
ptr += 1
|
2016-01-16 18:18:17 +03:00
|
|
|
|
nr_iter += 1
|
|
|
|
|
# This is ugly, but it's a way to guard out infinite loops
|
|
|
|
|
if nr_iter >= 10000000:
|
|
|
|
|
raise RuntimeError(
|
|
|
|
|
"Possibly infinite loop encountered while looking for token.lefts")
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
|
|
|
|
property rights:
|
|
|
|
|
def __get__(self):
|
2017-04-15 14:05:15 +03:00
|
|
|
|
"""
|
|
|
|
|
The rightward immediate children of the word, in the syntactic
|
|
|
|
|
dependency parse.
|
|
|
|
|
"""
|
2015-09-06 11:48:36 +03:00
|
|
|
|
cdef const TokenC* ptr = self.c + (self.c.r_edge - self.i)
|
2015-07-13 20:20:48 +03:00
|
|
|
|
tokens = []
|
2016-01-16 18:18:17 +03:00
|
|
|
|
cdef int nr_iter = 0
|
2015-07-13 20:20:48 +03:00
|
|
|
|
while ptr > self.c:
|
2016-03-01 12:09:08 +03:00
|
|
|
|
if ptr + ptr.head == self.c:
|
2015-07-14 01:10:11 +03:00
|
|
|
|
tokens.append(self.doc[ptr - (self.c - self.i)])
|
2016-03-01 12:09:08 +03:00
|
|
|
|
ptr -= 1
|
|
|
|
|
nr_iter += 1
|
2016-01-16 18:18:17 +03:00
|
|
|
|
if nr_iter >= 10000000:
|
|
|
|
|
raise RuntimeError(
|
|
|
|
|
"Possibly infinite loop encountered while looking for token.rights")
|
2015-07-13 20:20:48 +03:00
|
|
|
|
tokens.reverse()
|
|
|
|
|
for t in tokens:
|
|
|
|
|
yield t
|
|
|
|
|
|
|
|
|
|
property children:
|
2017-04-15 14:05:15 +03:00
|
|
|
|
"""
|
|
|
|
|
A sequence of the token's immediate syntactic children.
|
2016-11-01 14:25:36 +03:00
|
|
|
|
|
|
|
|
|
Yields: Token A child token such that child.head==self
|
2017-04-15 14:05:15 +03:00
|
|
|
|
"""
|
2015-07-13 20:20:48 +03:00
|
|
|
|
def __get__(self):
|
|
|
|
|
yield from self.lefts
|
|
|
|
|
yield from self.rights
|
|
|
|
|
|
|
|
|
|
property subtree:
|
2017-04-15 14:05:15 +03:00
|
|
|
|
"""
|
|
|
|
|
A sequence of all the token's syntactic descendents.
|
2016-11-01 14:25:36 +03:00
|
|
|
|
|
|
|
|
|
Yields: Token A descendent token such that self.is_ancestor(descendent)
|
2017-04-15 14:05:15 +03:00
|
|
|
|
"""
|
2015-07-13 20:20:48 +03:00
|
|
|
|
def __get__(self):
|
|
|
|
|
for word in self.lefts:
|
|
|
|
|
yield from word.subtree
|
|
|
|
|
yield self
|
|
|
|
|
for word in self.rights:
|
|
|
|
|
yield from word.subtree
|
|
|
|
|
|
|
|
|
|
property left_edge:
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""The leftmost token of this token's syntactic descendents.
|
2016-11-01 14:25:36 +03:00
|
|
|
|
|
2017-05-19 19:47:56 +03:00
|
|
|
|
RETURNS (Token): The first token such that `self.is_ancestor(token)`.
|
2017-04-15 14:05:15 +03:00
|
|
|
|
"""
|
2015-07-13 20:20:48 +03:00
|
|
|
|
def __get__(self):
|
2015-07-14 01:10:11 +03:00
|
|
|
|
return self.doc[self.c.l_edge]
|
2015-08-09 00:37:44 +03:00
|
|
|
|
|
2015-07-13 20:20:48 +03:00
|
|
|
|
property right_edge:
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""The rightmost token of this token's syntactic descendents.
|
2016-11-01 14:25:36 +03:00
|
|
|
|
|
2017-05-19 19:47:56 +03:00
|
|
|
|
RETURNS (Token): The last token such that `self.is_ancestor(token)`.
|
2017-04-15 14:05:15 +03:00
|
|
|
|
"""
|
2015-07-13 20:20:48 +03:00
|
|
|
|
def __get__(self):
|
2015-07-14 01:10:11 +03:00
|
|
|
|
return self.doc[self.c.r_edge]
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
2016-03-11 19:31:06 +03:00
|
|
|
|
property ancestors:
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""A sequence of this token's syntactic ancestors.
|
2016-11-01 14:25:36 +03:00
|
|
|
|
|
2017-05-19 19:47:56 +03:00
|
|
|
|
YIELDS (Token): A sequence of ancestor tokens such that
|
|
|
|
|
`ancestor.is_ancestor(self)`.
|
2017-04-15 14:05:15 +03:00
|
|
|
|
"""
|
2016-03-11 19:31:06 +03:00
|
|
|
|
def __get__(self):
|
|
|
|
|
cdef const TokenC* head_ptr = self.c
|
2017-02-27 00:27:11 +03:00
|
|
|
|
# guard against infinite loop, no token can have
|
2016-03-11 19:31:06 +03:00
|
|
|
|
# more ancestors than tokens in the tree
|
|
|
|
|
cdef int i = 0
|
|
|
|
|
while head_ptr.head != 0 and i < self.doc.length:
|
|
|
|
|
head_ptr += head_ptr.head
|
|
|
|
|
yield self.doc[head_ptr - (self.c - self.i)]
|
|
|
|
|
i += 1
|
|
|
|
|
|
2016-11-01 14:25:36 +03:00
|
|
|
|
def is_ancestor(self, descendant):
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""Check whether this token is a parent, grandparent, etc. of another
|
2016-11-01 14:25:36 +03:00
|
|
|
|
in the dependency tree.
|
|
|
|
|
|
2017-05-19 19:47:56 +03:00
|
|
|
|
descendant (Token): Another token.
|
|
|
|
|
RETURNS (bool): Whether this token is the ancestor of the descendant.
|
2017-04-15 14:05:15 +03:00
|
|
|
|
"""
|
2016-11-01 15:28:00 +03:00
|
|
|
|
if self.doc is not descendant.doc:
|
2016-11-01 14:25:36 +03:00
|
|
|
|
return False
|
2016-03-11 19:31:06 +03:00
|
|
|
|
return any( ancestor.i == self.i for ancestor in descendant.ancestors )
|
|
|
|
|
|
2015-07-13 20:20:48 +03:00
|
|
|
|
property head:
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""The syntactic parent, or "governor", of this token.
|
2017-02-27 00:27:11 +03:00
|
|
|
|
|
2017-05-19 19:47:56 +03:00
|
|
|
|
RETURNS (Token): The token head.
|
2017-04-15 14:05:15 +03:00
|
|
|
|
"""
|
2015-07-13 20:20:48 +03:00
|
|
|
|
def __get__(self):
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""The token predicted by the parser to be the head of the current
|
|
|
|
|
token.
|
2017-04-15 14:05:15 +03:00
|
|
|
|
"""
|
2015-07-14 01:10:11 +03:00
|
|
|
|
return self.doc[self.i + self.c.head]
|
2016-03-11 19:31:06 +03:00
|
|
|
|
def __set__(self, Token new_head):
|
|
|
|
|
# this function sets the head of self to new_head
|
|
|
|
|
# and updates the counters for left/right dependents
|
|
|
|
|
# and left/right corner for the new and the old head
|
|
|
|
|
|
|
|
|
|
# do nothing if old head is new head
|
|
|
|
|
if self.i + self.c.head == new_head.i:
|
|
|
|
|
return
|
|
|
|
|
|
|
|
|
|
cdef Token old_head = self.head
|
|
|
|
|
cdef int rel_newhead_i = new_head.i - self.i
|
|
|
|
|
|
|
|
|
|
# is the new head a descendant of the old head
|
2017-05-19 21:23:40 +03:00
|
|
|
|
cdef bint is_desc = old_head.is_ancestor(new_head)
|
2017-02-27 00:27:11 +03:00
|
|
|
|
|
2016-03-11 19:31:06 +03:00
|
|
|
|
cdef int new_edge
|
2016-03-14 15:43:48 +03:00
|
|
|
|
cdef Token anc, child
|
2016-03-11 19:31:06 +03:00
|
|
|
|
|
|
|
|
|
# update number of deps of old head
|
|
|
|
|
if self.c.head > 0: # left dependent
|
|
|
|
|
old_head.c.l_kids -= 1
|
|
|
|
|
if self.c.l_edge == old_head.c.l_edge:
|
|
|
|
|
# the token dominates the left edge so the left edge of the head
|
|
|
|
|
# may change when the token is reattached
|
|
|
|
|
# it may not change if the new head is a descendant of the current head
|
|
|
|
|
|
|
|
|
|
new_edge = self.c.l_edge
|
2016-03-14 15:43:48 +03:00
|
|
|
|
# the new l_edge is the left-most l_edge on any of the other dependents
|
|
|
|
|
# where the l_edge is left of the head, otherwise it is the head
|
2016-03-11 19:31:06 +03:00
|
|
|
|
if not is_desc:
|
2016-03-14 15:43:48 +03:00
|
|
|
|
new_edge = old_head.i
|
|
|
|
|
for child in old_head.children:
|
|
|
|
|
if child == self:
|
|
|
|
|
continue
|
|
|
|
|
if child.c.l_edge < new_edge:
|
|
|
|
|
new_edge = child.c.l_edge
|
|
|
|
|
old_head.c.l_edge = new_edge
|
|
|
|
|
|
2016-03-11 19:31:06 +03:00
|
|
|
|
# walk up the tree from old_head and assign new l_edge to ancestors
|
|
|
|
|
# until an ancestor already has an l_edge that's further left
|
|
|
|
|
for anc in old_head.ancestors:
|
|
|
|
|
if anc.c.l_edge <= new_edge:
|
|
|
|
|
break
|
|
|
|
|
anc.c.l_edge = new_edge
|
2017-02-27 00:27:11 +03:00
|
|
|
|
|
2016-03-11 19:31:06 +03:00
|
|
|
|
elif self.c.head < 0: # right dependent
|
|
|
|
|
old_head.c.r_kids -= 1
|
|
|
|
|
# do the same thing as for l_edge
|
|
|
|
|
if self.c.r_edge == old_head.c.r_edge:
|
|
|
|
|
new_edge = self.c.r_edge
|
2016-03-14 15:43:48 +03:00
|
|
|
|
|
2016-03-11 19:31:06 +03:00
|
|
|
|
if not is_desc:
|
2016-03-14 15:43:48 +03:00
|
|
|
|
new_edge = old_head.i
|
|
|
|
|
for child in old_head.children:
|
|
|
|
|
if child == self:
|
|
|
|
|
continue
|
|
|
|
|
if child.c.r_edge > new_edge:
|
|
|
|
|
new_edge = child.c.r_edge
|
|
|
|
|
old_head.c.r_edge = new_edge
|
2017-02-27 00:27:11 +03:00
|
|
|
|
|
2016-03-11 19:31:06 +03:00
|
|
|
|
for anc in old_head.ancestors:
|
|
|
|
|
if anc.c.r_edge >= new_edge:
|
|
|
|
|
break
|
|
|
|
|
anc.c.r_edge = new_edge
|
|
|
|
|
|
|
|
|
|
# update number of deps of new head
|
|
|
|
|
if rel_newhead_i > 0: # left dependent
|
|
|
|
|
new_head.c.l_kids += 1
|
|
|
|
|
# walk up the tree from new head and set l_edge to self.l_edge
|
|
|
|
|
# until you hit a token with an l_edge further to the left
|
|
|
|
|
if self.c.l_edge < new_head.c.l_edge:
|
2016-03-14 15:43:48 +03:00
|
|
|
|
new_head.c.l_edge = self.c.l_edge
|
2016-03-11 19:31:06 +03:00
|
|
|
|
for anc in new_head.ancestors:
|
2016-03-14 15:43:48 +03:00
|
|
|
|
if anc.c.l_edge <= self.c.l_edge:
|
2016-03-11 19:31:06 +03:00
|
|
|
|
break
|
2016-03-14 15:43:48 +03:00
|
|
|
|
anc.c.l_edge = self.c.l_edge
|
2016-03-11 19:31:06 +03:00
|
|
|
|
|
|
|
|
|
elif rel_newhead_i < 0: # right dependent
|
|
|
|
|
new_head.c.r_kids += 1
|
|
|
|
|
# do the same as for l_edge
|
|
|
|
|
if self.c.r_edge > new_head.c.r_edge:
|
2016-03-14 15:43:48 +03:00
|
|
|
|
new_head.c.r_edge = self.c.r_edge
|
2016-03-11 19:31:06 +03:00
|
|
|
|
for anc in new_head.ancestors:
|
2016-03-14 15:43:48 +03:00
|
|
|
|
if anc.c.r_edge >= self.c.r_edge:
|
2016-03-11 19:31:06 +03:00
|
|
|
|
break
|
2016-03-14 15:43:48 +03:00
|
|
|
|
anc.c.r_edge = self.c.r_edge
|
2016-03-11 19:31:06 +03:00
|
|
|
|
|
|
|
|
|
# set new head
|
|
|
|
|
self.c.head = rel_newhead_i
|
2015-08-09 00:37:44 +03:00
|
|
|
|
|
2015-07-13 20:20:48 +03:00
|
|
|
|
property conjuncts:
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""A sequence of coordinated tokens, including the token itself.
|
2016-11-01 14:25:36 +03:00
|
|
|
|
|
2017-05-19 19:47:56 +03:00
|
|
|
|
YIELDS (Token): A coordinated token.
|
2017-04-15 14:05:15 +03:00
|
|
|
|
"""
|
2015-07-13 20:20:48 +03:00
|
|
|
|
def __get__(self):
|
2015-10-14 19:34:57 +03:00
|
|
|
|
"""Get a list of conjoined words."""
|
2015-07-13 20:20:48 +03:00
|
|
|
|
cdef Token word
|
2016-10-19 21:54:03 +03:00
|
|
|
|
if 'conjuncts' in self.doc.user_token_hooks:
|
|
|
|
|
yield from self.doc.user_token_hooks['conjuncts'](self)
|
2016-10-17 03:44:49 +03:00
|
|
|
|
else:
|
|
|
|
|
if self.dep_ != 'conj':
|
|
|
|
|
for word in self.rights:
|
|
|
|
|
if word.dep_ == 'conj':
|
|
|
|
|
yield word
|
|
|
|
|
yield from word.conjuncts
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
|
|
|
|
property ent_type:
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""Named entity type.
|
|
|
|
|
|
2017-05-28 16:10:22 +03:00
|
|
|
|
RETURNS (uint64): Named entity type.
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""
|
2015-07-13 20:20:48 +03:00
|
|
|
|
def __get__(self):
|
|
|
|
|
return self.c.ent_type
|
2017-05-28 16:10:22 +03:00
|
|
|
|
def __set__(self, ent_type):
|
|
|
|
|
self.c.ent_type = ent_type
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
|
|
|
|
property ent_iob:
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""IOB code of named entity tag. `1="I", 2="O", 3="B"`. 0 means no tag
|
|
|
|
|
is assigned.
|
|
|
|
|
|
2017-05-28 16:10:22 +03:00
|
|
|
|
RETURNS (uint64): IOB code of named entity tag.
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""
|
2015-07-13 20:20:48 +03:00
|
|
|
|
def __get__(self):
|
|
|
|
|
return self.c.ent_iob
|
|
|
|
|
|
|
|
|
|
property ent_type_:
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""Named entity type.
|
|
|
|
|
|
|
|
|
|
RETURNS (unicode): Named entity type.
|
|
|
|
|
"""
|
2015-07-13 20:20:48 +03:00
|
|
|
|
def __get__(self):
|
2016-09-30 21:20:22 +03:00
|
|
|
|
return self.vocab.strings[self.c.ent_type]
|
2017-05-28 16:10:22 +03:00
|
|
|
|
def __set__(self, ent_type):
|
|
|
|
|
self.c.ent_type = self.vocab.strings.add(ent_type)
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
|
|
|
|
property ent_iob_:
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""IOB code of named entity tag. "B" means the token begins an entity,
|
|
|
|
|
"I" means it is inside an entity, "O" means it is outside an entity, and
|
|
|
|
|
"" means no entity tag is set.
|
|
|
|
|
|
|
|
|
|
RETURNS (unicode): IOB code of named entity tag.
|
|
|
|
|
"""
|
2015-07-13 20:20:48 +03:00
|
|
|
|
def __get__(self):
|
|
|
|
|
iob_strings = ('', 'I', 'O', 'B')
|
|
|
|
|
return iob_strings[self.c.ent_iob]
|
|
|
|
|
|
2016-09-21 15:54:55 +03:00
|
|
|
|
property ent_id:
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""ID of the entity the token is an instance of, if any. Usually
|
|
|
|
|
assigned by patterns in the Matcher.
|
|
|
|
|
|
2017-05-28 16:10:22 +03:00
|
|
|
|
RETURNS (uint64): ID of the entity.
|
2017-04-15 14:05:15 +03:00
|
|
|
|
"""
|
2016-09-21 15:54:55 +03:00
|
|
|
|
def __get__(self):
|
2016-09-23 16:07:07 +03:00
|
|
|
|
return self.c.ent_id
|
2016-09-21 15:54:55 +03:00
|
|
|
|
|
|
|
|
|
def __set__(self, hash_t key):
|
2017-03-31 15:00:14 +03:00
|
|
|
|
self.c.ent_id = key
|
2016-09-21 15:54:55 +03:00
|
|
|
|
|
|
|
|
|
property ent_id_:
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""ID of the entity the token is an instance of, if any. Usually
|
|
|
|
|
assigned by patterns in the Matcher.
|
|
|
|
|
|
|
|
|
|
RETURNS (unicode): ID of the entity.
|
2017-04-15 14:05:15 +03:00
|
|
|
|
"""
|
2016-09-21 15:54:55 +03:00
|
|
|
|
def __get__(self):
|
2016-09-30 21:20:22 +03:00
|
|
|
|
return self.vocab.strings[self.c.ent_id]
|
2016-09-21 15:54:55 +03:00
|
|
|
|
|
2017-03-31 15:00:14 +03:00
|
|
|
|
def __set__(self, name):
|
2017-05-28 16:10:22 +03:00
|
|
|
|
self.c.ent_id = self.vocab.strings.add(name)
|
2016-09-21 15:54:55 +03:00
|
|
|
|
|
2015-07-13 20:20:48 +03:00
|
|
|
|
property whitespace_:
|
|
|
|
|
def __get__(self):
|
2015-10-18 09:21:11 +03:00
|
|
|
|
return ' ' if self.c.spacy else ''
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
|
|
|
|
property orth_:
|
|
|
|
|
def __get__(self):
|
2016-09-30 21:20:22 +03:00
|
|
|
|
return self.vocab.strings[self.c.lex.orth]
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
|
|
|
|
property lower_:
|
|
|
|
|
def __get__(self):
|
2016-09-30 21:20:22 +03:00
|
|
|
|
return self.vocab.strings[self.c.lex.lower]
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
|
|
|
|
property norm_:
|
|
|
|
|
def __get__(self):
|
2016-09-30 21:20:22 +03:00
|
|
|
|
return self.vocab.strings[self.c.lex.norm]
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
|
|
|
|
property shape_:
|
|
|
|
|
def __get__(self):
|
2016-09-30 21:20:22 +03:00
|
|
|
|
return self.vocab.strings[self.c.lex.shape]
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
|
|
|
|
property prefix_:
|
|
|
|
|
def __get__(self):
|
2016-09-30 21:20:22 +03:00
|
|
|
|
return self.vocab.strings[self.c.lex.prefix]
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
|
|
|
|
property suffix_:
|
|
|
|
|
def __get__(self):
|
2016-09-30 21:20:22 +03:00
|
|
|
|
return self.vocab.strings[self.c.lex.suffix]
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
2016-03-10 15:01:34 +03:00
|
|
|
|
property lang_:
|
|
|
|
|
def __get__(self):
|
2016-09-30 21:20:22 +03:00
|
|
|
|
return self.vocab.strings[self.c.lex.lang]
|
2016-03-10 15:01:34 +03:00
|
|
|
|
|
2015-07-13 20:20:48 +03:00
|
|
|
|
property lemma_:
|
2017-05-19 19:47:56 +03:00
|
|
|
|
"""Base form of the word, with no inflectional suffixes.
|
|
|
|
|
|
|
|
|
|
RETURNS (unicode): Token lemma.
|
|
|
|
|
"""
|
2015-07-13 20:20:48 +03:00
|
|
|
|
def __get__(self):
|
2016-09-30 21:20:22 +03:00
|
|
|
|
return self.vocab.strings[self.c.lemma]
|
2017-04-16 19:07:53 +03:00
|
|
|
|
def __set__(self, unicode lemma_):
|
2017-05-28 16:10:22 +03:00
|
|
|
|
self.c.lemma = self.vocab.strings.add(lemma_)
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
|
|
|
|
property pos_:
|
|
|
|
|
def __get__(self):
|
2015-10-10 09:55:55 +03:00
|
|
|
|
return parts_of_speech.NAMES[self.c.pos]
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
|
|
|
|
property tag_:
|
|
|
|
|
def __get__(self):
|
2016-09-30 21:20:22 +03:00
|
|
|
|
return self.vocab.strings[self.c.tag]
|
2016-11-03 01:28:59 +03:00
|
|
|
|
def __set__(self, tag):
|
2017-05-28 16:10:22 +03:00
|
|
|
|
self.tag = self.vocab.strings.add(tag)
|
2015-07-13 20:20:48 +03:00
|
|
|
|
|
|
|
|
|
property dep_:
|
|
|
|
|
def __get__(self):
|
2016-09-30 21:20:22 +03:00
|
|
|
|
return self.vocab.strings[self.c.dep]
|
2016-03-11 19:31:06 +03:00
|
|
|
|
def __set__(self, unicode label):
|
2017-05-28 16:10:22 +03:00
|
|
|
|
self.c.dep = self.vocab.strings.add(label)
|
2015-07-13 21:20:58 +03:00
|
|
|
|
|
2015-07-27 02:50:06 +03:00
|
|
|
|
property is_oov:
|
2015-09-15 06:06:18 +03:00
|
|
|
|
def __get__(self): return Lexeme.c_check_flag(self.c.lex, IS_OOV)
|
2015-07-27 02:50:06 +03:00
|
|
|
|
|
2015-09-14 10:49:58 +03:00
|
|
|
|
property is_stop:
|
2015-09-15 06:06:18 +03:00
|
|
|
|
def __get__(self): return Lexeme.c_check_flag(self.c.lex, IS_STOP)
|
2015-09-14 10:49:58 +03:00
|
|
|
|
|
2015-07-26 17:37:16 +03:00
|
|
|
|
property is_alpha:
|
2015-09-15 06:06:18 +03:00
|
|
|
|
def __get__(self): return Lexeme.c_check_flag(self.c.lex, IS_ALPHA)
|
2015-08-09 00:37:44 +03:00
|
|
|
|
|
2015-07-26 17:37:16 +03:00
|
|
|
|
property is_ascii:
|
2015-09-15 06:06:18 +03:00
|
|
|
|
def __get__(self): return Lexeme.c_check_flag(self.c.lex, IS_ASCII)
|
2015-07-26 17:37:16 +03:00
|
|
|
|
|
|
|
|
|
property is_digit:
|
2015-09-15 06:06:18 +03:00
|
|
|
|
def __get__(self): return Lexeme.c_check_flag(self.c.lex, IS_DIGIT)
|
2015-07-26 17:37:16 +03:00
|
|
|
|
|
|
|
|
|
property is_lower:
|
2015-09-15 06:06:18 +03:00
|
|
|
|
def __get__(self): return Lexeme.c_check_flag(self.c.lex, IS_LOWER)
|
2015-07-26 17:37:16 +03:00
|
|
|
|
|
|
|
|
|
property is_title:
|
2015-09-15 06:06:18 +03:00
|
|
|
|
def __get__(self): return Lexeme.c_check_flag(self.c.lex, IS_TITLE)
|
2015-07-26 17:37:16 +03:00
|
|
|
|
|
|
|
|
|
property is_punct:
|
2015-09-15 06:06:18 +03:00
|
|
|
|
def __get__(self): return Lexeme.c_check_flag(self.c.lex, IS_PUNCT)
|
2015-07-26 17:37:16 +03:00
|
|
|
|
|
2017-02-27 00:27:11 +03:00
|
|
|
|
property is_space:
|
2015-09-15 06:06:18 +03:00
|
|
|
|
def __get__(self): return Lexeme.c_check_flag(self.c.lex, IS_SPACE)
|
2017-02-27 00:27:11 +03:00
|
|
|
|
|
|
|
|
|
property is_bracket:
|
2016-02-04 15:04:16 +03:00
|
|
|
|
def __get__(self): return Lexeme.c_check_flag(self.c.lex, IS_BRACKET)
|
|
|
|
|
|
2017-02-27 00:27:11 +03:00
|
|
|
|
property is_quote:
|
2016-02-04 15:04:16 +03:00
|
|
|
|
def __get__(self): return Lexeme.c_check_flag(self.c.lex, IS_QUOTE)
|
|
|
|
|
|
2017-02-27 00:27:11 +03:00
|
|
|
|
property is_left_punct:
|
2016-02-04 15:04:16 +03:00
|
|
|
|
def __get__(self): return Lexeme.c_check_flag(self.c.lex, IS_LEFT_PUNCT)
|
|
|
|
|
|
2017-02-27 00:27:11 +03:00
|
|
|
|
property is_right_punct:
|
2016-02-04 15:04:16 +03:00
|
|
|
|
def __get__(self): return Lexeme.c_check_flag(self.c.lex, IS_RIGHT_PUNCT)
|
2015-07-26 17:37:16 +03:00
|
|
|
|
|
|
|
|
|
property like_url:
|
2015-09-15 06:06:18 +03:00
|
|
|
|
def __get__(self): return Lexeme.c_check_flag(self.c.lex, LIKE_URL)
|
2015-08-09 00:37:44 +03:00
|
|
|
|
|
2015-07-26 17:37:16 +03:00
|
|
|
|
property like_num:
|
2015-09-15 06:06:18 +03:00
|
|
|
|
def __get__(self): return Lexeme.c_check_flag(self.c.lex, LIKE_NUM)
|
2015-07-26 17:37:16 +03:00
|
|
|
|
|
|
|
|
|
property like_email:
|
2015-09-15 06:06:18 +03:00
|
|
|
|
def __get__(self): return Lexeme.c_check_flag(self.c.lex, LIKE_EMAIL)
|