Add files using upload-large-folder tool

evalkit_eagle/lib/python3.10/site-packages/sacrebleu/tokenizers/__init__.py

@@ -0,0 +1,2 @@
+# Base tokenizer to derive from
+from .tokenizer_base import BaseTokenizer   # noqa: F401

evalkit_eagle/lib/python3.10/site-packages/sacrebleu/tokenizers/tokenizer_13a.py

@@ -0,0 +1,34 @@
+from functools import lru_cache
+from .tokenizer_base import BaseTokenizer
+from .tokenizer_re import TokenizerRegexp
+
+
+class Tokenizer13a(BaseTokenizer):
+
+    def signature(self):
+        return '13a'
+
+    def __init__(self):
+        self._post_tokenizer = TokenizerRegexp()
+
+    @lru_cache(maxsize=2**16)
+    def __call__(self, line):
+        """Tokenizes an input line using a relatively minimal tokenization
+        that is however equivalent to mteval-v13a, used by WMT.
+
+        :param line: a segment to tokenize
+        :return: the tokenized line
+        """
+
+        # language-independent part:
+        line = line.replace('<skipped>', '')
+        line = line.replace('-\n', '')
+        line = line.replace('\n', ' ')
+
+        if '&' in line:
+            line = line.replace('&quot;', '"')
+            line = line.replace('&amp;', '&')
+            line = line.replace('&lt;', '<')
+            line = line.replace('&gt;', '>')
+
+        return self._post_tokenizer(f' {line} ')

evalkit_eagle/lib/python3.10/site-packages/sacrebleu/tokenizers/tokenizer_base.py

@@ -0,0 +1,19 @@
+class BaseTokenizer:
+    """A base dummy tokenizer to derive from."""
+
+    def signature(self):
+        """
+        Returns a signature for the tokenizer.
+
+        :return: signature string
+        """
+        raise NotImplementedError()
+
+    def __call__(self, line):
+        """
+        Tokenizes an input line with the tokenizer.
+
+        :param line: a segment to tokenize
+        :return: the tokenized line
+        """
+        raise NotImplementedError()

evalkit_eagle/lib/python3.10/site-packages/sacrebleu/tokenizers/tokenizer_char.py

@@ -0,0 +1,19 @@
+from functools import lru_cache
+from .tokenizer_base import BaseTokenizer
+
+
+class TokenizerChar(BaseTokenizer):
+    def signature(self):
+        return 'char'
+
+    def __init__(self):
+        pass
+
+    @lru_cache(maxsize=2**16)
+    def __call__(self, line):
+        """Tokenizes all the characters in the input line.
+
+        :param line: a segment to tokenize
+        :return: the tokenized line
+        """
+        return " ".join((char for char in line))

evalkit_eagle/lib/python3.10/site-packages/sacrebleu/tokenizers/tokenizer_intl.py

@@ -0,0 +1,50 @@
+from functools import lru_cache
+
+import regex
+
+from .tokenizer_base import BaseTokenizer
+
+
+class TokenizerV14International(BaseTokenizer):
+    """Tokenizes a string following the official BLEU implementation.
+
+    See github.com/moses-smt/mosesdecoder/blob/master/scripts/generic/mteval-v14.pl#L954-L983
+
+    In our case, the input string is expected to be just one line.
+    We just tokenize on punctuation and symbols,
+    except when a punctuation is preceded and followed by a digit
+    (e.g. a comma/dot as a thousand/decimal separator).
+    We do not recover escaped forms of punctuations such as ' or >
+    as these should never appear in MT system outputs (see issue #138)
+
+    Note that a number (e.g., a year) followed by a dot at the end of
+    sentence is NOT tokenized, i.e. the dot stays with the number because
+    `s/(\\p{P})(\\P{N})/ $1 $2/g` does not match this case (unless we add a
+    space after each sentence). However, this error is already in the
+    original mteval-v14.pl and we want to be consistent with it.
+    The error is not present in the non-international version,
+    which uses `$norm_text = " $norm_text "`.
+
+    :param line: the input string to tokenize.
+    :return: The tokenized string.
+    """
+
+    def signature(self):
+        return 'intl'
+
+    def __init__(self):
+        self._re = [
+            # Separate out punctuations preceeded by a non-digit
+            (regex.compile(r'(\P{N})(\p{P})'), r'\1 \2 '),
+            # Separate out punctuations followed by a non-digit
+            (regex.compile(r'(\p{P})(\P{N})'), r' \1 \2'),
+            # Separate out symbols
+            (regex.compile(r'(\p{S})'), r' \1 '),
+        ]
+
+    @lru_cache(maxsize=2**16)
+    def __call__(self, line: str) -> str:
+        for (_re, repl) in self._re:
+            line = _re.sub(repl, line)
+
+        return ' '.join(line.split())

