pymud 0.20.4__py3-none-any.whl → 0.21.0__py3-none-any.whl

pymud/__init__.py

@@ -1,12 +1,17 @@
 from .settings import Settings
 from .pymud import PyMudApp
-from .modules import IConfig
+from .modules import IConfigBase, IConfig, PymudMeta
 from .objects import CodeBlock, Alias, SimpleAlias, Trigger, SimpleTrigger, Command, SimpleCommand, Timer, SimpleTimer, GMCPTrigger
 from .extras import DotDict
 from .session import Session
 from .logger import Logger
 from .main import main
+from .decorators import exception, async_exception, PymudDecorator, alias, trigger, timer, gmcp
 
 __all__ = [
-    "IConfig", "PyMudApp", "Settings", "CodeBlock", "Alias", "SimpleAlias", "Trigger", "SimpleTrigger", "Command", "SimpleCommand", "Timer", "SimpleTimer", "GMCPTrigger", "Session", "PyMudApp", "DotDict", "Logger", "main"
+    "PymudMeta", "IConfigBase", "IConfig", "PyMudApp", "Settings", "CodeBlock", 
+    "Alias", "SimpleAlias", "Trigger", "SimpleTrigger", 
+    "Command", "SimpleCommand", "Timer", "SimpleTimer", 
+    "GMCPTrigger", "Session", "DotDict", "Logger", "main",
+    "exception", "async_exception", "PymudDecorator", "alias", "trigger", "timer", "gmcp",
 ]

pymud/decorators.py

