pymud 0.20.0a4__py3-none-any.whl → 0.20.1__py3-none-any.whl

pymud/session.py

@@ -4,10 +4,11 @@ from collections import OrderedDict
 import logging, queue
 from logging import FileHandler
 from logging.handlers import QueueHandler, QueueListener
-
+from wcwidth import wcswidth, wcwidth
 from .logger import Logger
-from .extras import SessionBuffer, DotDict, Plugin
+from .extras import SessionBuffer, DotDict
 from .protocol import MudClientProtocol
+from .modules import ModuleInfo
 from .objects import BaseObject, Trigger, Alias, Command, Timer, SimpleAlias, SimpleTrigger, SimpleTimer, GMCPTrigger, CodeBlock, CodeLine
 from .settings import Settings
 
@@ -99,6 +100,7 @@ class Session:
         "ig"  : "ignore",
         "t+"  : "ignore",
         "t-"  : "ignore",
+        "show": "test",
     }
 
     def __init__(self, app, name, host, port, encoding = None, after_connect = None, loop = None, **kwargs):
@@ -256,11 +258,6 @@ class Session:
         if self.connected:
             self.write_eof()
 
-            # 两次保存，删掉一次
-            # # 断开时自动保存变量数据
-            # if Settings.client["var_autosave"]:
-            #     self.handle_save()
-
     def onDisconnected(self, protocol):
         "当从服务器连接断开时执行的操作。包括保存变量(若设置)、打印断开时间、执行自定义事件(若设置)等。"
         # 断开时自动保存变量数据
@@ -562,7 +559,7 @@ class Session:
 
         半数的数量由 Settings.client['buffer_lines'] 确定，默认为5000行。
         """
-        if (self._line_count >= 2 * Settings.client["buffer_lines"]) and self.buffer.document.is_cursor_at_the_end:
+        if (Settings.client["buffer_lines"] > 0) and (self._line_count >= 2 * Settings.client["buffer_lines"]) and self.buffer.document.is_cursor_at_the_end:
             self._line_count = self.buffer.clear_half()
 
     def feed_data(self, data) -> None:
@@ -657,24 +654,25 @@ class Session:
         self.display_line = raw_line
 
         if not self._ignore:
-            all_tris = list(self._triggers.values())
+            # 修改实现，形成列表时即排除非使能状态触发器，加快响应速度
+            #all_tris = list(self._triggers.values())
+            all_tris = [tri for tri in self._triggers.values() if isinstance(tri, Trigger) and tri.enabled]
             all_tris.sort(key = lambda tri: tri.priority)
 
             for tri in all_tris:
-                if isinstance(tri, Trigger) and tri.enabled:
-                    if tri.raw:
-                        state = tri.match(raw_line, docallback = True)
-                    else:
-                        state = tri.match(tri_line, docallback = True)
+                if tri.raw:
+                    state = tri.match(raw_line, docallback = True)
+                else:
+                    state = tri.match(tri_line, docallback = True)
 
-                    if state.result == Trigger.SUCCESS:
-                        if tri.oneShot:                     # 仅执行一次的trigger，匹配成功后，删除该Trigger（从触发器列表中移除）
-                            self._triggers.pop(tri.id)
+                if state.result == Trigger.SUCCESS:
+                    if tri.oneShot:                     # 仅执行一次的trigger，匹配成功后，删除该Trigger（从触发器列表中移除）
+                        self._triggers.pop(tri.id)
 
-                        if not tri.keepEval:                # 非持续匹配的trigger，匹配成功后停止检测后续Trigger
-                            break
-                        else:
-                            pass
+                    if not tri.keepEval:                # 非持续匹配的trigger，匹配成功后停止检测后续Trigger
+                        break
+                    else:
+                        pass
 
         # 将数据写入缓存添加到此处
         if len(self.display_line) > 0:
@@ -768,7 +766,7 @@ class Session:
             lines = line.split(self.seperator)
             for ln in lines:
                 if Settings.client["echo_input"]:
-                    self.writetobuffer(f"\x1b[32m{ln}\x1b[0m")
+                    self.writetobuffer(f"\x1b[32m{ln}\x1b[0m", True)
                 else:
                     self.log.log(f"\x1b[32m{ln}\x1b[0m\n")
 
@@ -777,7 +775,7 @@ class Session:
                 
         else:
             if Settings.client["echo_input"]:
-                self.writetobuffer(f"\x1b[32m{line}\x1b[0m")
+                self.writetobuffer(f"\x1b[32m{line}\x1b[0m", True)
             else:
                 self.log.log(f"\x1b[32m{line}\x1b[0m\n")
 
@@ -808,7 +806,7 @@ class Session:
         return await awaitable
 
     def exec(self, cmd: str, name = None, *args, **kwargs):
-        """
+        r"""
         在名称为name的会话中使用exec_command执行MUD命令。当不指定name时，在当前会话中执行。
 
         - exec 与 writeline 都会向服务器写入数据。其差异在于，exec执行的内容，会先经过Alias处理和Command处理，实际向远程发送内容与cmd可以不一致。
@@ -1284,6 +1282,8 @@ class Session:
         """
         从会话中移除一个对象，可直接删除 Alias, Trigger, GMCPTrigger, Command, Timer 或它们的子类本身
         