evalkit_eagle/lib/python3.10/site-packages/sacrebleu/tokenizers/tokenizer_ja_mecab.py

@@ -0,0 +1,52 @@
+from functools import lru_cache
+
+try:
+    import MeCab
+    import ipadic
+except ImportError:
+    # Don't fail until the tokenizer is actually used
+    MeCab = None
+
+from .tokenizer_base import BaseTokenizer
+
+FAIL_MESSAGE = """
+Japanese tokenization requires extra dependencies, but you do not have them installed.
+Please install them like so.
+
+    pip install sacrebleu[ja]
+"""
+
+
+class TokenizerJaMecab(BaseTokenizer):
+    def __init__(self):
+        if MeCab is None:
+            raise RuntimeError(FAIL_MESSAGE)
+        self.tagger = MeCab.Tagger(ipadic.MECAB_ARGS + " -Owakati")
+
+        # make sure the dictionary is IPA
+        d = self.tagger.dictionary_info()
+        assert d.size == 392126, \
+            "Please make sure to use the IPA dictionary for MeCab"
+        # This asserts that no user dictionary has been loaded
+        assert d.next is None
+
+    @lru_cache(maxsize=2**16)
+    def __call__(self, line):
+        """
+        Tokenizes an Japanese input line using MeCab morphological analyzer.
+
+        :param line: a segment to tokenize
+        :return: the tokenized line
+        """
+        line = line.strip()
+        sentence = self.tagger.parse(line).strip()
+        return sentence
+
+    def signature(self):
+        """
+        Returns the MeCab parameters.
+
+        :return: signature string
+        """
+        signature = self.tagger.version() + "-IPA"
+        return 'ja-mecab-' + signature

evalkit_eagle/lib/python3.10/site-packages/sacrebleu/tokenizers/tokenizer_ko_mecab.py

@@ -0,0 +1,52 @@
+from functools import lru_cache
+
+try:
+    import mecab_ko as MeCab
+    import mecab_ko_dic
+except ImportError:
+    # Don't fail until the tokenizer is actually used
+    MeCab = None
+
+from .tokenizer_base import BaseTokenizer
+
+FAIL_MESSAGE = """
+Korean tokenization requires extra dependencies, but you do not have them installed.
+Please install them like so.
+
+    pip install sacrebleu[ko]
+"""
+
+
+class TokenizerKoMecab(BaseTokenizer):
+    def __init__(self):
+        if MeCab is None:
+            raise RuntimeError(FAIL_MESSAGE)
+        self.tagger = MeCab.Tagger(mecab_ko_dic.MECAB_ARGS + " -Owakati")
+
+        # make sure the dictionary is mecab-ko-dic
+        d = self.tagger.dictionary_info()
+        assert d.size == 811795, \
+            "Please make sure to use the mecab-ko-dic for MeCab-ko"
+        # This asserts that no user dictionary has been loaded
+        assert d.next is None
+
+    @lru_cache(maxsize=2**16)
+    def __call__(self, line):
+        """
+        Tokenizes an Korean input line using MeCab-ko morphological analyzer.
+
+        :param line: a segment to tokenize
+        :return: the tokenized line
+        """
+        line = line.strip()
+        sentence = self.tagger.parse(line).strip()
+        return sentence
+
+    def signature(self):
+        """
+        Returns the MeCab-ko parameters.
+
+        :return: signature string
+        """
+        signature = self.tagger.version() + "-KO"
+        return 'ko-mecab-' + signature