@@ -0,0 +1,234 @@
+import sys, functools, traceback
+from typing import Union, Optional, List
+
+def print_exception(session, e: Exception):
+    """打印异常信息"""
+    from .settings import Settings
+    from .session import Session
+    if isinstance(session, Session):
+        # tb = sys.exc_info()[2]
+        # frames = traceback.extract_tb(tb)
+        # frame = frames[-1]
+        # session.error(Settings.gettext("exception_traceback", frame.filename, frame.lineno, frame.name), Settings.gettext("script_error"))
+        # if frame.line:
+        #     session.error(f"    {frame.line}", Settings.gettext("script_error"))
+
+        # session.error(Settings.gettext("exception_message", type(e).__name__, e), Settings.gettext("script_error"))
+        # session.error("===========================", Settings.gettext("script_error"))
+        session.error(traceback.format_exc(), Settings.gettext("script_error"))
+
+def exception(func):
+    """方法异常处理装饰器，捕获异常后通过会话的session.error打印相关信息"""
+    @functools.wraps(func)
+    def wrapper(self, *args, **kwargs):
+        from .objects import BaseObject
+        from .modules import ModuleInfo, IConfig
+        from .session import Session
+        from .settings import Settings
+        try:
+            return func(self, *args, **kwargs)
+        except Exception as e:
+            # 调用类的错误处理方法
+            if isinstance(self, Session):
+                session = self
+            elif isinstance(self, (BaseObject, IConfig, ModuleInfo)):
+                session = self.session
+            else:
+                session = None
+                
+            if isinstance(session, Session):
+                print_exception(session, e)
+                #session.error(Settings.gettext("exception_message", e, type(e)))
+                #session.error(Settings.gettext("exception_traceback", traceback.format_exc()))
+            else:
+                raise  # 当没有会话时，选择重新抛出异常
+    return wrapper
+
+def async_exception(func):
+    """异步方法异常处理装饰器，捕获异常后通过会话的session.error打印相关信息"""
+    @functools.wraps(func)
+    async def wrapper(self, *args, **kwargs):
+        from .objects import BaseObject
+        from .modules import ModuleInfo, IConfig
+        from .session import Session
+        from .settings import Settings
+        try:
+            return await func(self, *args, **kwargs)
+        except Exception as e:
+            if isinstance(self, Session):
+                session = self
+            elif isinstance(self, (BaseObject, IConfig, ModuleInfo)):
+                session = self.session
+            else:
+                session = None
+
+            if isinstance(session, Session):
+                print_exception(session, e)
+
+            else:
+                raise  # 当没有会话时，选择重新抛出异常
+    return wrapper
+
+
+class PymudDecorator:
+    """
+    装饰器基类。使用装饰器可以快捷创建各类Pymud基础对象。
+    
+        :param type: 装饰器的类型，用于区分不同的装饰器，为字符串类型。
+        :param args: 可变位置参数，用于传递额外的参数。
+        :param kwargs: 可变关键字参数，用于传递额外的键值对参数。
+    """
+    def __init__(self, type: str, *args, **kwargs):
+        self.type = type
+        self.args = args
+        self.kwargs = kwargs
+
+    def __call__(self, func):
+        decos = getattr(func, "__pymud_decorators__", [])
+        decos.append(self)
+        func.__pymud_decorators__ = decos
+
+        return func
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__} type = {self.type} args = {self.args} kwargs = {self.kwargs}>"
+
+
+def alias(
+        patterns: Union[List[str], str], 
+        id: Optional[str] = None, 
+        group: str = "", 
+        enabled: bool = True, 
+        ignoreCase: bool = False, 
+        isRegExp: bool = True, 
+        keepEval: bool = False, 
+        expandVar: bool = True, 
+        priority: int = 100, 
+        oneShot: bool = False,  
+        *args, **kwargs):
+    """
+    使用装饰器创建一个别名（Alias）对象。被装饰的函数将在别名成功匹配时调用。
+    被装饰的函数，除第一个参数为类实例本身self之外，另外包括id, line, wildcards三个参数。
+    其中id为别名对象的唯一标识符，line为匹配的文本行，wildcards为匹配的通配符列表。
+
+    :param patterns: 别名匹配的模式。
+    :param id: 别名对象的唯一标识符，不指定时将自动生成唯一标识符。
+    :param group: 别名所属的组名，默认为空字符串。
+    :param enabled: 别名是否启用，默认为 True。
+    :param ignoreCase: 匹配时是否忽略大小写，默认为 False。
+    :param isRegExp: 模式是否为正则表达式，默认为 True。
+    :param keepEval: 若存在多个可匹配的别名时，是否持续匹配，默认为 False。
+    :param expandVar: 是否展开变量，默认为 True。
+    :param priority: 别名的优先级，值越小优先级越高，默认为 100。
+    :param oneShot: 别名是否只触发一次后自动失效，默认为 False。
+    :param args: 可变位置参数，用于传递额外的参数。
+    :param kwargs: 可变关键字参数，用于传递额外的键值对参数。
+    :return: PymudDecorator 实例，类型为 "alias"。
+    """
+    # 将传入的参数更新到 kwargs 字典中
+    kwargs.update({
+        "patterns": patterns,
+        "id": id, 
+        "group": group, 
+        "enabled": enabled, 
+        "ignoreCase": ignoreCase, 
+        "isRegExp": isRegExp, 
+        "keepEval": keepEval, 
+        "expandVar": expandVar, 
+        "priority": priority, 
+        "oneShot": oneShot})
+    
+    # 如果 id 为 None，则从 kwargs 中移除 "id" 键
+    if not id:
+        kwargs.pop("id")
+
+    return PymudDecorator("alias", *args, **kwargs)
+
+def trigger(
+        patterns: Union[List[str], str], 
+        id: Optional[str] = None, 
+        group: str = "", 
+        enabled: bool = True, 
+        ignoreCase: bool = False, 
+        isRegExp: bool = True, 
+        keepEval: bool = False, 
+        expandVar: bool = True, 
+        raw: bool = False, 
+        priority: int = 100, 
+        oneShot: bool = False,  
+        *args, **kwargs):
+    """
+    使用装饰器创建一个触发器（Trigger）对象。
+
+    :param patterns: 触发器匹配的模式。单行模式可以是字符串或正则表达式，多行模式必须是元组或列表，其中每个元素都是字符串或正则表达式。
+    :param id: 触发器对象的唯一标识符，不指定时将自动生成唯一标识符。
+    :param group: 触发器所属的组名，默认为空字符串。
+    :param enabled: 触发器是否启用，默认为 True。
+    :param ignoreCase: 匹配时是否忽略大小写，默认为 False。
+    :param isRegExp: 模式是否为正则表达式，默认为 True。
+    :param keepEval: 若存在多个可匹配的触发器时，是否持续匹配，默认为 False。
+    :param expandVar: 是否展开变量，默认为 True。
+    :param raw: 是否使用原始匹配方式，默认为 False。原始匹配方式下，不对 VT100 下的 ANSI 颜色进行解码，因此可以匹配颜色；正常匹配仅匹配文本。
+    :param priority: 触发器的优先级，值越小优先级越高，默认为 100。
+    :param oneShot: 触发器是否只触发一次后自动失效，默认为 False。
+    :param args: 可变位置参数，用于传递额外的参数。
+    :param kwargs: 可变关键字参数，用于传递额外的键值对参数。
+    :return: PymudDecorator 实例，类型为 "trigger"。
+    """
+    # 将传入的参数更新到 kwargs 字典中
+    kwargs.update({
+        "patterns": patterns,
+        "id": id, 
+        "group": group, 
+        "enabled": enabled, 
+        "ignoreCase": ignoreCase, 
+        "isRegExp": isRegExp, 
+        "keepEval": keepEval, 
+        "expandVar": expandVar, 
+        "raw": raw,
+        "priority": priority, 
+        "oneShot": oneShot})
+    if not id:
+        kwargs.pop("id")
+    return PymudDecorator("trigger", *args, **kwargs)
+
+def timer(timeout: float, id: Optional[str] = None, group: str = "", enabled: bool = True, *args, **kwargs):
+    """
+    使用装饰器创建一个定时器（Timer）对象。
+
+    :param timeout: 定时器超时时间，单位为秒。
+    :param id: 定时器对象的唯一标识符，不指定时将自动生成唯一标识符。
+    :param group: 定时器所属的组名，默认为空字符串。
+    :param enabled: 定时器是否启用，默认为 True。
+    :param args: 可变位置参数，用于传递额外的参数。
+    :param kwargs: 可变关键字参数，用于传递额外的键值对参数。
+    :return: PymudDecorator 实例，类型为 "timer"。
+    """
+    kwargs.update({
+        "timeout": timeout,
+        "id": id,
+        "group": group,
+        "enabled": enabled
+        })
+    if not id:
+        kwargs.pop("id")
+    return PymudDecorator("timer", *args, **kwargs)
+
+def gmcp(name: str, group: str = "", enabled: bool = True, *args, **kwargs):
+    """
+    使用装饰器创建一个GMCP触发器（GMCPTrigger）对象。
+
+    :param name: GMCP触发器的名称。
+    :param group: GMCP触发器所属的组名，默认为空字符串。
+    :param enabled: GMCP触发器是否启用，默认为 True。
+    :param args: 可变位置参数，用于传递额外的参数。
+    :param kwargs: 可变关键字参数，用于传递额外的键值对参数。
+    :return: PymudDecorator 实例，类型为 "gmcp"。
+    """
+    kwargs.update({
+        "id": name,
+        "group": group,
+        "enabled": enabled
+        })
+    
+    return PymudDecorator("gmcp", *args, **kwargs)