+        ** 注 ** 现在 delObject 和 delObjects 使用结果相同，都可以清除单个对象、对个对象的list, tuple或dict, 可以有效防止代码写错
+
         :param obj: 要删除的多个特定对象组成的元组、列表或者字典，可以为 Alias, Trigger, GMCPTrigger, Command, Timer 或其子类
 
         示例:
@@ -1320,10 +1320,15 @@ class Session:
         elif isinstance(obj, GMCPTrigger):
             self._gmcp.pop(obj.id, None)
 
+        elif isinstance(obj, (list, tuple, dict)):
+            self.delObjects(obj)
+
     def delObjects(self, objs):
         """
         从会话中移除一组对象，可直接删除多个 Alias, Trigger, GMCPTrigger, Command, Timer
         
+        ** 注 ** 现在 delObject 和 delObjects 使用结果相同，都可以清除单个对象、对个对象的list, tuple或dict, 可以有效防止代码写错
+
         :param objs: 要删除的一组对象的元组、列表或者字典(保持兼容性)，其中对象可以为 Alias, Trigger, GMCPTrigger, Command, Timer 或它们的子类
 
         示例:
@@ -1355,6 +1360,9 @@ class Session:
             for key, item in objs.items():
                 self.delObject(item)
 
+        elif isinstance(objs, BaseObject):
+            self.delObject(objs)
+
     def addAliases(self, alis):
         """
         向会话中增加多个别名
@@ -1956,7 +1964,7 @@ class Session:
                 else:
                     vars_simple[k] = v
 
-            width = self.application.get_width()
+            width = self.application.get_width() - 2        # 保留2个字符，防止 > 导致换行
             
             title = f"  VARIABLE LIST IN SESSION {self.name}  "
             left = (width - len(title)) // 2
@@ -1964,6 +1972,7 @@ class Session:
             self.writetobuffer("="*left + title + "="*right, newline = True)
             
             # print vars in simple, 每个变量占40格，一行可以多个变量
+            # 这里可以考虑调整一下，默认40, 但如果一个变量值太长，则选择占两个位置
             var_count = len(vars_simple)
             var_per_line = (width - 2) // 40
             lines = math.ceil(var_count / var_per_line)
@@ -1979,14 +1988,18 @@ class Session:
                 self.writetobuffer(" " * left_space)
                 line_vars = var_keys[start:end]
                 for var in line_vars:
-                    self.writetobuffer("{0:>18} = {1:<19}".format(var, vars_simple[var].__repr__()))
+                    repr = vars_simple[var].__repr__()
+                    vwidth = 22 - (wcswidth(repr) - len(repr))
+                    self.writetobuffer("{0} = {1}".format(var.rjust(20), repr.ljust(vwidth)))
+                    #self.writetobuffer("{0:>18} = {1:<19}".format(var, vars_simple[var].__repr__()))
 
                 self.writetobuffer("", newline = True)
 
             # print vars in complex, 每个变量占1行