evalkit_eagle/lib/python3.10/site-packages/sacrebleu/tokenizers/tokenizer_none.py

@@ -0,0 +1,10 @@
+from .tokenizer_base import BaseTokenizer
+
+class NoneTokenizer(BaseTokenizer):
+    """Don't apply any tokenization. Not recommended!."""
+
+    def signature(self):
+        return 'none'
+
+    def __call__(self, line):
+        return line

evalkit_eagle/lib/python3.10/site-packages/sacrebleu/tokenizers/tokenizer_re.py

@@ -0,0 +1,38 @@
+from functools import lru_cache
+import re
+
+from .tokenizer_base import BaseTokenizer
+
+
+class TokenizerRegexp(BaseTokenizer):
+
+    def signature(self):
+        return 're'
+
+    def __init__(self):
+        self._re = [
+            # language-dependent part (assuming Western languages)
+            (re.compile(r'([\{-\~\[-\` -\&\(-\+\:-\@\/])'), r' \1 '),
+            # tokenize period and comma unless preceded by a digit
+            (re.compile(r'([^0-9])([\.,])'), r'\1 \2 '),
+            # tokenize period and comma unless followed by a digit
+            (re.compile(r'([\.,])([^0-9])'), r' \1 \2'),
+            # tokenize dash when preceded by a digit
+            (re.compile(r'([0-9])(-)'), r'\1 \2 '),
+            # one space only between words
+            # NOTE: Doing this in Python (below) is faster
+            # (re.compile(r'\s+'), r' '),
+        ]
+
+    @lru_cache(maxsize=2**16)
+    def __call__(self, line):
+        """Common post-processing tokenizer for `13a` and `zh` tokenizers.
+
+        :param line: a segment to tokenize
+        :return: the tokenized line
+        """
+        for (_re, repl) in self._re:
+            line = _re.sub(repl, line)
+
+        # no leading or trailing spaces, single space within words
+        return ' '.join(line.split())

evalkit_eagle/lib/python3.10/site-packages/sacrebleu/tokenizers/tokenizer_spm.py

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+
+import os
+import logging
+
+from functools import lru_cache
+from ..utils import SACREBLEU_DIR, download_file
+from .tokenizer_base import BaseTokenizer
+
+sacrelogger = logging.getLogger('sacrebleu')
+
+
+SPM_MODELS = {
+    "spm": {
+        "url": "https://dl.fbaipublicfiles.com/fairseq/models/flores/sacrebleu_tokenizer_spm.model",
+        "signature": "flores101",
+    },
+    # same as the default of "spm"
+    "flores101": {
+        "url": "https://dl.fbaipublicfiles.com/fairseq/models/flores/sacrebleu_tokenizer_spm.model",
+        "signature": "flores101",
+    },
+    "flores200": {
+        "url": "https://tinyurl.com/flores200sacrebleuspm",
+        "signature": "flores200",
+    },
+}
+
+class TokenizerSPM(BaseTokenizer):
+    def signature(self):
+        return self.name
+
+    def __init__(self, key="spm"):
+        self.name = SPM_MODELS[key]["signature"]
+
+        if key == "spm":
+            sacrelogger.warn("Tokenizer 'spm' has been changed to 'flores101', and may be removed in the future.")
+
+        try:
+            import sentencepiece as spm
+        except (ImportError, ModuleNotFoundError):
+            raise ImportError(
+                '\n\nPlease install the sentencepiece library for SPM tokenization:'
+                '\n\n  pip install sentencepiece '
+            )
+        self.sp = spm.SentencePieceProcessor()
+
+        model_path = os.path.join(SACREBLEU_DIR, "models", os.path.basename(SPM_MODELS[key]["url"]))
+        if not os.path.exists(model_path):
+            url = SPM_MODELS[self.name]["url"]
+            download_file(url, model_path)
+        self.sp.Load(model_path)
+
+    @lru_cache(maxsize=2**16)
+    def __call__(self, line):
+        """Tokenizes all the characters in the input line.
+
+        :param line: a segment to tokenize
+        :return: the tokenized line
+        """
+        return " ".join(self.sp.EncodeAsPieces(line))
+
+
+class Flores200Tokenizer(TokenizerSPM):
+    def __init__(self):
+        super().__init__("flores200")
+
+class Flores101Tokenizer(TokenizerSPM):
+    def __init__(self):
+        super().__init__("flores101")