pymud/dialogs.py

@@ -1,18 +1,18 @@
 import asyncio, webbrowser
-
+from typing import Any, Callable, Iterable, List, Tuple, Union
 from prompt_toolkit.layout import AnyContainer, ConditionalContainer, Float, VSplit, HSplit, Window, WindowAlign, ScrollablePane, ScrollOffsets
 from prompt_toolkit.widgets import Button, Dialog, Label, MenuContainer, MenuItem, TextArea, SystemToolbar, Frame, RadioList 
 from prompt_toolkit.layout.dimension import Dimension, D
 from prompt_toolkit import ANSI, HTML
 from prompt_toolkit.mouse_events import MouseEvent, MouseEventType
-from prompt_toolkit.formatted_text import FormattedText
+from prompt_toolkit.formatted_text import FormattedText, AnyFormattedText
 from prompt_toolkit.application.current import get_app
 from .extras import EasternButton
 
 from .settings import Settings
 
 class BasicDialog:
-    def __init__(self, title = "", modal = True):
+    def __init__(self, title: AnyFormattedText = "", modal = True):
         self.future = asyncio.Future()
         self.dialog = Dialog(
             body = self.create_body(),
@@ -22,14 +22,14 @@ class BasicDialog:
             width = D(preferred=80),
         )
 
-    def set_done(self, result = True):
+    def set_done(self, result: Any = True):
         self.future.set_result(result)
 
     def create_body(self) -> AnyContainer:
-        return HSplit([Label(text="basic dialog")])
+        return HSplit([Label(text=Settings.gettext("basic_dialog"))])
 
     def create_buttons(self):