-            for k, v in vars_complex.items():
+            var_keys = sorted(vars_complex.keys())
+            for key in var_keys:
                 self.writetobuffer(" " * left_space)
-                self.writetobuffer("{0:>18} = {1}".format(k, v.__repr__()), newline = True)
+                self.writetobuffer("{0:>20} = {1}".format(key, vars_complex[key].__repr__()), newline = True)
 
             self.writetobuffer("="*width, newline = True)
 
@@ -2039,7 +2052,7 @@ class Session:
                 else:
                     vars_simple[k] = v
 
-            width = self.application.get_width()
+            width = self.application.get_width() - 2        # 保留2个字符，防止 > 导致换行
             
             title = f" GLOBAL VARIABLES LIST "
             left = (width - len(title)) // 2
@@ -2062,21 +2075,23 @@ class Session:
                 self.writetobuffer(" " * left_space)
                 line_vars = var_keys[start:end]
                 for var in line_vars:
-                    self.writetobuffer("{0:>18} = {1:<19}".format(var, vars_simple[var].__repr__()))
+                    repr = vars_simple[var].__repr__()
+                    vwidth = 22 - (wcswidth(repr) - len(repr))
+                    self.writetobuffer("{0} = {1}".format(var.rjust(20), repr.ljust(vwidth)))
 
                 self.writetobuffer("", newline = True)
 
             # print vars in complex, 每个变量占1行
             for k, v in vars_complex.items():
                 self.writetobuffer(" " * left_space)
-                self.writetobuffer("{0:>18} = {1}".format(k, v.__repr__()), newline = True)
+                self.writetobuffer("{0:>20} = {1}".format(k, v.__repr__()), newline = True)
 
             self.writetobuffer("="*width, newline = True)
 
         elif len(args) == 1:
             var = args[0]
             if var in self.application.globals.keys():
-                self.info("{0:>18} = {1:<19}".format(var, self.application.get_globals(var).__repr__()), "全局变量")
+                self.info("{0:>20} = {1:<22}".format(var, self.application.get_globals(var).__repr__()), "全局变量")
             else:
                 self.info("全局空间不存在名称为 {} 的变量".format(var), "全局变量")
             
@@ -2151,7 +2166,7 @@ class Session:
                             self.info("创建Timer {} 成功: {}".format(ti.id, ti.__repr__()))
 
     def handle_alias(self, code: CodeLine = None, *args, **kwargs):
-        """
+        r"""
         嵌入命令 #alias / #ali 的执行函数，操作别名。该命令可以不带参数、带一个参数或者两个参数。
         该函数不应该在代码中直接调用。
 
@@ -2541,6 +2556,7 @@ class Session:
         self._variables.clear()
         self._tasks.clear()
 