evalkit_eagle/lib/python3.10/site-packages/sacrebleu/tokenizers/tokenizer_ter.py

@@ -0,0 +1,171 @@
+# Copyright 2020 Memsource
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+import re
+from functools import lru_cache
+
+from .tokenizer_base import BaseTokenizer
+
+
+def _normalize_general_and_western(sent: str) -> str:
+    # language-independent (general) part
+
+    # strip end-of-line hyphenation and join lines
+    sent = re.sub(r"\n-", "", sent)
+
+    # join lines
+    sent = re.sub(r"\n", " ", sent)
+
+    # handle XML escaped symbols
+    sent = re.sub(r""", "\"", sent)
+    sent = re.sub(r"&", "&", sent)
+    sent = re.sub(r"&lt;", "<", sent)
+    sent = re.sub(r"&gt;", ">", sent)
+
+    # language-dependent (Western) part
+    sent = f" {sent} "
+
+    # tokenize punctuation
+    sent = re.sub(r"([{-~[-` -&(-+:-@/])", r" \1 ", sent)
+
+    # handle possesives
+    sent = re.sub(r"'s ", r" 's ", sent)
+    sent = re.sub(r"'s$", r" 's", sent)
+
+    # tokenize period and comma unless preceded by a digit
+    sent = re.sub(r"([^0-9])([\.,])", r"\1 \2 ", sent)
+
+    # tokenize period and comma unless followed by a digit
+    sent = re.sub(r"([\.,])([^0-9])", r" \1 \2", sent)
+
+    # tokenize dash when preceded by a digit
+    sent = re.sub(r"([0-9])(-)", r"\1 \2 ", sent)
+
+    return sent
+
+
+def _normalize_asian(sent: str) -> str:
+    # Split Chinese chars and Japanese kanji down to character level
+
+    # 4E00—9FFF CJK Unified Ideographs
+    # 3400—4DBF CJK Unified Ideographs Extension A
+    sent = re.sub(r"([\u4e00-\u9fff\u3400-\u4dbf])", r" \1 ", sent)
+
+    # 31C0—31EF CJK Strokes
+    # 2E80—2EFF CJK Radicals Supplement
+    sent = re.sub(r"([\u31c0-\u31ef\u2e80-\u2eff])", r" \1 ", sent)
+
+    # 3300—33FF CJK Compatibility
+    # F900—FAFF CJK Compatibility Ideographs
+    # FE30—FE4F CJK Compatibility Forms
+    sent = re.sub(
+        r"([\u3300-\u33ff\uf900-\ufaff\ufe30-\ufe4f])", r" \1 ", sent)
+
+    # 3200—32FF Enclosed CJK Letters and Months
+    sent = re.sub(r"([\u3200-\u3f22])", r" \1 ", sent)
+
+    # Split Hiragana, Katakana, and KatakanaPhoneticExtensions
+    # only when adjacent to something else
+    # 3040—309F Hiragana
+    # 30A0—30FF Katakana
+    # 31F0—31FF Katakana Phonetic Extensions
+    sent = re.sub(
+        r"(^|^[\u3040-\u309f])([\u3040-\u309f]+)(?=$|^[\u3040-\u309f])",
+        r"\1 \2 ", sent)
+    sent = re.sub(
+        r"(^|^[\u30a0-\u30ff])([\u30a0-\u30ff]+)(?=$|^[\u30a0-\u30ff])",
+        r"\1 \2 ", sent)
+    sent = re.sub(
+        r"(^|^[\u31f0-\u31ff])([\u31f0-\u31ff]+)(?=$|^[\u31f0-\u31ff])",
+        r"\1 \2 ", sent)
+
+    sent = re.sub(TercomTokenizer.ASIAN_PUNCT, r" \1 ", sent)
+    sent = re.sub(TercomTokenizer.FULL_WIDTH_PUNCT, r" \1 ", sent)
+    return sent
+
+
+def _remove_punct(sent: str) -> str:
+    return re.sub(r"[\.,\?:;!\"\(\)]", "", sent)
+
+
+def _remove_asian_punct(sent: str) -> str:
+    sent = re.sub(TercomTokenizer.ASIAN_PUNCT, r"", sent)
+    sent = re.sub(TercomTokenizer.FULL_WIDTH_PUNCT, r"", sent)
+    return sent
+
+
+class TercomTokenizer(BaseTokenizer):
+    """Re-implementation of Tercom Tokenizer in Python 3.
+
+    See src/ter/core/Normalizer.java in https://github.com/jhclark/tercom
+
+    Note that Python doesn't support named Unicode blocks so the mapping for
+    relevant blocks was taken from here:
+
+    https://unicode-table.com/en/blocks/
+    """
+    ASIAN_PUNCT = r"([\u3001\u3002\u3008-\u3011\u3014-\u301f\uff61-\uff65\u30fb])"
+    FULL_WIDTH_PUNCT = r"([\uff0e\uff0c\uff1f\uff1a\uff1b\uff01\uff02\uff08\uff09])"
+
+    def __init__(self,
+                 normalized: bool = False,
+                 no_punct: bool = False,
+                 asian_support: bool = False,
+                 case_sensitive: bool = False):
+        """Initialize the tokenizer.
+
+        :param normalized: Enable character normalization. By default, normalizes a couple of things such as
+            newlines being stripped, retrieving XML encoded characters, and fixing tokenization for punctuation. When
+            'asian_support' is enabled, also normalizes specific Asian (CJK) character sequences, i.e.
+            split them down to the character level.
+        :param no_punct: Remove punctuation. Can be used in conjunction with 'asian_support' to also remove typical
+            punctuation markers in Asian languages (CJK).
+        :param asian_support: Enable special treatment of Asian characters. This option only has an effect when
+            'normalized' and/or 'no_punct' is enabled. If 'normalized' is also enabled, then Asian (CJK)
+            characters are split down to the character level. If 'no_punct' is enabled alongside 'asian_support',
+            specific unicode ranges for CJK and full-width punctuations are also removed.
+        :param case_sensitive: Enable case sensitivity, i.e., do not lower case data.
+        """
+        self._normalized = normalized
+        self._no_punct = no_punct
+        self._asian_support = asian_support
+        self._case_sensitive = case_sensitive
+
+    @lru_cache(maxsize=2**16)
+    # Although the cache is shared across different instances, same sentence
+    # queries do not return invalid returns across different instances since
+    # `self` becomes part of the query as well.
+    def __call__(self, sent: str) -> str:
+        if not sent:
+            return ""
+
+        if not self._case_sensitive:
+            sent = sent.lower()
+
+        if self._normalized:
+            sent = _normalize_general_and_western(sent)
+            if self._asian_support:
+                sent = _normalize_asian(sent)
+
+        if self._no_punct:
+            sent = _remove_punct(sent)
+            if self._asian_support:
+                sent = _remove_asian_punct(sent)
+
+        # Strip extra whitespaces
+        return ' '.join(sent.split())
+
+    def signature(self):
+        return 'tercom'

evalkit_eagle/lib/python3.10/site-packages/sacrebleu/tokenizers/tokenizer_zh.py

@@ -0,0 +1,119 @@
+# Copyright 2017--2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You may not
+# use this file except in compliance with the License. A copy of the License
+# is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is distributed on
+# an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+# express or implied. See the License for the specific language governing
+# permissions and limitations under the License.
+
+##############
+
+# MIT License
+# Copyright (c) 2017 - Shujian Huang <huangsj@nju.edu.cn>
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+# Author: Shujian Huang huangsj@nju.edu.cn
+
+
+from functools import lru_cache
+
+from .tokenizer_base import BaseTokenizer
+from .tokenizer_re import TokenizerRegexp
+
+_UCODE_RANGES = [
+    (u'\u3400', u'\u4db5'),  # CJK Unified Ideographs Extension A, release 3.0
+    (u'\u4e00', u'\u9fa5'),  # CJK Unified Ideographs, release 1.1
+    (u'\u9fa6', u'\u9fbb'),  # CJK Unified Ideographs, release 4.1
+    (u'\uf900', u'\ufa2d'),  # CJK Compatibility Ideographs, release 1.1
+    (u'\ufa30', u'\ufa6a'),  # CJK Compatibility Ideographs, release 3.2
+    (u'\ufa70', u'\ufad9'),  # CJK Compatibility Ideographs, release 4.1
+    (u'\u20000', u'\u2a6d6'),  # (UTF16) CJK Unified Ideographs Extension B, release 3.1
+    (u'\u2f800', u'\u2fa1d'),  # (UTF16) CJK Compatibility Supplement, release 3.1
+    (u'\uff00', u'\uffef'),  # Full width ASCII, full width of English punctuation,
+                             # half width Katakana, half wide half width kana, Korean alphabet
+    (u'\u2e80', u'\u2eff'),  # CJK Radicals Supplement
+    (u'\u3000', u'\u303f'),  # CJK punctuation mark
+    (u'\u31c0', u'\u31ef'),  # CJK stroke
+    (u'\u2f00', u'\u2fdf'),  # Kangxi Radicals
+    (u'\u2ff0', u'\u2fff'),  # Chinese character structure
+    (u'\u3100', u'\u312f'),  # Phonetic symbols
+    (u'\u31a0', u'\u31bf'),  # Phonetic symbols (Taiwanese and Hakka expansion)
+    (u'\ufe10', u'\ufe1f'),
+    (u'\ufe30', u'\ufe4f'),
+    (u'\u2600', u'\u26ff'),
+    (u'\u2700', u'\u27bf'),
+    (u'\u3200', u'\u32ff'),
+    (u'\u3300', u'\u33ff'),
+]
+
+
+class TokenizerZh(BaseTokenizer):
+
+    def signature(self):
+        return 'zh'
+
+    def __init__(self):
+        self._post_tokenizer = TokenizerRegexp()
+
+    @staticmethod
+    @lru_cache(maxsize=2**16)
+    def _is_chinese_char(uchar):
+        """
+        :param uchar: input char in unicode
+        :return: whether the input char is a Chinese character.
+        """
+        for start, end in _UCODE_RANGES:
+            if start <= uchar <= end:
+                return True
+        return False
+
+    @lru_cache(maxsize=2**16)
+    def __call__(self, line):
+        """The tokenization of Chinese text in this script contains two
+        steps: separate each Chinese characters (by utf-8 encoding); tokenize
+        the non Chinese part (following the `13a` i.e. mteval tokenizer).
+
+        Author: Shujian Huang huangsj@nju.edu.cn
+
+        :param line: input sentence
+        :return: tokenized sentence
+        """
+
+        line = line.strip()
+        line_in_chars = ""
+
+        # TODO: the below code could probably be replaced with the following:
+        # @ozan: Gives slightly different scores, need to investigate
+        # import regex
+        # line = regex.sub(r'(\p{Han})', r' \1 ', line)
+        for char in line:
+            if self._is_chinese_char(char):
+                line_in_chars += " "
+                line_in_chars += char
+                line_in_chars += " "
+            else:
+                line_in_chars += char
+
+        return self._post_tokenizer(line_in_chars)