-        ok_button = EasternButton(text="确定", handler=(lambda: self.set_done()))
+        ok_button = EasternButton(text=Settings.gettext("ok"), handler=(lambda: self.set_done()))
         return [ok_button]
 
     def set_exception(self, exc):
@@ -47,7 +47,7 @@ class MessageDialog(BasicDialog):
         return HSplit([Label(text=self.message)])
     
 class QueryDialog(BasicDialog):
-    def __init__(self, title="", message = "", modal=True):
+    def __init__(self, title: AnyFormattedText = "", message: AnyFormattedText = "", modal = True):
         self.message = message
         super().__init__(title, modal)
 
@@ -55,17 +55,17 @@ class QueryDialog(BasicDialog):
         return HSplit([Label(text=self.message)])
     
     def create_buttons(self):
-        ok_button = EasternButton(text="确定", handler=(lambda: self.set_done(True)))
-        cancel_button = EasternButton(text="取消", handler=(lambda: self.set_done(False)))
+        ok_button = EasternButton(text=Settings.gettext("ok"), handler=(lambda: self.set_done(True)))
+        cancel_button = EasternButton(text=Settings.gettext("cancel"), handler=(lambda: self.set_done(False)))
         return [ok_button, cancel_button]
 
 class WelcomeDialog(BasicDialog):
     def __init__(self, modal=True):
         self.website = FormattedText(
-            [('', '访问 '),
+            [('', f'{Settings.gettext("visit")} '),
              #('class:b', 'GitHub:'), 
-             ('', 'https://pymud.readthedocs.org/', self.open_url),
-             ('', ' 以查看最新帮助文档')]
+             ('', Settings.__website__, self.open_url),
+             ('', f' {Settings.gettext("displayhelp")}')]
              )
         super().__init__("PYMUD", modal)
         
@@ -77,10 +77,10 @@ class WelcomeDialog(BasicDialog):
         import platform, sys
         body = HSplit([
             Window(height=1),
-            Label(HTML('<b fg="red">PYMUD {0}</b> - a MUD Client Written in Python'.format(Settings.__version__, Settings.__release__)), align=WindowAlign.CENTER),
-            Label(HTML('作者: <b>{0}</b> <b>E-mail</b>: <u>{1}</u>'.format(Settings.__author__, Settings.__email__)), align=WindowAlign.CENTER),
+            Label(HTML(Settings.gettext("appinfo", Settings.__version__, Settings.__release__)), align=WindowAlign.CENTER),
+            Label(HTML(Settings.gettext("author", Settings.__author__, Settings.__email__)), align=WindowAlign.CENTER),
             Label(self.website, align=WindowAlign.CENTER),
-            Label('系统:{} {}   Python版本:{}'.format(platform.system(), platform.version(), platform.python_version()), align = WindowAlign.CENTER),
+            Label(Settings.gettext("sysversion", platform.system(), platform.version(), platform.python_version()), align = WindowAlign.CENTER),
 
             Window(height=1),
         ])
@@ -89,25 +89,25 @@ class WelcomeDialog(BasicDialog):
 
 class NewSessionDialog(BasicDialog):
     def __init__(self):
