New oopmultilang,LICENSE

leoweyr · leoweyr · commit 4eeb4ee538ee · 2023-05-05T22:01:34.000+08:00
diff --git a/LICENSE b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-present, leoweyr
+
+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.
diff --git a/README.md b/README.md
@@ -1,2 +1,3 @@
-# Python-OOPMultilang
- A Python package that supports multi-language conversion of the object-oriented paradigm.
+# OOPMultilang
+
+A Python package that supports multi-language conversion of the object-oriented paradigm.
diff --git a/oopmultilang/__init__.py b/oopmultilang/__init__.py
@@ -0,0 +1,7 @@
+from .lang import (
+    Lang,
+    load_mode,
+    LangDictSearchError
+)
+
+__all__ = ["Lang", "load_mode", "LangDictSearchError"]
diff --git a/oopmultilang/_errors.py b/oopmultilang/_errors.py
@@ -0,0 +1,65 @@
+import inspect
+import os
+import sys
+from enum import Enum
+
+
+class ExpressionError(Exception):
+    def __init__(self, expression):
+        self.__m_expression = expression
+        self.__m_traceback_filename = inspect.getframeinfo(inspect.currentframe().f_back).filename
+        self.__m_tracebakc_lineno = inspect.currentframe().f_back.f_lineno
+        self.__m_message = "invalid expression"
+        # Use Python default exception handler to handle this exception.
+        sys.last_type = type(self)
+        sys.last_value = self
+        sys.last_traceback = self.__traceback__
+
+    def __str__(self):
+        if self.__m_expression.count(
+                "as") > 1:  # If the expression contains more than one "as" keyword, find the error index and indicate it.
+            error_index = self.__m_expression.find("as", self.__m_expression.find("as") + 1)
+            error_message = f"""File \"{os.path.abspath(self.__m_traceback_filename)}\", line {self.__m_tracebakc_lineno}\
+            \n\t{self.__m_expression}\
+            \n\t{' ' * error_index}^\
+            \nExpressionError: {self.__m_message}
+            """
+        return error_message
+
+
+class LangDictSearchError(Exception, Enum):
+    # Error type.
+    UNIVERSAL_WORD_EXIST_ERROR = 1
+    SOURCE_LANG_DICT_MATCH_ERROR = 2
+    TARGET_LANG_DICT_MATCH_ERROR = 3
+
+    def __init__(self, error_type, error_word, source_lang, target_lang):
+        self.__m_error_type = error_type
+        self.__m_error_word = error_word
+        self.__m_error_position = None
+        self.__m_message = ""
+
+        # Different error conditions.
+        if self.__m_error_type == LangDictSearchError.UNIVERSAL_WORD_EXIST_ERROR:
+            self.__m_message = f"'{self.__m_error_word}' is not the universal word in language dictionaries"
+        elif self.__m_error_type == LangDictSearchError.SOURCE_LANG_DICT_MATCH_ERROR:
+            self.__m_error_position = source_lang
+            self.__m_message = f"'{self.__m_error_word}' is not the native word in '{self.__m_error_position}' dictionary"
+        elif self.__m_error_type == LangDictSearchError.TARGET_LANG_DICT_MATCH_ERROR:
+            self.__m_error_position = target_lang
+            self.__m_message = f"'{self.__m_error_word}' can not be converted to the native word in '{self.__m_error_position}' dictionary"
+
+    def __str__(self):
+        return self.__m_message
+
+    @property
+    def type(self):
+        return self.__m_error_type
+
+    @property
+    def word(self):
+        return self.word
+
+    @property
+    def position(self):
+        return self.__m_error_position
diff --git a/oopmultilang/_lang_dict_parser.py b/oopmultilang/_lang_dict_parser.py
@@ -0,0 +1,42 @@
+class LangDictParser:
+    """
+    Each lang dict data structure is uniformly composed of universal word and native word in pairs.
+
+    - ``universal word``: Similar to the object-oriented usage, generally expressed in English.
+    - ``native word``: Native word of the language associated with the lang dict.
+    """
+    @classmethod
+    def loads(cls, lang_dict):
+        pass
+
+    @classmethod
+    def dumps(cls, python_dict: dict):
+        pass
+
+
+class LangTypeLangDict(LangDictParser):
+    @classmethod
+    def loads(cls, lang_dict: str):
+        python_dict = {}
+        line_index = 1
+        for line in lang_dict.split('\n'):
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            if "#" in line:
+                line = line[:line.index("#")]
+            if "=" not in line:
+                raise ValueError(f"invalid lang type data, line {line_index} is missing at most one equals sign")
+            key, value = line.split("=")
+            python_dict[key.strip()] = value.strip()
+            line_index += 1
+        return python_dict
+
+    @classmethod
+    def dumps(cls, python_dict: dict):
+        if not isinstance(python_dict, dict):
+            raise ValueError("invalid dict")
+        lang_dict = ""
+        for key, value in python_dict.items():
+            lang_dict += f"{key} = {value}\n"
+        return lang_dict
diff --git a/oopmultilang/lang.py b/oopmultilang/lang.py
@@ -0,0 +1,171 @@
+from enum import Enum
+
+"""
+An enumeration representing two loading modes.
+
+- ``REALTIME``: Static data files are read for each conversion.
+- ``ONETIME``: Static data files are only read once when the object is instantiated for the first time.
+"""
+load_mode = Enum('LoadMode', ('REALTIME', 'ONETIME'))
+
+
+from _errors import ExpressionError
+from _errors import LangDictSearchError
+from _lang_dict_parser import LangTypeLangDict
+from easierfile import File
+
+
+class _LangUniversal():
+    def __init__(self, super_self, lang_dicts):
+        self.__m_dict = lang_dicts
+        self.__m_super_self = super_self
+
+    def __getattr__(self, universal_word_form_call):
+        """
+        Chained calls enable the universal word to support object-oriented expression without string quotes in the code.
+        """
+        universal_word_form_call_chain = [universal_word_form_call]
+        super_self = self.__m_super_self
+        lang_dicts = self.__m_dict
+
+        class ChainedClass:
+            def __getattr__(self, universal_word_form_call):
+                universal_word_form_call_chain.append(universal_word_form_call)
+                return ChainedClass()
+
+            def __repr__(self):
+                """
+                Final settlement of Chained Calls.
+                """
+                if universal_word_form_call_chain[-1] in lang_dicts.keys():
+                    return super_self.str('.'.join(universal_word_form_call_chain[0:-1]), None, universal_word_form_call_chain[-1])
+                else:
+                    return super_self.str('.'.join(universal_word_form_call_chain))
+
+        return ChainedClass()
+
+
+class Lang:
+    def __init__(self, include=(), load_mode=load_mode.REALTIME):
+        self.__m_dict = {}
+        self._m_load_mode = load_mode
+
+        # None represents the universal word.
+        self.__m_default_source_lang = None
+        self.__m_default_target_lang = None
+
+        if len(include) != 0:
+            for expression in include:
+                """
+                Parses expressions imported into language dictionaries via param<include>.
+
+                There are two forms of this expression, one is full and the other is short.
+
+                For example:
+
+                1. ``full``: './en_us.lang as en_us'
+                2. ``short``: './en_us.lang'
+
+                Note that when using the short form, the name of the associated language will be the name of the file.
+                """
+                if expression.find("as") != -1:
+                    if expression.count("as") == 1:
+                        """
+                        A list of strings representing the distinct terms of the expression after it is parsed.
+                        
+                        - ``expression_parsing[0]``: The file path of the language dictionary.
+                        - ``expression_parsing[1]``: The associated language of the language dictionary.
+                        """
+                        expression_parsing = [expression_unit.strip() for expression_unit in expression]
+                        dictionary_file = File(expression_parsing[0])
+                        dictionary_associated_lang = expression_parsing[1]
+                    else:
+                        raise ExpressionError(expression)
+                else:
+                    dictionary_file = File(expression)
+                    dictionary_associated_lang = dictionary_file.info["name"]
+
+                # Store language dictionary file information for different languages into member:private<self.__m_dict>.
+                if not dictionary_file.status["exist"]:
+                    raise FileNotFoundError("Language dictionary not found: " + dictionary_file.info["path"])
+                else:
+                    if dictionary_associated_lang in self.__m_dict.keys():
+                        self.__m_dict[dictionary_associated_lang].append(dictionary_file.info["path"])
+                    else:
+                        self.__m_dict[dictionary_associated_lang] = [dictionary_file.info["path"]]
+
+        # One-time loading mode.
+        if self._m_load_mode == load_mode.ONETIME:
+            self.__load_lang_dict()
+
+    def __load_lang_dict(self):
+        new_dict = self.__m_dict.copy()
+        for dictionary_associated_lang, dictionary in self.__m_dict.items():
+            if isinstance(dictionary, list):  # Indicates that dictionary is a list of lang dict file path.
+                new_dict[dictionary_associated_lang] = {}
+                for dictionary_file_path in dictionary:
+                    dict_file = File(dictionary_file_path)
+                    if dict_file.info["ext"] == "lang":  # Parse the lang dict of type .lang
+                        new_dict[dictionary_associated_lang].update(LangTypeLangDict.loads(dict_file.content))
+        self.__m_dict = new_dict
+
+    def default_lang(self, source_lang=None, target_lang=None):
+        if source_lang is not None:
+            self.__m_default_source_lang = source_lang
+        if target_lang is not None:
+            self.__m_default_target_lang = target_lang
+
+    def str(self, word, source_lang=None, target_lang=None):
+        # Whether are default langs setting.
+        if source_lang is None:
+            source_lang = self.__m_default_source_lang
+        if target_lang is None:
+            target_lang = self.__m_default_target_lang
+
+        # Real-time loading mode.
+        if self._m_load_mode == load_mode.REALTIME:
+            self.__load_lang_dict()
+
+        # Initialize lang dict search transition value.
+        source_word = word
+        universal_word = None
+        target_word = None
+
+        # Search for the universal word corresponding to the native word.
+        if source_lang is None:
+            is_matched = False
+            for dictionary in self.__m_dict.values():
+                if source_word in dictionary.keys():
+                    universal_word = source_word
+                    is_matched = True
+            if not is_matched:
+                raise LangDictSearchError(
+                    LangDictSearchError.UNIVERSAL_WORD_EXIST_ERROR, source_word, source_lang, target_lang)
+        else:
+            is_matched = False
+            for dictionary_universal_word, dictionary_native_word in self.__m_dict[source_lang].items():
+                if dictionary_native_word == source_word:
+                    universal_word = dictionary_universal_word
+                    is_matched = True
+            if not is_matched:
+                raise LangDictSearchError(
+                    LangDictSearchError.SOURCE_LANG_DICT_MATCH_ERROR, source_word, source_lang, target_lang)
+
+        # Search for the native word corresponding to the universal word.
+        if target_lang is None:
+            target_word = universal_word
+        else:
+            is_matched = False
+            for dictionary_universal_word, dictionary_native_word in self.__m_dict[target_lang].items():
+                if dictionary_universal_word == universal_word:
+                    target_word = dictionary_native_word
+                    is_matched =True
+            if not is_matched:
+                raise LangDictSearchError(
+                    LangDictSearchError.TARGET_LANG_DICT_MATCH_ERROR, source_word, source_lang, target_lang)
+            
+        return target_word
+
+    @property
+    def universal(self):
+        return _LangUniversal(self, self.__m_dict)
