opencc-purepy 1.0.0__tar.gz

opencc_purepy-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 The Python Packaging Authority
+
+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.

opencc_purepy-1.0.0/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: opencc-purepy
+Version: 1.0.0
+Summary: Pure Python implementation of OpenCC for Chinese text conversion
+Author-email: laisuk <laisuk@yahoo.com>
+License: MIT
+Project-URL: Homepage, https://github.com/laisuk/opencc_purepy
+Project-URL: Issues, https://github.com/laisuk/opencc_purepy/issues
+Keywords: opencc,chinese,text,conversion,pure-python
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Text Processing :: Linguistic
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# opencc_purepy
+
+[![PyPI version](https://img.shields.io/pypi/v/opencc-purepy.svg)](https://pypi.org/project/opencc-purepy/)
+[![License](https://img.shields.io/github/license/laisuk/opencc_pyo3)](https://github.com/laisuk/opencc_pyo3/blob/main/LICENSE)
+
+**`opencc_purepy`** is a **pure Python implementation** of OpenCC (Open Chinese Convert), enabling conversion between different Chinese text variants such as Simplified, Traditional, Hong Kong, Taiwan, and Japanese Kanji.  
+It uses dictionary-based segmentation and mapping logic inspired by [BYVoid/OpenCC](https://github.com/BYVoid/OpenCC).
+
+---
+
+## 🔧 Features
+
+- ✅ Pure Python – no native dependencies
+- 🔄 Supports conversion between multiple Chinese locales:
+  - Simplified ↔ Traditional
+  - Traditional ↔ Hong Kong / Taiwan / Japanese
+- ✨ Optional punctuation style conversion
+- 🧠 Automatic simplified/traditional code detection
+
+---
+
+## 🔁 Supported Conversion Configs
+
+| Code     | Description                          |
+|----------|--------------------------------------|
+| `s2t`    | Simplified → Traditional             |
+| `t2s`    | Traditional → Simplified             |
+| `s2tw`   | Simplified → Traditional (Taiwan)    |
+| `tw2s`   | Taiwan → Simplified                  |
+| `s2twp`  | Simplified → Traditional → Taiwan    |
+| `tw2sp`  | Taiwan → Traditional → Simplified    |
+| `s2hk`   | Simplified → Hong Kong               |
+| `hk2s`   | Hong Kong → Simplified               |
+| `t2tw`   | Traditional → Taiwan                 |
+| `tw2t`   | Taiwan → Traditional                 |
+| `t2twp`  | Traditional → Taiwan                 |
+| `tw2tp`  | Taiwan → Traditional                 |
+| `t2hk`   | Traditional → Hong Kong              |
+| `hk2t`   | Hong Kong → Traditional              |
+| `t2jp`   | Traditional → Japanese Kanji         |
+| `jp2t`   | Japanese Kanji → Traditional         |
+
+---
+
+## 📦 Installation
+
+```bash
+pip install opencc-purepy
+```
+
+## 🚀 Usage
+
+### 🐍 Python
+
+```python
+from opencc_purepy import OpenCC
+
+text = "“春眠不觉晓，处处闻啼鸟。”"
+opencc = OpenCC("s2t")
+converted = opencc.convert(text, punctuation=True)
+print(converted)  # 「春眠不覺曉，處處聞啼鳥。」
+```
+
+### 🖥 CLI
+
+```sh
+python -m opencc_purepy convert -i input.txt -o output.txt -c s2t -p
+```
+
+Or if installed as a script:
+
+```bash
+opencc-purepy convert -i input.txt -o output.txt -c s2t -p
+```
+
+## 🧩 API Reference
+
+### Class: `OpenCC`
+
+- `OpenCC(config: str = "s2t")`
+    - `config`: Conversion configuration (see above).
+- `convert(input: str, punctuation: bool = False) -> str`
+    - Convert text with optional punctuation conversion.
+- `zho_check(input: str) -> int`  
+  - Detects the code of the input text.
+      - 1 - Traditional, 
+      - 2 - Simplified, 
+      - 0 - others
+
+## 🛠 Development
+
+- Python bindings: [opencc_purepy/__init__.py](https://github.com/laisuk/opencc_purepy/blob/master/opencc_purepy/__init__.py), [opencc_purepy/opencc_purepy.pyi](https://github.com/laisuk/opencc_purepy/blob/master/opencc_purepy/opencc_purepy.pyi)
+- CLI: [opencc_purepy/__main__.py](https://github.com/laisuk/opencc_purepy/blob/master/opencc_purepy/__main__.py)
+
+## 📄 License
+This project is licensed under the [MIT](https://github.com/laisuk/opencc_purepy/blob/master/LICENSE) License.
+
+---
+
+Powered by Pure Python and OpenCC Lexicons.

opencc_purepy-1.0.0/README.md

@@ -0,0 +1,100 @@
+# opencc_purepy
+
+[![PyPI version](https://img.shields.io/pypi/v/opencc-purepy.svg)](https://pypi.org/project/opencc-purepy/)
+[![License](https://img.shields.io/github/license/laisuk/opencc_pyo3)](https://github.com/laisuk/opencc_pyo3/blob/main/LICENSE)
+
+**`opencc_purepy`** is a **pure Python implementation** of OpenCC (Open Chinese Convert), enabling conversion between different Chinese text variants such as Simplified, Traditional, Hong Kong, Taiwan, and Japanese Kanji.  
+It uses dictionary-based segmentation and mapping logic inspired by [BYVoid/OpenCC](https://github.com/BYVoid/OpenCC).
+
+---
+
+## 🔧 Features
+
+- ✅ Pure Python – no native dependencies
+- 🔄 Supports conversion between multiple Chinese locales:
+  - Simplified ↔ Traditional
+  - Traditional ↔ Hong Kong / Taiwan / Japanese
+- ✨ Optional punctuation style conversion
+- 🧠 Automatic simplified/traditional code detection
+
+---
+
+## 🔁 Supported Conversion Configs
+
+| Code     | Description                          |
+|----------|--------------------------------------|
+| `s2t`    | Simplified → Traditional             |
+| `t2s`    | Traditional → Simplified             |
+| `s2tw`   | Simplified → Traditional (Taiwan)    |
+| `tw2s`   | Taiwan → Simplified                  |
+| `s2twp`  | Simplified → Traditional → Taiwan    |
+| `tw2sp`  | Taiwan → Traditional → Simplified    |
+| `s2hk`   | Simplified → Hong Kong               |
+| `hk2s`   | Hong Kong → Simplified               |
+| `t2tw`   | Traditional → Taiwan                 |
+| `tw2t`   | Taiwan → Traditional                 |
+| `t2twp`  | Traditional → Taiwan                 |
+| `tw2tp`  | Taiwan → Traditional                 |
+| `t2hk`   | Traditional → Hong Kong              |
+| `hk2t`   | Hong Kong → Traditional              |
+| `t2jp`   | Traditional → Japanese Kanji         |
+| `jp2t`   | Japanese Kanji → Traditional         |
+
+---
+
+## 📦 Installation
+
+```bash
+pip install opencc-purepy
+```
+
+## 🚀 Usage
+
+### 🐍 Python
+
+```python
+from opencc_purepy import OpenCC
+
+text = "“春眠不觉晓，处处闻啼鸟。”"
+opencc = OpenCC("s2t")
+converted = opencc.convert(text, punctuation=True)
+print(converted)  # 「春眠不覺曉，處處聞啼鳥。」
+```
+
+### 🖥 CLI
+
+```sh
+python -m opencc_purepy convert -i input.txt -o output.txt -c s2t -p
+```
+
+Or if installed as a script:
+
+```bash
+opencc-purepy convert -i input.txt -o output.txt -c s2t -p
+```
+
+## 🧩 API Reference
+
+### Class: `OpenCC`
+
+- `OpenCC(config: str = "s2t")`
+    - `config`: Conversion configuration (see above).
+- `convert(input: str, punctuation: bool = False) -> str`
+    - Convert text with optional punctuation conversion.
+- `zho_check(input: str) -> int`  
+  - Detects the code of the input text.
+      - 1 - Traditional, 
+      - 2 - Simplified, 
+      - 0 - others
+
+## 🛠 Development
+
+- Python bindings: [opencc_purepy/__init__.py](https://github.com/laisuk/opencc_purepy/blob/master/opencc_purepy/__init__.py), [opencc_purepy/opencc_purepy.pyi](https://github.com/laisuk/opencc_purepy/blob/master/opencc_purepy/opencc_purepy.pyi)
+- CLI: [opencc_purepy/__main__.py](https://github.com/laisuk/opencc_purepy/blob/master/opencc_purepy/__main__.py)
+
+## 📄 License
+This project is licensed under the [MIT](https://github.com/laisuk/opencc_purepy/blob/master/LICENSE) License.
+
+---
+
+Powered by Pure Python and OpenCC Lexicons.

opencc_purepy-1.0.0/opencc_purepy/__init__.py

@@ -0,0 +1,6 @@
+##########################################################
+# Author: Bryan Lai
+# GitHub: laisuk
+# January, 2025
+##########################################################
+from .core import OpenCC

opencc_purepy-1.0.0/opencc_purepy/__main__.py

@@ -0,0 +1,46 @@
+from __future__ import print_function
+
+import argparse
+import sys
+from . import dictgen_cmd
+from . import convert_cmd  # We'll move your current logic into convert_cmd.py
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog='opencc_purepy',
+        description='OpenCC CLI with multiple tools',
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+
+    subparsers = parser.add_subparsers(dest='command', required=True)
+
+    # ---- convert subcommand ----
+    parser_convert = subparsers.add_parser('convert', help='Convert text using OpenCC')
+    parser_convert.add_argument('-i', '--input', metavar='<file>', help='Input file')
+    parser_convert.add_argument('-o', '--output', metavar='<file>', help='Output file')
+    parser_convert.add_argument('-c', '--config', metavar='<conversion>', help='Conversion configuration')
+    parser_convert.add_argument('-p', '--punct', action='store_true', default=False, help='Punctuation conversion: True/False')
+    parser_convert.add_argument('--in-enc', metavar='<encoding>', default='UTF-8', help='Input encoding')
+    parser_convert.add_argument('--out-enc', metavar='<encoding>', default='UTF-8', help='Output encoding')
+    parser_convert.set_defaults(func=convert_cmd.main)
+
+    # ---- dictgen subcommand ----
+    parser_dictgen = subparsers.add_parser('dictgen', help='Generate dictionary')
+    parser_dictgen.add_argument(
+        "-f", "--format",
+        choices=["json"],
+        default="json",
+        help="Dictionary format: [json]"
+    )
+    parser_dictgen.add_argument(
+        "-o", "--output",
+        metavar="<filename>",
+        help="Write generated dictionary to <filename>. If not specified, a default filename is used."
+    )
+    parser_dictgen.set_defaults(func=dictgen_cmd.main)
+
+    args = parser.parse_args()
+    return args.func(args)
+
+if __name__ == '__main__':
+    sys.exit(main())

opencc_purepy-1.0.0/opencc_purepy/convert_cmd.py

@@ -0,0 +1,28 @@
+import io
+import sys
+from opencc_purepy import OpenCC
+
+def main(args):
+    if args.config is None:
+        print("Please specify conversion.", file=sys.stderr)
+        return 1
+
+    opencc = OpenCC(args.config)
+
+    # Prompt only if reading from stdin, and it's interactive (i.e., not piped or redirected)
+    if args.input is None and sys.stdin.isatty():
+        print("Input text to convert, <Ctrl+Z> (Windows) or <Ctrl+D> (Unix) then Enter to submit:", file=sys.stderr)
+
+    with io.open(args.input if args.input else 0, encoding=args.in_enc) as f:
+        input_str = f.read()
+    output_str = opencc.convert(input_str, args.punct)
+
+    with io.open(args.output if args.output else 1, 'w', encoding=args.out_enc) as f:
+        f.write(output_str)
+
+    in_from = args.input if args.input else "<stdin>"
+    out_to = args.output if args.output else "stdout"
+    if sys.stderr.isatty():
+        print(f"Conversion completed ({args.config}): {in_from} -> {out_to}", file=sys.stderr)
+
+    return 0

opencc_purepy-1.0.0/opencc_purepy/core.py

@@ -0,0 +1,362 @@
+import re
+from typing import List, Dict, Tuple
+from .dictionary_lib import DictionaryMaxlength
+
+DELIMITERS = set(
+    " \t\n\r!\"#$%&'()*+,-./:;<=>?@[\\]^_{}|~＝、。“”‘’『』「」﹁﹂—－（）《》〈〉？！…／＼︒︑︔︓︿﹀︹︺︙︐［﹇］﹈︕︖︰︳︴︽︾︵︶｛︷｝︸﹃﹄【︻】︼　～．，；：")
+STRIP_REGEX = re.compile(r"[!-/:-@\[-`{-~\t\n\v\f\r 0-9A-Za-z_]")
+
+
+class DictRefs:
+    def __init__(self, round_1):
+        self.round_1 = round_1
+        self.round_2 = None
+        self.round_3 = None
+
+    def with_round_2(self, round_2):
+        self.round_2 = round_2
+        return self
+
+    def with_round_3(self, round_3):
+        self.round_3 = round_3
+        return self
+
+    def apply_segment_replace(self, input_text, segment_replace):
+        output = segment_replace(input_text, self.round_1)
+        if self.round_2:
+            output = segment_replace(output, self.round_2)
+        if self.round_3:
+            output = segment_replace(output, self.round_3)
+        return output
+
+
+class OpenCC:
+    def __init__(self, config=None):
+        _config_list = [
+            "s2t", "t2s", "s2tw", "tw2s", "s2twp", "tw2sp", "s2hk", "hk2s", "t2tw", "tw2t", "t2twp", "tw2t", "tw2tp",
+            "t2hk", "hk2t", "t2jp", "jp2t"
+        ]
+        if config in _config_list:
+            self.config = config
+        else:
+            self._last_error = f"Invalid config: {config}"
+            self.config = "s2t"
+        try:
+            self.dictionary = DictionaryMaxlength.new()
+            # self.dictionary = DictionaryMaxlength.from_dicts()
+        except Exception as e:
+            self._last_error = str(e)  # <- Use thread-safe setter
+            self.dictionary = DictionaryMaxlength()
+
+        self.delimiters = DELIMITERS
+
+    def get_last_error(self):
+        return self._last_error
+
+    def segment_replace(self, text: str, dictionaries: List[Tuple[Dict[str, str], int]]) -> str:
+        max_word_length = max((length for _, length in dictionaries), default=1)
+        ranges = self.get_split_ranges(text)
+        return "".join(
+            self.convert_by(list(text[start:end]), dictionaries, max_word_length)
+            for start, end in ranges
+        )
+
+    def convert_by(self, text_chars: List[str], dictionaries, max_word_length: int) -> str:
+        if not text_chars:
+            return ""
+
+        delimiters = self.delimiters  # Local variable for speed
+        if len(text_chars) == 1 and text_chars[0] in delimiters:
+            return text_chars[0]
+
+        result = []
+        i = 0
+        text_chars_len = len(text_chars)
+        while i < text_chars_len:
+            best_match = None
+            best_length = 0
+            # Use local variable for dictionaries
+            for length in range(min(max_word_length, text_chars_len - i), 0, -1):
+                word = "".join(text_chars[i:i + length])
+                for d, _ in dictionaries:
+                    match = d.get(word)
+                    if match is not None:
+                        best_match = match
+                        best_length = length
+                        break
+                if best_length:
+                    break
+            if not best_length:
+                best_match = text_chars[i]
+                best_length = 1
+            result.append(best_match)
+            i += best_length
+        return "".join(result)
+
+    def get_split_ranges(self, text: str) -> List[Tuple[int, int]]:
+        """
+        Returns a list of (start, end) index tuples, where each tuple represents
+        the start (inclusive) and end (exclusive) indices of a chunk in the text.
+        """
+        ranges = []
+        start = 0
+        for i, ch in enumerate(text):
+            if ch in self.delimiters:
+                ranges.append((start, i + 1))  # include the delimiter
+                start = i + 1
+        if start < len(text):
+            ranges.append((start, len(text)))
+        return ranges
+
+    def s2t(self, input_text: str, punctuation: bool = False) -> str:
+        if not input_text:
+            self._last_error = "Input text is empty"
+            return ""
+        refs = DictRefs([
+            self.dictionary.st_phrases,
+            self.dictionary.st_characters
+        ])
+        output = refs.apply_segment_replace(input_text, self.segment_replace)
+        return self.convert_punctuation(output, "s") if punctuation else output
+
+    def t2s(self, input_text: str, punctuation: bool = False) -> str:
+        refs = DictRefs([
+            self.dictionary.ts_phrases,
+            self.dictionary.ts_characters
+        ])
+        output = refs.apply_segment_replace(input_text, self.segment_replace)
+        return self.convert_punctuation(output, "t") if punctuation else output
+
+    def s2tw(self, input_text: str, punctuation: bool = False) -> str:
+        refs = DictRefs([
+            self.dictionary.st_phrases,
+            self.dictionary.st_characters
+        ]).with_round_2([
+            self.dictionary.tw_variants
+        ])
+        output = refs.apply_segment_replace(input_text, self.segment_replace)
+        return self.convert_punctuation(output, "s") if punctuation else output
+
+    def tw2s(self, input_text: str, punctuation: bool = False) -> str:
+        refs = DictRefs([
+            self.dictionary.tw_variants_rev_phrases,
+            self.dictionary.tw_variants_rev
+        ]).with_round_2([
+            self.dictionary.ts_phrases,
+            self.dictionary.ts_characters
+        ])
+        output = refs.apply_segment_replace(input_text, self.segment_replace)
+        return self.convert_punctuation(output, "t") if punctuation else output
+
+    def s2twp(self, input_text: str, punctuation: bool = False) -> str:
+        refs = DictRefs([
+            self.dictionary.st_phrases,
+            self.dictionary.st_characters
+        ]).with_round_2([
+            self.dictionary.tw_phrases
+        ]).with_round_3([
+            self.dictionary.tw_variants
+        ])
+        output = refs.apply_segment_replace(input_text, self.segment_replace)
+        return self.convert_punctuation(output, "s") if punctuation else output
+
+    def tw2sp(self, input_text: str, punctuation: bool = False) -> str:
+        refs = DictRefs([
+            self.dictionary.tw_phrases_rev,
+            self.dictionary.tw_variants_rev_phrases,
+            self.dictionary.tw_variants_rev
+        ]).with_round_2([
+            self.dictionary.ts_phrases,
+            self.dictionary.ts_characters
+        ])
+        output = refs.apply_segment_replace(input_text, self.segment_replace)
+        return self.convert_punctuation(output, "t") if punctuation else output
+
+    def s2hk(self, input_text: str, punctuation: bool = False) -> str:
+        refs = DictRefs([
+            self.dictionary.st_phrases,
+            self.dictionary.st_characters
+        ]).with_round_2([
+            self.dictionary.hk_variants
+        ])
+        output = refs.apply_segment_replace(input_text, self.segment_replace)
+        return self.convert_punctuation(output, "s") if punctuation else output
+
+    def hk2s(self, input_text: str, punctuation: bool = False) -> str:
+        refs = DictRefs([
+            self.dictionary.hk_variants_rev_phrases,
+            self.dictionary.hk_variants_rev
+        ]).with_round_2([
+            self.dictionary.ts_phrases,
+            self.dictionary.ts_characters
+        ])
+        output = refs.apply_segment_replace(input_text, self.segment_replace)
+        return self.convert_punctuation(output, "t") if punctuation else output
+
+    def t2tw(self, input_text: str) -> str:
+        refs = DictRefs([
+            self.dictionary.tw_variants
+        ])
+        output = refs.apply_segment_replace(input_text, self.segment_replace)
+        return output
+
+    def t2twp(self, input_text: str) -> str:
+        refs = DictRefs([
+            self.dictionary.tw_phrases
+        ]).with_round_2([
+            self.dictionary.tw_variants
+        ])
+        output = refs.apply_segment_replace(input_text, self.segment_replace)
+        return output
+
+    def tw2t(self, input_text: str) -> str:
+        refs = DictRefs([
+            self.dictionary.tw_variants_rev_phrases,
+            self.dictionary.tw_variants_rev
+        ])
+        output = refs.apply_segment_replace(input_text, self.segment_replace)
+        return output
+
+    def tw2tp(self, input_text: str) -> str:
+        refs = DictRefs([
+            self.dictionary.tw_variants_rev_phrases,
+            self.dictionary.tw_variants_rev
+        ]).with_round_2([
+            self.dictionary.tw_phrases_rev
+        ])
+        output = refs.apply_segment_replace(input_text, self.segment_replace)
+        return output
+
+    def t2hk(self, input_text: str) -> str:
+        refs = DictRefs([
+            self.dictionary.hk_variants
+        ])
+        output = refs.apply_segment_replace(input_text, self.segment_replace)
+        return output
+
+    def hk2t(self, input_text: str) -> str:
+        refs = DictRefs([
+            self.dictionary.hk_variants_rev_phrases,
+            self.dictionary.hk_variants_rev
+        ])
+        output = refs.apply_segment_replace(input_text, self.segment_replace)
+        return output
+
+    def t2jp(self, input_text: str) -> str:
+        refs = DictRefs([
+            self.dictionary.jp_variants
+        ])
+        output = refs.apply_segment_replace(input_text, self.segment_replace)
+        return output
+
+    def jp2t(self, input_text: str) -> str:
+        refs = DictRefs([
+            self.dictionary.jps_phrases,
+            self.dictionary.jps_characters,
+            self.dictionary.jp_variants_rev
+        ])
+        output = refs.apply_segment_replace(input_text, self.segment_replace)
+        return output
+
+    def convert(self, input_text: str, punctuation: bool = False) -> str:
+        config = self.config.lower()
+        try:
+            if config == "s2t":
+                return self.s2t(input_text, punctuation)
+            elif config == "s2tw":
+                return self.s2tw(input_text, punctuation)
+            elif config == "s2twp":
+                return self.s2twp(input_text, punctuation)
+            elif config == "s2hk":
+                return self.s2hk(input_text, punctuation)
+            elif config == "t2s":
+                return self.t2s(input_text, punctuation)
+            elif config == "t2tw":
+                return self.t2tw(input_text)
+            elif config == "t2twp":
+                return self.t2twp(input_text)
+            elif config == "t2hk":
+                return self.t2hk(input_text)
+            elif config == "tw2s":
+                return self.tw2s(input_text, punctuation)
+            elif config == "tw2sp":
+                return self.tw2sp(input_text, punctuation)
+            elif config == "tw2t":
+                return self.tw2t(input_text)
+            elif config == "tw2tp":
+                return self.tw2tp(input_text)
+            elif config == "hk2s":
+                return self.hk2s(input_text, punctuation)
+            elif config == "hk2t":
+                return self.hk2t(input_text)
+            elif config == "jp2t":
+                return self.jp2t(input_text)
+            elif config == "t2jp":
+                return self.t2jp(input_text)
+            else:
+                self._last_error = f"Invalid config: {config}"
+                return self._last_error
+        except Exception as e:
+            self._last_error = f"Conversion failed: {e}"
+            return self._last_error
+
+    def st(self, input_text: str) -> str:
+        dict_refs = [self.dictionary.st_characters]
+        chars = list(input_text)  # converts str into list of chars
+        return self.convert_by(chars, dict_refs, 1)
+
+    def ts(self, input_text: str) -> str:
+        dict_refs = [self.dictionary.ts_characters]
+        chars = list(input_text)  # converts str into list of chars
+        return self.convert_by(chars, dict_refs, 1)
+
+    def zho_check(self, input_text: str) -> int:
+        if not input_text:
+            return 0
+
+        stripped = STRIP_REGEX.sub("", input_text)
+        max_chars = find_max_utf8_length(stripped, 200)
+        strip_text = stripped[:max_chars]
+
+        if strip_text != self.ts(strip_text):
+            return 1
+        elif strip_text != self.st(strip_text):
+            return 2
+        else:
+            return 0
+
+    @staticmethod
+    def convert_punctuation(input_text: str, config: str) -> str:
+        s2t = {
+            '“': '「',
+            '”': '」',
+            '‘': '『',
+            '’': '』',
+        }
+
+        t2s = {
+            '「': '“',
+            '」': '”',
+            '『': '‘',
+            '』': '’',
+        }
+
+        if config[0] == 's':
+            mapping = s2t
+            pattern = "[" + "".join(re.escape(c) for c in s2t.keys()) + "]"
+        else:
+            pattern = "[" + "".join(re.escape(c) for c in t2s.keys()) + "]"
+            mapping = t2s
+
+        return re.sub(pattern, lambda m: mapping[m.group()], input_text)
+
+
+def find_max_utf8_length(s: str, max_byte_count: int) -> int:
+    encoded = s.encode('utf-8')
+    if len(encoded) <= max_byte_count:
+        return len(encoded)
+
+    byte_count = max_byte_count
+    while byte_count > 0 and (encoded[byte_count] & 0b11000000) == 0b10000000:
+        byte_count -= 1
+    return byte_count