+
     def load_module(self, module_names):
         """
         模块加载函数。
@@ -2564,33 +2580,12 @@ class Session:
         "加载指定名称模块"
         try:
             if module_name not in self._modules.keys():
-                mod = importlib.import_module(module_name)
-                if hasattr(mod, 'Configuration'):
-                    config = mod.Configuration(self)
-                    self._modules[module_name] = {"module": mod, "config": config}
-                    self.info(f"主配置模块 {module_name} 加载完成.")
-                else:
-                    self._modules[module_name] = {"module": mod, "config": None}
-                    self.info(f"子配置模块 {module_name} 加载完成.")
+                self._modules[module_name] = ModuleInfo(module_name, self)
 
             else:
-                mod = self._modules[module_name]["module"]
-                config = self._modules[module_name]["config"]
-                if config: 
-                    if hasattr(config, "__unload__") or hasattr(config, "unload"):
-                        unload = getattr(config, "__unload__", None) or getattr(config, "unload", None)
-                        if callable(unload):
-                            unload()
-
-                    del config
-                mod = importlib.reload(mod)
-                if hasattr(mod, 'Configuration'):
-                    config = mod.Configuration(self)
-                    self._modules[module_name] = {"module": mod, "config": config}
-                    self.info(f"主配置模块 {module_name} 重新加载完成.")
-                else:
-                    self._modules[module_name] = {"module": mod, "config": None}
-                    self.info(f"子配置模块 {module_name} 重新加载完成.")
+                mod = self._modules[module_name]
+                if isinstance(mod, ModuleInfo):
+                    mod.reload()
 
         except Exception as e:
             import traceback
@@ -2618,18 +2613,9 @@ class Session:
     def _unload_module(self, module_name):
         "卸载指定名称模块。卸载支持需要模块的Configuration实现 __unload__ 或 unload 方法"
         if module_name in self._modules.keys():
-            mod = self._modules[module_name]["module"]
-            config = self._modules[module_name]["config"]
-            if config: 
-                if hasattr(config, "__unload__") or hasattr(config, "unload"):
-                    unload = getattr(config, "__unload__", None) or getattr(config, "unload", None)
-                    if callable(unload):
-                        unload()
-
-                del config
-            del mod
-            self._modules.pop(module_name)
-            self.info(f"配置模块 {module_name} 已成功卸载.")
+            mod = self._modules.pop(module_name)
+            if isinstance(mod, ModuleInfo):
+                mod.unload()
 
         else:
             self.warning(f"指定模块名称 {module_name} 并未加载.")
@@ -2643,9 +2629,9 @@ class Session:
         :param module_names: 要重新加载的模块清单。为元组/列表时，卸载指定名称的系列模块，当名称为字符串时，卸载单个模块。当不指定时，重新加载所有已加载模块。
         """
         if module_names is None:
-            self.clean()
-            mods = list(self._modules.keys())
-            self.load_module(mods)
+            for name, module in self._modules.items():
+                if isinstance(module, ModuleInfo):
+                    module.reload()
 
             self.info(f"所有配置模块全部重新加载完成.")
 
@@ -2653,14 +2639,17 @@ class Session:
             for mod in module_names:
                 mod = mod.strip()
                 if mod in self._modules.keys():
-                    self.load_module(mod)
+                    module = self._modules[mod]
+                    if isinstance(module, ModuleInfo):
+                        module.reload()
                 else:
                     self.warning(f"指定模块名称 {mod} 并未加载，无法重新加载.")
 
         elif isinstance(module_names, str):
             if module_names in self._modules.keys():
-                mod = module_names.strip()
-                self.load_module(mod)
+                module = self._modules[module_names]
+                if isinstance(module, ModuleInfo):
+                    module.reload()
             else:
                 self.warning(f"指定模块名称 {module_names} 并未加载，无法重新加载.")
         
@@ -2744,7 +2733,7 @@ class Session:
 
                 elif mod in self.plugins.keys():
                     self.application.reload_plugin(self.plugins[mod])
-
+                    self.info(f'插件 {mod} 重新加载完成！')
                 else:
                     self.warning(f"指定名称 {mod} 既未找到模块，也未找到插件，重新加载失败..")
 
@@ -2798,12 +2787,29 @@ class Session:
             - #reload
         '''
 
-        count = len(self._modules.keys())
-        if count == 0:
-            self.info("当前会话并未加载任何模块。", "MODULES")
-        else:
-            self.info(f"当前会话已加载 {count} 个模块，包括（按加载顺序排列）：{list(self._modules.keys())}", "MODULES")
+        args = code.code[2:]
+        
+        if len(args) == 0:
+            count = len(self._modules.keys())
+            if count == 0:
+                self.info("当前会话并未加载任何模块。", "MODULES")
+            else:
+                self.info(f"当前会话已加载 {count} 个模块，包括（按加载顺序排列）：{list(self._modules.keys())}", "MODULES")
     
+        elif len(args) >= 1:
+            modules = ",".join(args).split(",")
+            for mod in modules:
+                if mod in self._modules.keys():
+                    module = self._modules[mod]
+                    if isinstance(module, ModuleInfo):
+                        if module.ismainmodule:
+                            self.info(f"模块 {module.name} 中包含的配置包括: {', '.join(module.config.keys())}")
+                        else:
+                            self.info(f"模块 {module.name} 为子模块，不包含配置。")
+
+                else:
+                    self.info(f"本会话中不存在指定名称 {mod} 的模块，可能是尚未加载到本会话中")
+
     def handle_reset(self, code: CodeLine = None, *args, **kwargs):
         '''
         嵌入命令 #reset 的执行函数，复位全部脚本。该命令不带参数。
