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

pymud/logger.py

@@ -1,7 +1,7 @@
 import os, re, datetime, threading, pathlib
 from queue import SimpleQueue, Empty
 from pathlib import Path
-
+from .settings import Settings
 class Logger:
     """
     PyMUD 的记录器类型，可用于会话中向文件记录数据。记录文件保存在当前目录下的 log 子目录中
@@ -57,6 +57,10 @@ class Logger:
                     now = datetime.datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
                     filename = f"{self.name}.{now}.log"
 
+                else:
+                    raise ValueError(Settings.gettext("exception_logmode_error", self._mode))
+
+                
                 logdir = Path.cwd().joinpath('log')
                 if not logdir.exists() or not logdir.is_dir():
                     logdir.mkdir()
@@ -70,8 +74,9 @@ class Logger:
 
             else:
                 self._queue.put_nowait(None)
-                self._thread.join()
-                self._thread = None
+                if self._thread:
+                    self._thread.join()
+                    self._thread = None
                 self._closeFile()
 
             self._enabled = enabled
@@ -130,7 +135,7 @@ class Logger:
         The thread will terminate if it sees a sentinel object in the queue.
         """
         newline = True
-        while True:
+        while self._stream:
             try:
                 data = self._queue.get(block = True)
                 if data:

pymud/main.py

