ó
ù`]c           @   s   d  d l  m Z d  d l m Z m Z d „  Z d „  Z d „  Z d e f d „  ƒ  YZ	 d „  Z
 d	 „  Z d
 „  Z d „  Z d S(   iÿÿÿÿ(   t   finditer(   t   escapet   unescapec         c   s³   t  | ƒ d k r! t d ƒ ‚ n  d } x… t r® y0 |  j | | ƒ } | d k r_ | | f Vn  Wn8 t k
 rš | t  |  ƒ k r– | t  |  ƒ f Vn  Pn X| t  | ƒ } q* Wd S(   sŽ  
    Return the offsets of the tokens in *s*, as a sequence of ``(start, end)``
    tuples, by splitting the string at each occurrence of *sep*.

        >>> from nltk.tokenize.util import string_span_tokenize
        >>> s = '''Good muffins cost $3.88\nin New York.  Please buy me
        ... two of them.\n\nThanks.'''
        >>> list(string_span_tokenize(s, " "))
        [(0, 4), (5, 12), (13, 17), (18, 26), (27, 30), (31, 36), (37, 37),
        (38, 44), (45, 48), (49, 55), (56, 58), (59, 73)]

    :param s: the string to be tokenized
    :type s: str
    :param sep: the token separator
    :type sep: str
    :rtype: iter(tuple(int, int))
    i    s!   Token delimiter must not be emptyN(   t   lent
   ValueErrort   Truet   index(   t   st   sept   leftt   right(    (    s1   lib/python2.7/site-packages/nltk/tokenize/util.pyt   string_span_tokenize   s    	c         c   sg   d } xI t  | |  ƒ D]8 } | j ƒ  \ } } | | k rH | | f Vn  | } q W| t |  ƒ f Vd S(   sä  
    Return the offsets of the tokens in *s*, as a sequence of ``(start, end)``
    tuples, by splitting the string at each successive match of *regexp*.

        >>> from nltk.tokenize.util import regexp_span_tokenize
        >>> s = '''Good muffins cost $3.88\nin New York.  Please buy me
        ... two of them.\n\nThanks.'''
        >>> list(regexp_span_tokenize(s, r'\s'))
        [(0, 4), (5, 12), (13, 17), (18, 23), (24, 26), (27, 30), (31, 36),
        (38, 44), (45, 48), (49, 51), (52, 55), (56, 58), (59, 64), (66, 73)]

    :param s: the string to be tokenized
    :type s: str
    :param regexp: regular expression that matches token separators (must not be empty)
    :type regexp: str
    :rtype: iter(tuple(int, int))
    i    N(   R    t   spanR   (   R   t   regexpR	   t   mR
   t   next(    (    s1   lib/python2.7/site-packages/nltk/tokenize/util.pyt   regexp_span_tokenize/   s    
c         c   s:   d } x- |  D]% \ } } | | | | f V| } q Wd S(   sŠ  
    Return a sequence of relative spans, given a sequence of spans.

        >>> from nltk.tokenize import WhitespaceTokenizer
        >>> from nltk.tokenize.util import spans_to_relative
        >>> s = '''Good muffins cost $3.88\nin New York.  Please buy me
        ... two of them.\n\nThanks.'''
        >>> list(spans_to_relative(WhitespaceTokenizer().span_tokenize(s)))
        [(0, 4), (1, 7), (1, 4), (1, 5), (1, 2), (1, 3), (1, 5), (2, 6),
        (1, 3), (1, 2), (1, 3), (1, 2), (1, 5), (2, 7)]

    :param spans: a sequence of (start, end) offsets of the tokens
    :type spans: iter(tuple(int, int))
    :rtype: iter(tuple(int, int))
    i    N(    (   t   spanst   prevR	   R
   (    (    s1   lib/python2.7/site-packages/nltk/tokenize/util.pyt   spans_to_relativeJ   s    t   CJKCharsc           B   s\   e  Z d  Z d Z d Z d Z d Z d Z d Z d Z	 d Z
 e e e e e e e	 e
 g Z RS(   s]  
    An object that enumerates the code points of the CJK characters as listed on
    http://en.wikipedia.org/wiki/Basic_Multilingual_Plane#Basic_Multilingual_Plane

    This is a Python port of the CJK code point enumerations of Moses tokenizer:
    https://github.com/moses-smt/mosesdecoder/blob/master/scripts/tokenizer/detokenizer.perl#L309
    i   iÿ  i€.  iÏ¤  i@¨  i¨  i ¬  i¯×  i ù  iÿú  i0þ  iOþ  ieÿ  iÜÿ  i   iÿÿ (   i   iÿ  (   i€.  iÏ¤  (   i@¨  i¨  (   i ¬  i¯×  (   i ù  iÿú  (   i0þ  iOþ  (   ieÿ  iÜÿ  (   i   iÿÿ (   t   __name__t
   __module__t   __doc__t   Hangul_Jamot   CJK_Radicalst   Phags_Pat   Hangul_Syllablest   CJK_Compatibility_Ideographst   CJK_Compatibility_Formst   Katakana_Hangul_Halfwidtht   Supplementary_Ideographic_Planet   ranges(    (    (    s1   lib/python2.7/site-packages/nltk/tokenize/util.pyR   `   s$    c         C   sW   t  g  d d d d d d d d g D]. \ } } | t |  ƒ k oK | k n ^ q" ƒ S(   s’  
    Python port of Moses' code to check for CJK character.

    >>> CJKChars().ranges
    [(4352, 4607), (11904, 42191), (43072, 43135), (44032, 55215), (63744, 64255), (65072, 65103), (65381, 65500), (131072, 196607)]
    >>> is_cjk(u'\u33fe')
    True
    >>> is_cjk(u'\uFE5F')
    False

    :param character: The character that needs to be checked.
    :type character: char
    :return: bool
    i   iÿ  i€.  iÏ¤  i@¨  i¨  i ¬  i¯×  i ù  iÿú  i0þ  iOþ  ieÿ  iÜÿ  i   iÿÿ (   i   iÿ  (   i€.  iÏ¤  (   i@¨  i¨  (   i ¬  i¯×  (   i ù  iÿú  (   i0þ  iOþ  (   ieÿ  iÜÿ  (   i   iÿÿ (   t   anyt   ord(   t	   charactert   startt   end(    (    s1   lib/python2.7/site-packages/nltk/tokenize/util.pyt   is_cjk¢   s    c         C   s3   t  |  d i d d 6d d 6d d 6d d	 6d
 d 6ƒS(   sŒ  
    This function transforms the input text into an "escaped" version suitable
    for well-formed XML formatting.

    Note that the default xml.sax.saxutils.escape() function don't escape
    some characters that Moses does so we have to manually add them to the
    entities dictionary.

        >>> input_str = ''')| & < > ' " ] ['''
        >>> expected_output =  ''')| &amp; &lt; &gt; ' " ] ['''
        >>> escape(input_str) == expected_output
        True
        >>> xml_escape(input_str)
        ')&#124; &amp; &lt; &gt; &apos; &quot; &#93; &#91;'

    :param text: The text that needs to be escaped.
    :type text: str
    :rtype: str
    t   entitiess   &apos;t   's   &quot;t   "s   &#124;t   |s   &#91;t   [s   &#93;t   ](   R   (   t   text(    (    s1   lib/python2.7/site-packages/nltk/tokenize/util.pyt
   xml_escapeÂ   s    c         C   s3   t  |  d i d d 6d d 6d d 6d d	 6d
 d 6ƒS(   sj  
    This function transforms the "escaped" version suitable
    for well-formed XML formatting into humanly-readable string.

    Note that the default xml.sax.saxutils.unescape() function don't unescape
    some characters that Moses does so we have to manually add them to the
    entities dictionary.

        >>> from xml.sax.saxutils import unescape
        >>> s = ')&#124; &amp; &lt; &gt; &apos; &quot; &#93; &#91;'
        >>> expected = ''')| & < > ' " ] ['''
        >>> xml_unescape(s) == expected
        True

    :param text: The text that needs to be unescaped.
    :type text: str
    :rtype: str
    R'   R(   s   &apos;R)   s   &quot;R*   s   &#124;R+   s   &#91;R,   s   &#93;(   R   (   R-   (    (    s1   lib/python2.7/site-packages/nltk/tokenize/util.pyt   xml_unescapeâ   s    c         C   s†   d } g  } xs |  D]k } y | j  | | ƒ } Wn) t k
 rZ t d j | | ƒ ƒ ‚ n X| t | ƒ } | j | | f ƒ q W| S(   sÅ  
    This module attempt to find the offsets of the tokens in *s*, as a sequence
    of ``(start, end)`` tuples, given the tokens and also the source string.

        >>> from nltk.tokenize import TreebankWordTokenizer
        >>> from nltk.tokenize.util import align_tokens
        >>> s = str("The plane, bound for St Petersburg, crashed in Egypt's "
        ... "Sinai desert just 23 minutes after take-off from Sharm el-Sheikh "
        ... "on Saturday.")
        >>> tokens = TreebankWordTokenizer().tokenize(s)
        >>> expected = [(0, 3), (4, 9), (9, 10), (11, 16), (17, 20), (21, 23),
        ... (24, 34), (34, 35), (36, 43), (44, 46), (47, 52), (52, 54),
        ... (55, 60), (61, 67), (68, 72), (73, 75), (76, 83), (84, 89),
        ... (90, 98), (99, 103), (104, 109), (110, 119), (120, 122),
        ... (123, 131), (131, 132)]
        >>> output = list(align_tokens(tokens, s))
        >>> len(tokens) == len(expected) == len(output)  # Check that length of tokens and tuples are the same.
        True
        >>> expected == list(align_tokens(tokens, s))  # Check that the output is as expected.
        True
        >>> tokens == [s[start:end] for start, end in output]  # Check that the slices of the string corresponds to the tokens.
        True

    :param tokens: The list of strings that are the result of tokenization
    :type tokens: list(str)
    :param sentence: The original string
    :type sentence: str
    :rtype: list(tuple(int,int))
    i    s    substring "{}" not found in "{}"(   R   R   t   formatR   t   append(   t   tokenst   sentencet   pointt   offsetst   tokenR$   (    (    s1   lib/python2.7/site-packages/nltk/tokenize/util.pyt   align_tokens  s    N(   t   reR    t   xml.sax.saxutilsR   R   R   R   R   t   objectR   R&   R.   R/   R7   (    (    (    s1   lib/python2.7/site-packages/nltk/tokenize/util.pyt   <module>	   s   	"		B	 	 	