-        super().__init__("创建新会话", True)
+        super().__init__(Settings.gettext("new_session"), True)
     
     def create_body(self) -> AnyContainer:
         body = HSplit([
             VSplit([
                 HSplit([
-                    Label(" 会话名称:"),
+                    Label(f" {Settings.gettext('sessionname')}:"),
                     Frame(body=TextArea(name = "session", text="session", multiline=False, wrap_lines=False, height = 1, dont_extend_height=True, width = D(preferred=10), focus_on_click=True, read_only=False),)
                 ]),
                 HSplit([
-                    Label(" 服务器地址:"),
+                    Label(f" {Settings.gettext('host')}:"),
                     Frame(body=TextArea(name = "host", text="mud.pkuxkx.net", multiline=False, wrap_lines=False, height = 1, dont_extend_height=True, width = D(preferred=20), focus_on_click=True, read_only=False),)
                 ]),
                 HSplit([
-                    Label(" 端口:"),
+                    Label(f" {Settings.gettext('port')}:"),
                     Frame(body=TextArea(name = "port", text="8081", multiline=False, wrap_lines=False, height = 1, dont_extend_height=True, width = D(max=8), focus_on_click=True, read_only=False),)
                 ]),
                 HSplit([
-                    Label(" 编码:"),
+                    Label(f" {Settings.gettext('encoding')}:"),
                     Frame(body=TextArea(name = "encoding", text="utf8", multiline=False, wrap_lines=False, height = 1, dont_extend_height=True, width = D(max=8), focus_on_click=True, read_only=False),)
                 ]),
             ])
@@ -116,15 +116,18 @@ class NewSessionDialog(BasicDialog):
         return body
 
     def create_buttons(self):
-        ok_button = EasternButton(text="确定", handler=self.btn_ok_clicked)
-        cancel_button = EasternButton(text="取消", handler=(lambda: self.set_done(False)))
+        ok_button = EasternButton(text=Settings.gettext("ok"), handler=self.btn_ok_clicked)
+        cancel_button = EasternButton(text=Settings.gettext("cancel"), handler=(lambda: self.set_done(False)))
         return [ok_button, cancel_button]
     
     def btn_ok_clicked(self):
-        name = get_app().layout.get_buffer_by_name("session").text
-        host = get_app().layout.get_buffer_by_name("host").text
-        port = int(get_app().layout.get_buffer_by_name("port").text)
-        encoding = get_app().layout.get_buffer_by_name("encoding").text
+        def get_text_safely(buffer_name):
+            buffer = get_app().layout.get_buffer_by_name(buffer_name)
+            return buffer.text if buffer else ""
+        name = get_text_safely("session")
+        host = get_text_safely("host")
+        port = get_text_safely("port")
+        encoding = get_text_safely("encoding")
         result = (name, host, port, encoding)
         self.set_done(result)
 
@@ -137,8 +140,8 @@ class LogSelectionDialog(BasicDialog):
         if len(values) > 0:
             self._radio_list = RadioList(values = self._selection_values)
         else:
-            self._radio_list = Label('无记录'.center(13))
-        super().__init__('选择查看的记录', modal)
+            self._radio_list = Label(Settings.gettext("nolog").center(13))
+        super().__init__(Settings.gettext("chooselog"), modal)
 
     def create_body(self) -> AnyContainer:
         body=HSplit([
@@ -148,13 +151,16 @@ class LogSelectionDialog(BasicDialog):
         return body
     
     def create_buttons(self):
-        ok_button = EasternButton(text="确定", handler=self.btn_ok_clicked)
-        cancel_button = EasternButton(text="取消", handler=(lambda: self.set_done(False)))
+        ok_button = EasternButton(text=Settings.gettext("ok"), handler=self.btn_ok_clicked)
+        cancel_button = EasternButton(text=Settings.gettext("cancel"), handler=(lambda: self.set_done(False)))
         return [ok_button, cancel_button]
     
     def btn_ok_clicked(self):
         if self._itemsCount:
-            result = self._radio_list.current_value
+            if isinstance(self._radio_list, RadioList):
+                result = self._radio_list.current_value
+            else:
+                result = None
             self.set_done(result)
         else:
             self.set_done(False)

pymud/extras.py

@@ -3,7 +3,7 @@ from unicodedata import east_asian_width
 from wcwidth import wcwidth
 import time, re, logging
 
-from typing import Iterable
+from typing import Iterable, Optional, Union, Tuple
 from prompt_toolkit import ANSI
 from prompt_toolkit.application import get_app
 from prompt_toolkit.buffer import Buffer
@@ -225,11 +225,11 @@ class SessionBuffer(Buffer):
 
     # End of <getters/setters>
 
-    def save_to_undo_stack(self, clear_redo_stack: bool = True) -> None:
-        pass
+    # def save_to_undo_stack(self, clear_redo_stack: bool = True) -> None:
+    #     pass
 
-    def delete(self, count: int = 1) -> str:
-        pass
+    # def delete(self, count: int = 1) -> str:
+    #     pass
 
     def insert_text(
         self,
@@ -291,116 +291,12 @@ class SessionBuffer(Buffer):
 
 
 class SessionBufferControl(BufferControl):
-    def __init__(self, buffer: SessionBuffer = None, input_processors = None, include_default_input_processors: bool = True, lexer: Lexer = None, preview_search: FilterOrBool = False, focusable: FilterOrBool = True, search_buffer_control = None, menu_position = None, focus_on_click: FilterOrBool = False, key_bindings: KeyBindingsBase = None):
+    def __init__(self, buffer: Optional[SessionBuffer] = None, input_processors = None, include_default_input_processors: bool = True, lexer: Optional[Lexer] = None, preview_search: FilterOrBool = False, focusable: FilterOrBool = True, search_buffer_control = None, menu_position = None, focus_on_click: FilterOrBool = False, key_bindings: Optional[KeyBindingsBase] = None):
         # 将所属Buffer类型更改为SessionBuffer
         buffer = buffer or SessionBuffer()
         super().__init__(buffer, input_processors, include_default_input_processors, lexer, preview_search, focusable, search_buffer_control, menu_position, focus_on_click, key_bindings)
         self.buffer = buffer
 
-    # def create_content(
-    #     self, width: int, height: int, preview_search: bool = False
-    # ) -> UIContent:
-    #     """
-    #     Create a UIContent.
-    #     """
-    #     buffer = self.buffer
-
-    #     # Trigger history loading of the buffer. We do this during the
-    #     # rendering of the UI here, because it needs to happen when an
-    #     # `Application` with its event loop is running. During the rendering of
-    #     # the buffer control is the earliest place we can achieve this, where
-    #     # we're sure the right event loop is active, and don't require user
-    #     # interaction (like in a key binding).
-    #     buffer.load_history_if_not_yet_loaded()
-
-    #     # Get the document to be shown. If we are currently searching (the
-    #     # search buffer has focus, and the preview_search filter is enabled),
-    #     # then use the search document, which has possibly a different
-    #     # text/cursor position.)
-    #     search_control = self.search_buffer_control
-    #     preview_now = preview_search or bool(
-    #         # Only if this feature is enabled.
-    #         self.preview_search()
-    #         and
-    #         # And something was typed in the associated search field.
-    #         search_control
-    #         and search_control.buffer.text
-    #         and
-    #         # And we are searching in this control. (Many controls can point to
-    #         # the same search field, like in Pyvim.)
-    #         get_app().layout.search_target_buffer_control == self
-    #     )
-
-    #     if preview_now and search_control is not None:
-    #         ss = self.search_state
-
-    #         document = buffer.document_for_search(
-    #             SearchState(
-    #                 text=search_control.buffer.text,
-    #                 direction=ss.direction,
-    #                 ignore_case=ss.ignore_case,
-    #             )
-    #         )
-    #     else:
-    #         document = buffer.document
-
-    #     get_processed_line = self._create_get_processed_line_func(
-    #         document, width, height
-    #     )
-    #     self._last_get_processed_line = get_processed_line
-
-    #     def translate_rowcol(row: int, col: int) -> Point:
-    #         "Return the content column for this coordinate."
-    #         return Point(x=get_processed_line(row).source_to_display(col), y=row)
-
-    #     def get_line(i: int) -> StyleAndTextTuples:
-    #         "Return the fragments for a given line number."
-    #         fragments = get_processed_line(i).fragments
-
-    #         # Add a space at the end, because that is a possible cursor
-    #         # position. (When inserting after the input.) We should do this on
-    #         # all the lines, not just the line containing the cursor. (Because
-    #         # otherwise, line wrapping/scrolling could change when moving the
-    #         # cursor around.)
-    #         fragments = fragments + [("", " ")]
-    #         return fragments
-
-    #     content = UIContent(
-    #         get_line=get_line,
-    #         line_count=document.line_count,
-    #         cursor_position=translate_rowcol(
-    #             document.cursor_position_row, document.cursor_position_col
-    #         ),
-    #     )
-
-    #     # If there is an auto completion going on, use that start point for a
-    #     # pop-up menu position. (But only when this buffer has the focus --
-    #     # there is only one place for a menu, determined by the focused buffer.)
-    #     if get_app().layout.current_control == self:
-    #         menu_position = self.menu_position() if self.menu_position else None
-    #         if menu_position is not None:
-    #             assert isinstance(menu_position, int)
-    #             menu_row, menu_col = buffer.document.translate_index_to_position(
-    #                 menu_position
-    #             )
-    #             content.menu_position = translate_rowcol(menu_row, menu_col)
-    #         elif buffer.complete_state:
-    #             # Position for completion menu.
-    #             # Note: We use 'min', because the original cursor position could be
-    #             #       behind the input string when the actual completion is for
-    #             #       some reason shorter than the text we had before. (A completion
-    #             #       can change and shorten the input.)
-    #             menu_row, menu_col = buffer.document.translate_index_to_position(
-    #                 min(
-    #                     buffer.cursor_position,
-    #                     buffer.complete_state.original_document.cursor_position,
-    #                 )
-    #             )
-    #             content.menu_position = translate_rowcol(menu_row, menu_col)
-    #         else:
-    #             content.menu_position = None
-
-    #     return content
 
     def mouse_handler(self, mouse_event: MouseEvent):
         """
@@ -414,7 +310,7 @@ class SessionBufferControl(BufferControl):
         # Focus buffer when clicked.
         cur_control = get_app().layout.current_control
         cur_buffer = get_app().layout.current_buffer
-        # 这里时修改的内容
+        # 这里是修改的内容
         if (cur_control == self) or (cur_buffer and cur_buffer.name == "input"):
             if self._last_get_processed_line:
                 processed_line = self._last_get_processed_line(position.y)
@@ -982,30 +878,6 @@ class EasternMenuContainer(MenuContainer):
 
 
 
-class MenuItem:
-    def __init__(
-        self,
-        text: str = "",
-        handler = None,
-        children = None,
-        shortcut = None,
-        disabled: bool = False,
-    ) -> None:
-        self.text = text
-        self.handler = handler
-        self.children = children or []
-        self.shortcut = shortcut
-        self.disabled = disabled
-        self.selected_item = 0
-
-    @property
-    def width(self) -> int:
-        if self.children:
-            return max(get_cwidth(c.text) for c in self.children)
-        else:
-            return 0
-
-
 class DotDict(dict):
     """
     可以通过点.访问内部key-value对的字典。此类型继承自dict。

pymud/i18n.py

@@ -0,0 +1,63 @@
+# internationalization (i18n)
+import os, importlib
+
+def i18n_ListAvailableLanguages():
+    """
+    List all available languages.
+
+    This function checks all files in the `lang` directory for files starting with `i18n.` and ending with `.py`.
+    These files represent internationalization configurations for different languages. The default language is Simplified Chinese ("chs").
+
+    Returns:
+        list: A list containing all available language codes.
+    """
+    # Define the default language list, here the default language is Simplified Chinese
+    languages = []  
+    # Define the directory where the language files are located
+    lang_dir = os.path.join(os.path.dirname(__file__), "lang")
+
+    # Check if the language directory exists. If it doesn't, return the default language list directly
+    if os.path.exists(lang_dir):
+        # Iterate through all files in the language directory
+        for filename in os.listdir(lang_dir):
+            # Check if the file starts with "i18n.", ends with ".py", and is not the default Simplified Chinese file
+            if filename.startswith("i18n_") and filename.endswith(".py"):
+                # Extract the language code from the filename, removing "i18n." and ".py"
+                language = filename[5:-3]  
+                # Add the extracted language code to the list of available languages
+                languages.append(language)
+
+    if not languages:
+        languages.append("chs")
+
+    return languages
+
+def i18n_LoadLanguage(lang: str):
+    lang_file = os.path.join(os.path.dirname(__file__), "lang", f"i18n_{lang}.py")
+    if os.path.exists(lang_file):
+        modLang = importlib.import_module(f"pymud.lang.i18n_{lang}")
+        TRANS = modLang.__dict__["TRANSLATION"]
+        if isinstance(TRANS, dict):
+            from .settings import Settings
+            Settings.text.update(TRANS["text"])
+
+            if "docstring" in TRANS.keys():
+                docstring = TRANS["docstring"]
+                if isinstance(docstring, dict):
+                    if "Session" in docstring.keys():
+                        from .session import Session
+                        docstring_class_session = docstring["Session"]
+                        if isinstance(docstring_class_session, dict):
+                            for key, newdoc in docstring_class_session.items():
+                                if hasattr(Session, key):
+                                    obj = getattr(Session, key)
+                                    obj.__doc__ = newdoc
+
+                    if "PyMudApp" in docstring.keys():
+                        from .pymud import PyMudApp
+                        docstring_class_pymudapp = docstring["PyMudApp"]
+                        if isinstance(docstring_class_pymudapp, dict):
+                            for key, newdoc in docstring_class_pymudapp.items():
+                                if hasattr(PyMudApp, key):
+                                    obj = getattr(PyMudApp, key)
+                                    obj.__doc__ = newdoc