@@ -1,26 +1,32 @@
-import os, sys, json, platform, shutil, logging, argparse
+import os, sys, json, platform, shutil, logging, argparse, locale
 from pathlib import Path
 from .pymud import PyMudApp
 from .settings import Settings
 
 CFG_TEMPLATE = {
+    "language" : "chs",                             # 语言设置，默认为简体中文
+
     "client": {
         "buffer_lines"      : 5000,                 # 保留缓冲行数
 
         "interval"          : 10,                   # 在自动执行中，两次命令输入中的间隔时间（ms）
         "auto_connect"      : True,                 # 创建会话后，是否自动连接
         "auto_reconnect"    : False,                # 在会话异常断开之后，是否自动重连
+        "reconnect_wait"    : 15,                   # 自动重连等待的时间（秒数）
         "var_autosave"      : True,                 # 断开时自动保存会话变量
         "var_autoload"      : True,                 # 初始化时自动加载会话变量
 
-        "echo_input"        : False,
         "beautify"          : True,                 # 专门为解决控制台下PKUXKX字符画对不齐的问题
+        "history_records"   : 500, 
 
+        "status_divider"    : False,                 # 是否显示状态栏的分隔线
         "status_display"    : 1,                    # 状态窗口显示情况设置，0-不显示，1-显示在下方，2-显示在右侧
         "status_height"     : 4,                    # 下侧状态栏的高度
         "status_width"      : 30,                   # 右侧状态栏的宽度
+        
 
     },
+
     "sessions" : {
         "pkuxkx" : {
             "host" : "mud.pkuxkx.net",
@@ -41,50 +47,123 @@ CFG_TEMPLATE = {
     }
 }
 
+def detect_system_language():
+    """
+    检测系统语言，返回中文或英文"
+    """
+    lang = "chs"
+    try:
+        value = locale.getlocale()[0]
+        if value and (value.lower().startswith("zh") or value.lower().startswith("chinese")):  # 中文
+            lang = "chs"
+        else:
+            lang = "eng"
+    except Exception as e:
+        # default is chs
+        pass
+
+    return lang
+
 def init_pymud_env(args):
-    print(f"欢迎使用PyMUD, 版本{Settings.__version__}. 使用PyMUD时, 建议建立一个新目录（任意位置），并将自己的脚本以及配置文件放到该目录下.")
-    print("即将开始为首次运行初始化环境...")
-    
-    dir = args.dir
-    if dir:
-        print(f"你已经指定了创建脚本的目录为 {args.dir}")
-        dir = Path(dir)
-    else:
-        dir = Path.home().joinpath('pkuxkx')
-
-        system = platform.system().lower()
-        dir_enter = input(f"检测到当前系统为 {system}, 请指定游戏脚本的目录（若目录不存在会自动创建），直接回车表示使用默认值 [{dir}]:")
-        if dir_enter:
-            dir = Path(dir_enter)
-                      
-    if dir.exists() and dir.is_dir():
-        print(f'检测到给定目录 {dir} 已存在，切换至此目录...')
-    else:
-        print(f'检测到给定目录 {dir} 不存在，正在创建并切换至目录...')
-        dir.mkdir()
-    
-    os.chdir(dir)
+    system = "unknown"
+    lang = detect_system_language()
+    if lang == "chs":
+        print(f"欢迎使用PyMUD, 版本{Settings.__version__}. 使用PyMUD时, 建议建立一个新目录（任意位置），并将自己的脚本以及配置文件放到该目录下.")
+        print("即将开始为首次运行初始化环境...")
+        
+        dir = args.dir
+        if dir:
+            if dir == ".":
+                dir_msg = "当前目录"
+            else:
+                dir_msg = f": {dir}"
+            print(f"你已经指定了创建脚本的目录为{dir_msg}")
+            dir = Path(dir)
+        else:
+            dir = Path.home().joinpath('pkuxkx')
+
+            system = platform.system().lower()
+            dir_enter = input(f"检测到当前系统为 {system}, 请指定游戏脚本的目录（若目录不存在会自动创建），直接回车表示使用默认值 [{dir}]:")
+            if dir_enter:
+                dir = Path(dir_enter)
+                        
+        if dir.exists() and dir.is_dir():
+            print(f'检测到给定目录 {dir} 已存在，切换至此目录...')
+        else:
+            print(f'检测到给定目录 {dir} 不存在，正在创建并切换至目录...')
+            dir.mkdir()
+        
+        os.chdir(dir)
 
-    if os.path.exists('pymud.cfg'):
-        print(f'检测到脚本目录下已存在pymud.cfg文件，将直接使用此文件进入PyMUD...')
-    else:
-        print(f'检测到脚本目录下不存在pymud.cfg文件，将使用默认内容创建该配置文件...')
-        with open('pymud.cfg', mode = 'x') as fp:
-            fp.writelines(json.dumps(CFG_TEMPLATE, indent = 4))
-
-    if not os.path.exists('examples.py'):
-        from pymud import pkuxkx
-        module_dir = pkuxkx.__file__
-        shutil.copyfile(module_dir, 'examples.py')
-        print(f'已将样例脚本拷贝至脚本目录，并加入默认配置文件')
-
-    print(f"后续可自行修改 {dir} 目录下的 pymud.cfg 文件以进行配置。")
-    if system == "windows":
-        print(f"后续运行PyMUD， 请在 {dir} 目录下键入命令： python -m pymud")
-    else:
-        print(f"后续运行PyMUD， 请在 {dir} 目录下键入命令： python3 -m pymud")
+        if os.path.exists('pymud.cfg'):
+            print(f'检测到脚本目录下已存在pymud.cfg文件，将直接使用此文件进入PyMUD...')
+        else:
+            print(f'检测到脚本目录下不存在pymud.cfg文件，将使用默认内容创建该配置文件...')
+            with open('pymud.cfg', mode = 'x') as fp:
+                fp.writelines(json.dumps(CFG_TEMPLATE, indent = 4))
+
+        if not os.path.exists('examples.py'):
+            from pymud import pkuxkx
+            module_dir = pkuxkx.__file__
+            shutil.copyfile(module_dir, 'examples.py')
+            print(f'已将样例脚本拷贝至脚本目录，并加入默认配置文件')
+
+        print(f"后续可自行修改 {dir} 目录下的 pymud.cfg 文件以进行配置。")
+        if system == "windows":
+            print(f"后续运行PyMUD， 请在 {dir} 目录下键入命令： python -m pymud，或直接使用快捷命令 pymud")
+        else:
+            print(f"后续运行PyMUD， 请在 {dir} 目录下键入命令： python3 -m pymud，或直接使用快捷命令 pymud")
 
-    input('所有内容已初始化完毕, 请按回车进入PyMUD.')
+        input('所有内容已初始化完毕, 请按回车进入PyMUD.')
+
+    else:
+        print(f"Welcome to PyMUD, version {Settings.__version__}. When using pymud, it is suggested that a new folder should be created (in any place), and the cfg configuration and all the scripts have been placed in the directory.")
+        print("Starting to initialize the environment for the first time...")
+        dir = args.dir
+        if dir:
+            if dir == ".":
+                dir_msg = "current directory"
+            else:
+                dir_msg = f": {dir}"
+            print(f"You have specified the directory to create the script as {dir_msg}")
+            dir = Path(dir)
+        else:
+            dir = Path.home().joinpath('pkuxkx')
+
+            system = platform.system().lower()
+            dir_enter = input(f"Detected the current system is {system}, please specify the directory of the game script (if the directory does not exist, it will be automatically created), press Enter to use the default value [{dir}]:")
+            if dir_enter:
+                dir = Path(dir_enter)
+                        
+        if dir.exists() and dir.is_dir():
+            print(f'Detected that the given directory {dir} already exists, switching to this directory...')
+        else:
+            print(f'Detected that the given directory {dir} does not exist, creating and switching to the directory...')
+            dir.mkdir()
+        
+        os.chdir(dir)
+
+        if os.path.exists('pymud.cfg'):
+            print(f'Detected that the pymud.cfg file already exists in the script directory, entering PyMUD directly using this file...')
+        else:
+            print(f'Detected that the pymud.cfg file does not exist in the script directory, creating the configuration file using the default content...')
+            with open('pymud.cfg', mode = 'x') as fp:
+                CFG_TEMPLATE["language"] = "eng"
+                fp.writelines(json.dumps(CFG_TEMPLATE, indent = 4))
+
+        if not os.path.exists('examples.py'):
+            from pymud import pkuxkx
+            module_dir = pkuxkx.__file__
+            shutil.copyfile(module_dir, 'examples.py')
+            print(f'The sample script has been copied to the script directory and added to the default configuration file')
+
+        print(f"Afterwards, you can modify the pymud.cfg file in the {dir} directory for configuration.")
+        if system == "windows":
+            print(f"Afterwards, please type the command 'python -m pymud' in the {dir} directory to run PyMUD, or use the shortcut command pymud")
+        else:
+            print(f"Afterwards, please type the command 'python3 -m pymud' in the {dir} directory to run PyMUD, or use the shortcut command pymud")
+
+        input('Press Enter to enter PyMUD.')
 
     startApp(args)
 
@@ -123,7 +202,7 @@ def main():
     subparsers = parser.add_subparsers(help = 'init用于初始化运行环境')
 
     par_init = subparsers.add_parser('init', description = '初始化pymud运行环境, 包括建立脚本目录, 创建默认配置文件, 创建样例脚本等.')
-    par_init.add_argument('-d', '--dir', dest = 'dir', metavar = 'dir', type = str, default = '', help = '指定构建脚本目录的名称, 不指定时会根据操作系统选择不同默认值')
+    par_init.add_argument('-d', '--dir', dest = 'dir', metavar = 'dir', type = str, default = '.', help = '指定构建脚本目录的名称, 不指定时会根据操作系统选择不同默认值')
     par_init.set_defaults(func = init_pymud_env)
 
     parser.add_argument('-d', '--debug', dest = 'debug', action = 'store_true', default = False, help = '指定以调试模式进入PyMUD。此时，系统log等级将设置为logging.NOTSET, 所有log数据均会被记录。默认不启用。')

pymud/modules.py

@@ -1,9 +1,21 @@
 
-import importlib, importlib.util
-from abc import ABC, ABCMeta
+import importlib, importlib.util, traceback
 from typing import Any
-from .objects import BaseObject, Command
+from .settings import Settings
+from .extras import DotDict
+from .decorators import exception, async_exception, PymudDecorator, print_exception
 
+class PymudMeta(type):
+    def __new__(cls, name, bases, attrs):
+        decorator_funcs = {}
+        for name, value in attrs.items():
+            if hasattr(value, "__pymud_decorators__"):
+                decorator_funcs[value.__name__] = getattr(value, "__pymud_decorators__", [])
+                
+        attrs["_decorator_funcs"] = decorator_funcs
+
+        return super().__new__(cls, name, bases, attrs)
+    
 class ModuleInfo:
     """
     模块管理类。对加载的模块文件进行管理。该类型由Session类进行管理，无需人工创建和干预。
@@ -15,7 +27,9 @@ class ModuleInfo:
 
     """
     def __init__(self, module_name: str, session):
-        self.session = session
+        from .session import Session
+        if isinstance(session, Session):
+            self.session = session
         self._name = module_name 
         self._ismainmodule = False
         self.load()
@@ -33,14 +47,19 @@ class ModuleInfo:
                 if (attr_name == "Configuration") or issubclass(attr, IConfig):
                     try:
                         self._config[f"{self.name}.{attr_name}"] = attr(self.session, reload = reload)
-                        self.session.info(f"配置对象 {self.name}.{attr_name} {'重新' if reload else ''}创建成功.")
+                        if not reload:
+                            self.session.info(Settings.gettext("configuration_created", self.name, attr_name))
+                        else:
+                            self.session.info(Settings.gettext("configuration_recreated", self.name, attr_name))
+
                     except Exception as e:
                         result = False
-                        self.session.error(f"配置对象 {self.name}.{attr_name} 创建失败. 错误信息为: {e}")
+                        self.session.error(Settings.gettext("configuration_fail", self.name, attr_name, e))
         self._ismainmodule = (self._config != {})
         return result
     
     def _unload(self):
+        from .objects import BaseObject, Command
         for key, config in self._config.items():
             if isinstance(config, Command):
                 # Command 对象在从会话中移除时，自动调用其 unload 系列方法，因此不能产生递归
@@ -65,21 +84,21 @@ class ModuleInfo:
     def load(self):
         "加载模块内容"
         if self._load():
-            self.session.info(f"{'主' if self.ismainmodule else '从'}配置模块 {self.name} 加载完成.")
+            self.session.info(f"{Settings.gettext('entity_module' if self.ismainmodule else 'non_entity_module')} {self.name} {Settings.gettext('load_ok')}")
         else:
-            self.session.error(f"{'主' if self.ismainmodule else '从'}配置模块 {self.name} 加载失败.")
+            self.session.info(f"{Settings.gettext('entity_module' if self.ismainmodule else 'non_entity_module')} {self.name} {Settings.gettext('load_fail')}")
 
     def unload(self):
         "卸载模块内容"
         self._unload()
         self._loaded = False
-        self.session.info(f"{'主' if self.ismainmodule else '从'}配置模块 {self.name} 卸载完成.")
+        self.session.info(f"{Settings.gettext('entity_module' if self.ismainmodule else 'non_entity_module')} {self.name} {Settings.gettext('unload_ok')}")
 
     def reload(self):
         "模块文件更新后调用，重新加载已加载的模块内容"
         self._unload()
         self._load(reload = True)
-        self.session.info(f"{'主' if self.ismainmodule else '从'}配置模块 {self.name} 重新加载完成.")
+        self.session.info(f"{Settings.gettext('entity_module' if self.ismainmodule else 'non_entity_module')} {self.name} {Settings.gettext('reload_ok')}")
 
     @property
     def name(self):
@@ -101,22 +120,69 @@ class ModuleInfo:
         "只读属性，区分是否主模块（即包含具体config的模块）"
         return self._ismainmodule
 
-class IConfig(metaclass = ABCMeta):
+class IConfigBase(metaclass = PymudMeta):
     """
-    用于提示PyMUD应用是否自动创建该配置类型的基础类（模拟接口）。
-    
-    继承 IConfig 类型让应用自动管理该类型，唯一需要的是，构造函数中，仅存在一个必须指定的参数 Session。
-
-    在应用自动创建 IConfig 实例时，除 session 参数外，还会传递一个 reload 参数 （bool类型），表示是首次加载还是重新加载特性。
-    可以从kwargs 中获取该参数，并针对性的设计相应代码。例如，重新加载相关联的其他模块等。
+    用于支持对装饰器写法对象进行管理的基础类。
+    该类型相当于原来的IConfig类，唯一区别时，模块加载时，不会对本类型创建实例对象。
+    主要用于对插件中定义的Command提供装饰器写法支持，因为这些Command是在会话构建时创建，因此不能在模块加载时自动创建，也就不能继承自IConfig。
     """
     def __init__(self, session, *args, **kwargs):
-        self.session = session
+        from .session import Session
+        from .objects import Alias, Trigger, Timer, GMCPTrigger
+        if isinstance(session, Session):
+            self.session = session
+        self.__inline_objects__ = DotDict()
+
+        if hasattr(self, "_decorator_funcs"):
+            deco_funcs = getattr(self, "_decorator_funcs")
+            for func_name, decorators in deco_funcs.items():
+                func = getattr(self, func_name)
+                for deco in decorators:
+                    if isinstance(deco, PymudDecorator):
+                        if deco.type == "alias":
+                            #patterns = deco.kwargs.pop("patterns")
+                            ali = Alias(self.session, *deco.args, **deco.kwargs, onSuccess = func)
+                            self.__inline_objects__[ali.id] = ali
+                        
+                        elif deco.type == "trigger":
+                            #patterns = deco.kwargs.pop("patterns")
+                            tri = Trigger(self.session, *deco.args, **deco.kwargs, onSuccess = func)
+                            self.__inline_objects__[tri.id] = tri
+
+                        elif deco.type == "timer":
+                            tim = Timer(self.session, *deco.args, **deco.kwargs, onSuccess = func)
+                            self.__inline_objects__[tim.id] = tim
+
+                        elif deco.type == "gmcp":
+                            gmcp = GMCPTrigger(self.session, name = deco.kwargs.get("id"), *deco.args, **deco.kwargs, onSuccess = func)
+                            self.__inline_objects__[gmcp.id] = gmcp
 
     def __unload__(self):
+        from .objects import BaseObject
         if self.session:
-            self.session.delObject(self)
+            self.session.delObjects(self.__inline_objects__)
+            if isinstance(self, BaseObject):
+                self.session.delObject(self)
 
+    @property
+    def objs(self) -> DotDict:
+        "返回内联自动创建的对象字典"
+        return self.__inline_objects__
+    
+    def obj(self, obj_id: str):
+        "根据对象ID返回内联自动创建的对象"
+        return self.__inline_objects__.get(obj_id, None) # type: ignore
+
+class IConfig(IConfigBase):
+    """
+    用于提示PyMUD应用是否自动创建该配置类型的基础类。
+    
+    继承 IConfig 类型让应用自动管理该类型，唯一需要的是，构造函数中，仅存在一个必须指定的参数 Session。
+
+    在应用自动创建 IConfig 实例时，除 session 参数外，还会传递一个 reload 参数 （bool类型），表示是首次加载还是重新加载特性。
+    可以从kwargs 中获取该参数，并针对性的设计相应代码。例如，重新加载相关联的其他模块等。
+    """
+        
 class Plugin:
     """
     插件管理类。对加载的插件文件进行管理。该类型由PyMudApp进行管理，无需人工创建。
@@ -137,17 +203,17 @@ class Plugin:
         "加载/重新加载插件对象"
         #del self.modspec, self.mod
         self.modspec = importlib.util.spec_from_file_location(self._plugin_file[:-3], self._plugin_loc)
-        self.mod     = importlib.util.module_from_spec(self.modspec)
-        self.modspec.loader.exec_module(self.mod)
+        if self.modspec and self.modspec.loader:
+            self.mod     = importlib.util.module_from_spec(self.modspec)
+            self.modspec.loader.exec_module(self.mod)
         
-        # self._app_init = self.mod.__dict__["PLUGIN_PYMUD_START"]
-        # self._session_create = self.mod.__dict__["PLUGIN_SESSION_CREATE"]
-        # self._session_destroy = self.mod.__dict__["PLUGIN_SESSION_DESTROY"]
-        # self._app_destroy = self.mod.__dict__["PLUGIN_PYMUD_DESTROY"]
-        self._app_init = self._load_mod_function("PLUGIN_PYMUD_START")
-        self._session_create = self._load_mod_function("PLUGIN_SESSION_CREATE")
-        self._session_destroy = self._load_mod_function("PLUGIN_SESSION_DESTROY")
-        self._app_destroy = self._load_mod_function("PLUGIN_PYMUD_DESTROY")
+            self._app_init = self._load_mod_function("PLUGIN_PYMUD_START")
+            self._session_create = self._load_mod_function("PLUGIN_SESSION_CREATE")
+            self._session_destroy = self._load_mod_function("PLUGIN_SESSION_DESTROY")
+            self._app_destroy = self._load_mod_function("PLUGIN_PYMUD_DESTROY")
+
+        else:
+            raise FileNotFoundError(Settings.gettext("exception_plugin_file_not_found", self._plugin_file))
         
     def _load_mod_function(self, func_name):
         # 定义一个默认函数，当插件文件中未定义指定名称的函数时，返回该函数
@@ -191,7 +257,11 @@ class Plugin:
 
         :param session: 新创建的会话对象实例
         """
-        self._session_create(session)
+        try:
+            self._session_create(session)
+        except Exception as e:
+            print_exception(session, e)
+            
 
     def onSessionDestroy(self, session):
         """
@@ -199,7 +269,10 @@ class Plugin:
 
         :param session: 所关闭的会话对象实例
         """
-        self._session_destroy(session)
+        try:
+            self._session_destroy(session)
+        except Exception as e:
+            print_exception(session, e)
 
     def onAppDestroy(self, app):
         """