@@ -2823,7 +2829,8 @@ class Session:
 
     def handle_save(self, code: CodeLine = None, *args, **kwargs):
         '''
-        嵌入命令 #save 的执行函数，保存当前会话变量（系统变量除外）至文件。该命令不带参数。
+        嵌入命令 #save 的执行函数，保存当前会话变量（系统变量和临时变量除外）至文件。该命令不带参数。
+        系统变量包括 %line, %copy 和 %raw 三个，临时变量是指变量名已下划线开头的变量
         该函数不应该在代码中直接调用。
 
         使用:
@@ -2844,10 +2851,10 @@ class Session:
         with open(file, "wb") as fp:
             saved = dict()
             saved.update(self._variables)
-            # keys = list(saved.keys())
-            # for key in keys:
-            #     if key.startswith("%"):
-            #         saved.pop(key)
+            keys = list(saved.keys())
+            for key in keys:
+                if key.startswith("_"):
+                    saved.pop(key)
             saved.pop("%line", None)
             saved.pop("%raw", None)
             saved.pop("%copy", None)
@@ -2867,19 +2874,26 @@ class Session:
 
     def handle_test(self, code: CodeLine = None, *args, **kwargs):
         '''
-        嵌入命令 #test 的执行函数，触发器测试命令。类似于zmud的#show命令。
+        嵌入命令 #test / #show 的执行函数，触发器测试命令。类似于zmud的#show命令。
         该函数不应该在代码中直接调用。
 
         使用:
-            - #test {some_text}: 测试服务器收到{some_text}时的触发器响应情况
+            - #test {some_text}: 测试服务器收到{some_text}时的触发器响应情况。此时，触发器不会真的响应。
+            - #tt {some_test}: 与#test 的差异是，若存在匹配的触发器，无论其是否被使能，该触发器均会实际响应。
 
         示例:
-            - ``#test 你深深吸了口气，站了起来。`` ： 模拟服务器收到“你深深吸了口气，站了起来。”时的情况进行触发测试
+            - ``#test 你深深吸了口气，站了起来。`` ： 模拟服务器收到“你深深吸了口气，站了起来。”时的情况进行触发测试（仅显示触发测试情况）
             - ``#test %copy``: 复制一句话，模拟服务器再次收到复制的这句内容时的情况进行触发器测试
+            - ``#test 你深深吸了口气，站了起来。`` ： 模拟服务器收到“你深深吸了口气，站了起来。”时的情况进行触发测试（会实际导致触发器动作）
 
         注意:
-            - #test命令测试触发器时，enabled为False的触发器不会响应。
+            - #test命令测试触发器时，触发器不会真的响应。
+            - #tt命令测试触发器时，触发器无论是否使能，均会真的响应。
         '''
+        cmd = code.code[1].lower()
+        docallback = False
+        if cmd == "test":
+            docallback = True
 
         new_cmd_text, new_code = code.expand(self, *args, **kwargs)
         line = new_cmd_text[6:]       # 取出#test 之后的所有内容
@@ -2890,32 +2904,82 @@ class Session:
             lines = []
             lines.append(line)
 
+        info_all = []
+        info_enabled = []               # 组织好每一行显示的内容之后，统一输出，不逐行info
+        info_disabled = []
+        triggered = 0
+        triggered_enabled = 0
+        triggered_disabled = 0
+
+
+        tris_enabled = [tri for tri in self._triggers.values() if isinstance(tri, Trigger) and tri.enabled]
+        tris_enabled.sort(key = lambda tri: tri.priority)
+
+        tris_disabled = [tri for tri in self._triggers.values() if isinstance(tri, Trigger) and not tri.enabled]
+        tris_disabled.sort(key = lambda tri: tri.priority)
+        
         for raw_line in lines:
-            #raw_line = "".join(args)
             tri_line = self.getPlainText(raw_line)
+            
+            block = False
+            for tri in tris_enabled:
+                if tri.raw:
+                    state = tri.match(raw_line, docallback = docallback)
+                else:
+                    state = tri.match(tri_line, docallback = docallback)
+
+                if state.result == Trigger.SUCCESS:
+                    triggered_enabled += 1
+                    if not block: 
+                        triggered += 1
+                        info_enabled.append(f"  {Settings.INFO_STYLE}{tri.__detailed__()} 正常触发。{Settings.CLR_STYLE}")
+                        info_enabled.append(f"    {Settings.INFO_STYLE}捕获：{state.wildcards}{Settings.CLR_STYLE}")
+                    
+                        if not tri.keepEval:                # 非持续匹配的trigger，匹配成功后停止检测后续Trigger
+                            info_enabled.append(f"    {Settings.WARN_STYLE}该触发器未开启keepEval, 会阻止后续触发器。{Settings.CLR_STYLE}")
+                            block = True
+                    else:
+                        info_enabled.append(f"  {Settings.WARN_STYLE}{tri.__detailed__()} 可以触发，但由于优先级与keepEval设定，触发器不会触发。{Settings.CLR_STYLE}")
+            
+            
+            for tri in tris_disabled:
+                if tri.raw:
+                    state = tri.match(raw_line, docallback = docallback)
+                else:
+                    state = tri.match(tri_line, docallback = docallback)
 
-            all_tris = list(self._triggers.values())
-            all_tris.sort(key = lambda tri: tri.priority)
+                if state.result == Trigger.SUCCESS:
+                    triggered_disabled += 1
+                    info_disabled.append(f"  {Settings.INFO_STYLE}{tri.__detailed__()} 可以匹配触发。{Settings.CLR_STYLE}")
 
-            for tri in all_tris:
-                if isinstance(tri, Trigger) and tri.enabled:
-                    if tri.raw:
-                        state = tri.match(raw_line, docallback = True)
-                    else:
-                        state = tri.match(tri_line, docallback = True)
+            if triggered_enabled + triggered_disabled == 0:
+                info_all.append("")
 
-                    if state.result == Trigger.SUCCESS:
-                        self.info(f"TRIGGER {tri.id} 被触发", "PYMUD TRIGGER TEST")
-                        if tri.oneShot:                     # 仅执行一次的trigger，匹配成功后，删除该Trigger（从触发器列表中移除）
-                            self._triggers.pop(tri.id)
+        if triggered_enabled == 0:
+            info_enabled.insert(0, f"使能的触发器中，没有可以触发的。")
+        elif triggered < triggered_enabled:
+            info_enabled.insert(0, f"使能的触发器中，共有 {triggered_enabled} 个可以触发，实际触发 {triggered} 个，另有 {triggered_enabled - triggered} 个由于 keepEval 原因实际不会触发。")
+        else:
+            info_enabled.insert(0, f"使能的触发器中，共有 {triggered_enabled} 个全部可以被正常触发。")
 
-                        if not tri.keepEval:                # 非持续匹配的trigger，匹配成功后停止检测后续Trigger
-                            break
-                        else:
-                            pass
+        if triggered_disabled > 0:
+            info_disabled.insert(0, f"未使能的触发器中，共有 {triggered_disabled} 个可以匹配。")
+        else:
+            info_disabled.insert(0, f"未使能触发器，没有可以匹配的。")
+
+        if triggered_enabled + triggered_disabled == 0:
+            info_all.append(f"PYMUD 触发器测试: {'响应模式' if docallback else '测试模式'}")
+            info_all.append(f"  测试内容: {line}")
+            info_all.append(f"  测试结果: 没有可以匹配的触发器。")
+        else:
+            info_all.append(f"PYMUD 触发器测试: {'响应模式' if docallback else '测试模式'}")
+            info_all.append(f"  测试内容: {line}")
+            info_all.append(f"  测试结果: 有{triggered}个触发器可以被正常触发，一共有{triggered_enabled + triggered_disabled}个满足匹配触发要求。")
+            info_all.extend(info_enabled)
+            info_all.extend(info_disabled)
 
-            if len(raw_line) > 0:
-                self.info(raw_line, "PYMUD TRIGGER TEST")
+        self.info("\n".join(info_all), "PYMUD 触发器测试")
+        #self.info("PYMUD 触发器测试 完毕")
 
     def handle_plugins(self, code: CodeLine = None, *args, **kwargs):
         '''
@@ -2946,7 +3010,7 @@ class Session:
             if name in self.plugins.keys():
                 plugin = self.plugins[name]
                 self.info(f"{plugin.desc['DESCRIPTION']}, 版本 {plugin.desc['VERSION']} 作者 {plugin.desc['AUTHOR']} 发布日期 {plugin.desc['RELEASE_DATE']}", f"PLUGIN {name}")
-                self.writetobuffer(plugin.help)
+                self.writetobuffer(plugin.help, True)
 
     def handle_replace(self, code: CodeLine = None, *args, **kwargs):
         '''
@@ -3066,7 +3130,8 @@ class Session:
                 new_lines.append("{}{}".format(style, line))
 
             msg = Settings.client["newline"].join(new_lines)
-                
+
+        # 将颜色跨行显示移动到了MudFormatProcessor中，此处无需再处理(不行，还得恢复)
         self.writetobuffer("{}[{}] {}{}".format(style, title, msg, Settings.CLR_STYLE), newline = True)
 
     def info(self, msg, title = "PYMUD INFO", style = Settings.INFO_STYLE):
@@ -3125,8 +3190,8 @@ class Session:
 
         示例:
             - ``#log`` : 在当前会话窗口列出所有记录器状态
-            - ``#log start`` : 启动本会话默认记录器（记录器名为会话名）。该记录器以纯文本模式，将后续所有屏幕输出、键盘键入、命令输入等记录到 name.log 文件的后端
-            - ``#log start -r`` : 启动本会话默认记录器。该记录器以raw模式，将后续所有屏幕输出、键盘键入、命令输入等记录到 name.log 文件的后端
+            - ``#log start`` : 启动本会话默认记录器（记录器名为会话名）。该记录器以纯文本模式，将后续所有屏幕输出、键盘键入、命令输入等记录到 log 目录下 name.log 文件的后端
+            - ``#log start -r`` : 启动本会话默认记录器。该记录器以raw模式，将后续所有屏幕输出、键盘键入、命令输入等记录到 log 目录下 name.log 文件的后端
             - ``#log start chat`` : 启动名为 chat 的记录器。该记录器以纯文本模式，记录代码中调用过该记录器 .log 进行记录的信息
             - ``#log stop`` : 停止本会话默认记录器（记录器名为会话名）。
 
@@ -3184,8 +3249,19 @@ class Session:
             elif (args[0] == "show"):
                 if len(args) > 1 and not args[1].startswith('-'):
                     file = args[1]
-                    self.application.logFileShown = file
-                    self.application.showLogInTab()
+                    if os.path.exists(file):
+                        filepath = os.path.abspath(file)
+                        #self.info(f'file {filepath} exists, will be shown.')
+                        self.application.logFileShown = filepath
+                        self.application.showLogInTab()
+                    elif os.path.exists(os.path.join('./log', file)):
+                        filepath = os.path.abspath(os.path.join('./log', file))
+                        #self.info(f'file {filepath} exists, will be shown.')
+                        self.application.logFileShown = filepath
+                        self.application.showLogInTab()
+                    else:
+                        self.warning(f'指定记录文件 {file} 不存在！')
+                    
                 else:
                     self.application.show_logSelectDialog()
 

pymud/settings.py

@@ -11,9 +11,9 @@ class Settings:
     "APP 名称, 默认PYMUD"
     __appdesc__   = "a MUD client written in Python"
     "APP 简要描述"
-    __version__   = "0.20.0"
+    __version__   = "0.20.1"
     "APP 当前版本"
-    __release__   = "2024-08-19"
+    __release__   = "2024-11-16"
     "APP 当前版本发布日期"
     __author__    = "本牛(newstart)@北侠"
     "APP 作者"