pymud 0.20.0__py3-none-any.whl → 0.20.0a1__py3-none-any.whl

pymud/session.py

@@ -1,15 +1,14 @@
-import asyncio, logging, re, math, os, pickle, datetime, importlib, importlib.util, sysconfig, time
+import asyncio, logging, re, math, os, pickle, datetime, importlib, importlib.util, sysconfig
 from collections.abc import Iterable
 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
+from .extras import SessionBuffer, DotDict, Plugin
 from .protocol import MudClientProtocol
-from .modules import ModuleInfo
-from .objects import BaseObject, Trigger, Alias, Command, Timer, SimpleAlias, SimpleTrigger, SimpleTimer, GMCPTrigger, CodeBlock, CodeLine
+from .objects import Trigger, Alias, Command, Timer, SimpleAlias, SimpleTrigger, SimpleTimer, GMCPTrigger, CodeBlock, CodeLine
 from .settings import Settings
 
 
@@ -30,14 +29,13 @@ class Session:
 
     """
     #_esc_regx = re.compile("\x1b\\[[^mz]+[mz]")
-    _esc_regx = re.compile(r"\x1b\[[\d;]+[abcdmz]", flags = re.IGNORECASE)
+    _esc_regx = re.compile("\x1b\\[[\d;]+[abcdmz]", flags = re.IGNORECASE)
 
     _sys_commands = (
         "help",
         "exit",
         "close",
         "connect",      # 连接到服务器
-        "disconnect",   # 从服务器断开连接
 
         "info",         # 输出蓝色info
         "warning",      # 输出黄色warning
@@ -91,7 +89,6 @@ class Session:
         "var" : "variable",
         "rep" : "repeat",
         "con" : "connect",
-        "dis" : "disconnect",
         "wa"  : "wait",
         "mess": "message",
         "action": "trigger",
@@ -119,6 +116,9 @@ class Session:
         self._events["connected"]    = None
         self._events["disconnected"] = None
 
+        self._loggers = dict()
+        self.log = self.getLogger(name)
+
         self._auto_script = kwargs.get("scripts", None)
 
         self._cmds_handler = dict()                         # 支持的命令的处理函数字典
@@ -142,13 +142,8 @@ class Session:
         self._status_maker = None                           # 创建状态窗口的函数（属性）
         self.display_line  = ""
 
-        self._activetime = time.time()
-
         self.initialize()
 
-        self._loggers = dict()
-        self.log = self.getLogger(name)
-
         self.host = host
         self.port = port
         self.encoding = encoding or self.encoding
@@ -181,10 +176,6 @@ class Session:
         if Settings.client["auto_connect"]:
             self.open()
 
-    def __del__(self):
-        self.clean()
-        self.closeLoggers()
-
     def initialize(self):
         "初始化Session有关对象。 **无需脚本调用。**"
         self._line_buffer = bytearray()
@@ -257,6 +248,11 @@ class Session:
         if self.connected:
             self.write_eof()
 
+            # 两次保存，删掉一次
+            # # 断开时自动保存变量数据
+            # if Settings.client["var_autosave"]:
+            #     self.handle_save()
+
     def onDisconnected(self, protocol):
         "当从服务器连接断开时执行的操作。包括保存变量(若设置)、打印断开时间、执行自定义事件(若设置)等。"
         # 断开时自动保存变量数据
@@ -294,15 +290,6 @@ class Session:
 
         return dura
 
-    @property
-    def idletime(self) -> float:
-        "只读属性，返回当前会话空闲时间（即最后一次向服务器写入数据到现在的时间），以秒为单位。当服务器未连接时，返回-1"
-        idle = -1
-        if self._protocol and self._protocol.connected:
-            idle = time.time() - self._activetime
-
-        return idle
-
     @property
     def status_maker(self):
         """
@@ -389,15 +376,6 @@ class Session:
 
         return logger
 
-    def closeLoggers(self):
-        "移除本会话所有相关Logger"
-        for name in self._loggers.keys():
-            if isinstance(self._loggers[name], Logger):
-                self._loggers[name].enabled = False
-            
-            if name in self.application.loggers.keys():
-                self.application.loggers.pop(name)
-
     @property
     def modules(self) -> OrderedDict:
         """
@@ -764,7 +742,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", True)
+                    self.writetobuffer(f"\x1b[32m{ln}\x1b[0m")
                 else:
                     self.log.log(f"\x1b[32m{ln}\x1b[0m\n")
 
@@ -773,38 +751,15 @@ class Session:
                 
         else:
             if Settings.client["echo_input"]:
-                self.writetobuffer(f"\x1b[32m{line}\x1b[0m", True)
+                self.writetobuffer(f"\x1b[32m{line}\x1b[0m")
             else:
                 self.log.log(f"\x1b[32m{line}\x1b[0m\n")
 
             cmd = line + self.newline
             self.write(cmd.encode(self.encoding, Settings.server["encoding_errors"]))
-
-        self._activetime = time.time()
     
-    async def waitfor(self, line: str, awaitable, wait_time = 0.05) -> None:
-        """
-        调用writline向服务器中写入一行后，等待到可等待对象再返回。
-        
-        :param line: 使用writeline写入的行
-        :param awaitable: 等待的可等待对象
-        :param wait_time: 写入行前等待的延时，单位为s。默认0.05
-
-        由于异步的消息循环机制，如果在写入命令之后再创建可等待对象，则有可能服务器响应在可等待对象的创建之前
-        此时使用await就无法等待到可等待对象的响应，会导致任务出错。
-        一种解决方式是先创建可等待对象，然后写入命令，然后再等待可等待对象，但这种情况下需要写入三行代码，书写麻烦
-        因此该函数是用于简化此类使用时的写法。
-
-        示例:
-            await session.waitfor('a_cmd', self.create_task(a_tri.triggered()))
-            done, pending = await session.waitfor('a_cmd', asyncio.wait([self.create_task(a_tri.triggered()), self.create_task(b_tri.triggered())], return_when = 'FIRST_COMPLETED'))
-        """
-        await asyncio.sleep(wait_time)
-        self.writeline(line)
-        return await awaitable
-
     def exec(self, cmd: str, name = None, *args, **kwargs):
-        r"""
+        """
         在名称为name的会话中使用exec_command执行MUD命令。当不指定name时，在当前会话中执行。
 
         - exec 与 writeline 都会向服务器写入数据。其差异在于，exec执行的内容，会先经过Alias处理和Command处理，实际向远程发送内容与cmd可以不一致。
@@ -819,7 +774,7 @@ class Session:
         示例:
             .. code:: Python
 
-                session.addAlias(SimpleAlias(self.session, r"^cb\s(\S+)\s(\S+)", "#3 get %1 from jinnang;#wa 250;combine gem;#wa 250;pack gem", id = "ali_combine"))
+                session.addAlias(SimpleAlias(self.session, "^cb\s(\S+)\s(\S+)", "#3 get %1 from jinnang;#wa 250;combine gem;#wa 250;pack gem", id = "ali_combine"))
                 session.exec("cb j1a")
         """
         name = name or self.name
@@ -840,10 +795,12 @@ class Session:
         name = name or self.name
         if name in self.application.sessions.keys():
             session = self.application.sessions[name]
-            return await session.exec_command_async(cmd, *args, **kwargs)
+            await session.exec_command_async(cmd, *args, **kwargs)
         else:
             self.error(f"不存在名称为{name}的会话")
 
+    
+
     def exec_code(self, cl: CodeLine, *args, **kwargs):
         """
         执行解析为CodeLine形式的MUD命令（必定为单个命令）。一般情况下，脚本中不应调用该方法，而应使用exec/exec_command。
@@ -917,7 +874,6 @@ class Session:
         :param args: 保留兼容与扩展性所需
         :param kwargs: 保留兼容与扩展性所需
         """
-
         if cl.length == 0:
             self.writeline("")
 
@@ -945,9 +901,9 @@ class Session:
                 else:
                     try:
                         cb = CodeBlock(sess_cmd)
-                        return await cb.async_execute(session, *args, **kwargs)
+                        await cb.async_execute(session, *args, **kwargs)
                     except Exception as e:
-                        return await session.exec_command_async(sess_cmd)
+                        await session.exec_command_async(sess_cmd)
             
             else:
                 if cmd in self._commands_alias.keys():
@@ -964,7 +920,7 @@ class Session:
 
         else:
             cmdtext, code = cl.expand(self, *args, **kwargs)
-            return await self.exec_text_async(cmdtext)
+            await self.exec_text_async(cmdtext)
             
     def exec_text(self, cmdtext: str):
         """
@@ -1004,14 +960,14 @@ class Session:
 
         异步调用时，该函数要等待对应的代码执行完毕后才会返回。可以用于确保命令执行完毕。
         """
-        result = None
+
         isNotCmd = True
         for command in self._commands.values():
             if isinstance(command, Command) and command.enabled:
                 state = command.match(cmdtext)
                 if state.result == Command.SUCCESS:
                     # 命令的任务名称采用命令id，以便于后续查错
-                    result = await self.create_task(command.execute(cmdtext), name = "task-{0}".format(command.id))
+                    await self.create_task(command.execute(cmdtext), name = "task-{0}".format(command.id))
                     isNotCmd = False
                     break
 
@@ -1029,8 +985,6 @@ class Session:
             if notAlias:
                 self.writeline(cmdtext)
 
-        return result
-
     def exec_command(self, line: str, *args, **kwargs) -> None:
         """
         在当前会话中执行MUD命令。多个命令可以用分隔符隔开。
@@ -1081,18 +1035,15 @@ class Session:
         """
 
         ## 以下为函数执行本体
-        result = None
         if (not "#" in line) and (not "@" in line) and (not "%" in line):
             cmds = line.split(self.seperator)
             for cmd in cmds:
-                result = await self.exec_text_async(cmd)
+                await self.exec_text_async(cmd)
                 if Settings.client["interval"] > 0:
                     await asyncio.sleep(Settings.client["interval"] / 1000.0)
         else:
             cb = CodeBlock(line)
-            result = await cb.async_execute(self)
-
-        return result
+            await cb.async_execute(self)
 
     def write_eof(self) -> None:
         """
@@ -1156,212 +1107,50 @@ class Session:
 
         return counts
 
-    # def _addObjects(self, objs: dict, cls: type):
-    #     if cls == Alias:
-    #         self._aliases.update(objs)
-    #     elif cls == Command:
-    #         self._commands.update(objs)
-    #     elif cls == Trigger:
-    #         self._triggers.update(objs)
-    #     elif cls == Timer:
-    #         self._timers.update(objs)
-    #     elif cls == GMCPTrigger:
-    #         self._gmcp.update(objs)
-
-    def _addObjects(self, objs):
-        if isinstance(objs, list) or isinstance(objs, tuple):
-            for item in objs:
-                self._addObject(item)
-
-        elif isinstance(objs, dict):
-            for key, item in objs.items():
-                if isinstance(item, BaseObject):
-                    if key != item.id:
-                        self.warning(f'对象 {item} 字典键值 {key} 与其id {item.id} 不一致，将丢弃键值，以其id添加到会话中...')
-
-                    self._addObject(item)
-
-    # def _addObject(self, obj, cls: type):
-    #     #if type(obj) == cls:
-    #     if isinstance(obj, cls):
-    #         if cls == Alias:
-    #             self._aliases[obj.id] = obj
-    #         elif cls == Command:
-    #             self._commands[obj.id] = obj
-    #         elif cls == Trigger:
-    #             self._triggers[obj.id] = obj
-    #         elif cls == Timer:
-    #             self._timers[obj.id] = obj
-    #         elif cls == GMCPTrigger:
-    #             self._gmcp[obj.id] = obj
-
-    def _addObject(self, obj):
-        if isinstance(obj, Alias):
-            self._aliases[obj.id] = obj
-        elif isinstance(obj, Command):
-            self._commands[obj.id] = obj
-        elif isinstance(obj, Trigger):
-            self._triggers[obj.id] = obj
-        elif isinstance(obj, Timer):
-            self._timers[obj.id] = obj
-        elif isinstance(obj, GMCPTrigger):
-            self._gmcp[obj.id] = obj
-
-    def addObject(self, obj: BaseObject):
-        """
-        向会话中增加单个对象，可直接添加 Alias, Trigger, GMCPTrigger, Command, Timer 或它们的子类
-
-        :param obj: 特定对象本身，可以为 Alias, Trigger, GMCPTrigger, Command, Timer 或其子类
-
-        示例:
-            .. code:: Python
-
-                class Configuration:
-                    def __init__(self, session):
-                        self.session = session
-                    
-                        self.session.addObject(SimpleAlias(session, r'^gta$', 'get all'),)
-                        self.session.addObject(SimpleTrigger(session, r'^[> ]*你嘻嘻地笑了起来.+', 'haha'))
-                        self.session.addObject(SimpleTimer(session, 'xixi', timeout = 10))
-
-        """
-        self._addObject(obj)
-
-    def addObjects(self, objs):
-        """
-        向会话中增加多个对象，可直接添加 Alias, Trigger, GMCPTrigger, Command, Timer 或它们的子类的元组、列表或者字典(保持兼容性)
-
-        :param objs: 多个特定对象组成的元组、列表或者字典，可以为 Alias, Trigger, GMCPTrigger, Command, Timer 或其子类
-
-        示例:
-            .. code:: Python
-
-                class Configuration:
-                    def __init__(self, session):
-                        self.session = session
-                    
-                        self.objs = [
-                            SimpleAlias(session, r'^gta$', 'get all;xixi'),
-                            SimpleTrigger(session, r'^[> ]*你嘻嘻地笑了起来.+', 'haha'),
-                            SimpleTimer(session, 'xixi', timeout = 10)
-                        ]
-
-                        self.session.addObjects(self.objs)
-
-        """
-        self._addObjects(objs)
+    def _addObjects(self, objs: dict, cls: type):
+        if cls == Alias:
+            self._aliases.update(objs)
+        elif cls == Command:
+            self._commands.update(objs)
+        elif cls == Trigger:
+            self._triggers.update(objs)
+        elif cls == Timer:
+            self._timers.update(objs)
+        elif cls == GMCPTrigger:
+            self._gmcp.update(objs)
+
+    def _addObject(self, obj, cls: type):
+        #if type(obj) == cls:
+        if isinstance(obj, cls):
+            if cls == Alias:
+                self._aliases[obj.id] = obj
+            elif cls == Command:
+                self._commands[obj.id] = obj
+            elif cls == Trigger:
+                self._triggers[obj.id] = obj
+            elif cls == Timer:
+                self._timers[obj.id] = obj
+            elif cls == GMCPTrigger:
+                self._gmcp[obj.id] = obj
 
     def _delObject(self, id, cls: type):
         if cls == Alias:
             self._aliases.pop(id, None)
         elif cls == Command:
-            cmd = self._commands.pop(id, None)
-            if isinstance(cmd, Command):
-                cmd.reset()
-                cmd.unload()
-                cmd.__unload__()
-
+            self._commands.pop(id, None)
         elif cls == Trigger:
             self._triggers.pop(id, None)
         elif cls == Timer:
-            timer = self._timers.pop(id, None)
-            if isinstance(timer, Timer):
-                timer.enabled = False
+            self._timers.pop(id, None)
         elif cls == GMCPTrigger:
             self._gmcp.pop(id, None)
 
-
     def _delObjects(self, ids: Iterable, cls: type):
         "删除多个指定元素"
         for id in ids:
             self._delObject(id, cls)
 
-    def delObject(self, obj):
-        """
-        从会话中移除一个对象，可直接删除 Alias, Trigger, GMCPTrigger, Command, Timer 或它们的子类本身
-        
-        ** 注 ** 现在 delObject 和 delObjects 使用结果相同，都可以清除单个对象、对个对象的list, tuple或dict, 可以有效防止代码写错
-
-        :param obj: 要删除的多个特定对象组成的元组、列表或者字典，可以为 Alias, Trigger, GMCPTrigger, Command, Timer 或其子类
-
-        示例:
-            .. code:: Python
-
-                class Configuration:
-                    def __init__(self, session):
-                        self.session = session
-
-                        ali = SimpleAlias(session, r'^gta$', 'get all', id = 'my_ali1')
-                        
-                        # 以下几种方式均可将该别名添加到会话
-                        session.addObject(ali)
-                        session.addAlias(ali)
-
-                        # 以下三种方式均可以删除该别名
-                        session.delObject(ali)
-                        session.delAlias(ali)
-                        session.delAlias("my_ali1")
-
-        """
-        if isinstance(obj, Alias):
-            self._aliases.pop(obj.id, None)
-        elif isinstance(obj, Command):
-            obj.reset()
-            obj.unload()
-            obj.__unload__()
-            self._commands.pop(obj.id, None)
-        elif isinstance(obj, Trigger):
-            self._triggers.pop(obj.id, None)
-        elif isinstance(obj, Timer):
-            obj.enabled = False
-            self._timers.pop(obj.id, None)
-        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 或它们的子类
-
-        示例:
-
-        .. code:: Python
-
-            class Configuration:
-                def __init__(self, session):
-                    self.session = session
-                
-                    self.objs = [
-                        SimpleAlias(session, r'^gta$', 'get all;xixi'),
-                        SimpleTrigger(session, r'^[> ]*你嘻嘻地笑了起来.+', 'haha'),
-                        SimpleTimer(session, 'xixi', timeout = 10)
-                    ]
-
-                    self.session.addObjects(self.objs)
-
-                def __unload__(self):
-                    "卸载本模块时，删除所有本模块添加的对象"
-                    self.session.delObjects(self.objs)
-
-        """
-        if isinstance(objs, list) or isinstance(objs, tuple):
-            for item in objs:
-                self.delObject(item)
-
-        elif isinstance(objs, dict):
-            for key, item in objs.items():
-                self.delObject(item)
-
-        elif isinstance(objs, BaseObject):
-            self.delObject(objs)
-
-    def addAliases(self, alis):
+    def addAliases(self, alis: dict):
         """
         向会话中增加多个别名
 
@@ -1382,55 +1171,55 @@ class Session:
                         self._aliases['my_ali2'] = SimpleAlias(self.session, "s", "south", id = "my_ali2")
                         self.session.addAliases(self._aliases)
         """
-        self._addObjects(alis)
+        self._addObjects(alis, Alias)
 
-    def addCommands(self, cmds):
+    def addCommands(self, cmds: dict):
         """
         向会话中增加多个命令。使用方法与 addAliases 类似。
 
         :param cmds: 多个命令的字典。字典 key 应为每个命令的 id。
         """
-        self._addObjects(cmds)
+        self._addObjects(cmds, Command)
 
-    def addTriggers(self, tris):
+    def addTriggers(self, tris: dict):
         """
         向会话中增加多个触发器。使用方法与 addAliases 类似。
 
         :param tris: 多个触发器的字典。字典 key 应为每个触发器的 id。
         """
-        self._addObjects(tris)
+        self._addObjects(tris, Trigger)
 
-    def addGMCPs(self, gmcps):
+    def addGMCPs(self, gmcps: dict):
         """
         向会话中增加多个GMCPTrigger。使用方法与 addAliases 类似。
 
         :param gmcps: 多个GMCPTrigger的字典。字典 key 应为每个GMCPTrigger的 id。
         """
-        self._addObjects(gmcps)
+        self._addObjects(gmcps, GMCPTrigger)
 
-    def addTimers(self, tis):
+    def addTimers(self, tis: dict):
         """
         向会话中增加多个定时器。使用方法与 addAliases 类似。
 
         :param tis: 多个定时器的字典。字典 key 应为每个定时器的 id。
         """
-        self._addObjects(tis)
+        self._addObjects(tis, Timer)
 
-    def addAlias(self, ali):
+    def addAlias(self, ali: Alias):
         """
         向会话中增加一个别名。
 
         :param ali: 要增加的别名对象，应为 Alias 类型或其子类
         """
-        self._addObject(ali)
+        self._addObject(ali, Alias)
 
-    def addCommand(self, cmd):
+    def addCommand(self, cmd: Command):
         """
         向会话中增加一个命令。
 
         :param cmd: 要增加的命令对象，应为 Command 类型或其子类
         """
-        self._addObject(cmd)
+        self._addObject(cmd, Command)
 
     def addTrigger(self, tri: Trigger):
         """
@@ -1438,7 +1227,7 @@ class Session:
 
         :param tri: 要增加的触发器对象，应为 Trigger 类型或其子类
         """
-        self._addObject(tri)
+        self._addObject(tri, Trigger)
 
     def addTimer(self, ti: Timer):
         """
@@ -1446,7 +1235,7 @@ class Session:
 
         :param ti: 要增加的定时器对象，应为 Timer 类型或其子类
         """
-        self._addObject(ti)
+        self._addObject(ti, Timer)
 
     def addGMCP(self, gmcp: GMCPTrigger):
         """
@@ -1455,7 +1244,7 @@ class Session:
         :param gmcp: 要增加的GMCP触发器对象，应为 GMCPTrigger 类型或其子类
         """
 
-        self._addObject(gmcp)
+        self._addObject(gmcp, GMCPTrigger)
 
     def delAlias(self, ali):
         """
@@ -1574,7 +1363,7 @@ class Session:
         for ti in ti_s:
             self.delTimer(ti)
 
-    def delGMCP(self, gmcp):
+    def delGMCP(self, gmcp: GMCPTrigger):
         """
         从会话中移除一个GMCP触发器，可接受 GMCPTrigger 对象或其的id。使用方法与 delAlias 类似
         
@@ -1890,7 +1679,6 @@ class Session:
         该函数不应该在代码中直接调用。
         
         相关命令:
-            - #disconnect
             - #close
             - #exit
         '''
@@ -1912,18 +1700,6 @@ class Session:
 
             self.info("已经与服务器连接了 {}".format(time_msg))
 
-    def handle_disconnect(self, code: CodeLine = None, *args, **kwargs):
-        '''
-        嵌入命令 #disconnect / #dis 的执行函数，断开到远程服务器的连接（仅当远程服务器已连接时有效）。
-        该函数不应该在代码中直接调用。
-        
-        相关命令:
-            - #connect
-            - #close
-        '''
-
-        self.disconnect()
-
     def handle_variable(self, code: CodeLine = None, *args, **kwargs):
         '''
         嵌入命令 #variable / #var 的执行函数，操作会话变量。
@@ -1962,7 +1738,7 @@ class Session:
                 else:
                     vars_simple[k] = v
 
-            width = self.application.get_width() - 2        # 保留2个字符，防止 > 导致换行
+            width = self.application.get_width()
             
             title = f"  VARIABLE LIST IN SESSION {self.name}  "
             left = (width - len(title)) // 2
@@ -1970,7 +1746,6 @@ 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)
@@ -1986,18 +1761,14 @@ class Session:
                 self.writetobuffer(" " * left_space)
                 line_vars = var_keys[start:end]
                 for var in line_vars:
-                    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("{0:>18} = {1:<19}".format(var, vars_simple[var].__repr__()))
 
                 self.writetobuffer("", newline = True)
 
             # print vars in complex, 每个变量占1行
-            var_keys = sorted(vars_complex.keys())
-            for key in var_keys:
+            for k, v in vars_complex.items():
                 self.writetobuffer(" " * left_space)
-                self.writetobuffer("{0:>20} = {1}".format(key, vars_complex[key].__repr__()), newline = True)
+                self.writetobuffer("{0:>18} = {1}".format(k, v.__repr__()), newline = True)
 
             self.writetobuffer("="*width, newline = True)
 
@@ -2050,7 +1821,7 @@ class Session:
                 else:
                     vars_simple[k] = v
 
-            width = self.application.get_width() - 2        # 保留2个字符，防止 > 导致换行
+            width = self.application.get_width()
             
             title = f" GLOBAL VARIABLES LIST "
             left = (width - len(title)) // 2
@@ -2073,23 +1844,21 @@ class Session:
                 self.writetobuffer(" " * left_space)
                 line_vars = var_keys[start:end]
                 for var in line_vars:
-                    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():
                 self.writetobuffer(" " * left_space)
-                self.writetobuffer("{0:>20} = {1}".format(k, v.__repr__()), newline = True)
+                self.writetobuffer("{0:>18} = {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:>20} = {1:<22}".format(var, self.application.get_globals(var).__repr__()), "全局变量")
+                self.info("{0:>18} = {1:<19}".format(var, self.application.get_globals(var).__repr__()), "全局变量")
             else:
                 self.info("全局空间不存在名称为 {} 的变量".format(var), "全局变量")
             
@@ -2164,7 +1933,7 @@ class Session:
                             self.info("创建Timer {} 成功: {}".format(ti.id, ti.__repr__()))
 
     def handle_alias(self, code: CodeLine = None, *args, **kwargs):
-        r"""
+        '''
         嵌入命令 #alias / #ali 的执行函数，操作别名。该命令可以不带参数、带一个参数或者两个参数。
         该函数不应该在代码中直接调用。
 
@@ -2195,7 +1964,7 @@ class Session:
             - #trigger
             - #timer
             - #command
-        """
+        '''
 
         self._handle_objs("Alias", self._aliases, *code.code[2:])
 
@@ -2554,7 +2323,6 @@ class Session:
         self._variables.clear()
         self._tasks.clear()
 
-
     def load_module(self, module_names):
         """
         模块加载函数。
@@ -2578,12 +2346,32 @@ class Session:
         "加载指定名称模块"
         try:
             if module_name not in self._modules.keys():
-                self._modules[module_name] = ModuleInfo(module_name, self)
+                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} 加载完成.")
 
             else:
-                mod = self._modules[module_name]
-                if isinstance(mod, ModuleInfo):
-                    mod.reload()
+                mod = self._modules[module_name]["module"]
+                config = self._modules[module_name]["config"]
+                if config: 
+                    if hasattr(config, "unload"):
+                        unload = getattr(config, "unload", None)
+                        if callable(unload):
+                            unload(config)
+                    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} 重新加载完成.")
 
         except Exception as e:
             import traceback
@@ -2609,11 +2397,20 @@ class Session:
             self._unload_module(mod)
 
     def _unload_module(self, module_name):
-        "卸载指定名称模块。卸载支持需要模块的Configuration实现 __unload__ 或 unload 方法"
+        "卸载指定名称模块。卸载支持需要模块的Configuration实现__del__方法"
         if module_name in self._modules.keys():
-            mod = self._modules.pop(module_name)
-            if isinstance(mod, ModuleInfo):
-                mod.unload()
+            mod = self._modules[module_name]["module"]
+            config = self._modules[module_name]["config"]
+            if config: 
+                if hasattr(config, "unload"):
+                    unload = getattr(config, "unload", None)
+                    if callable(unload):
+                        unload(config)
+
+                del config
+            del mod
+            self._modules.pop(module_name)
+            self.info(f"配置模块 {module_name} 已成功卸载.")
 
         else:
             self.warning(f"指定模块名称 {module_name} 并未加载.")
@@ -2627,9 +2424,9 @@ class Session:
         :param module_names: 要重新加载的模块清单。为元组/列表时，卸载指定名称的系列模块，当名称为字符串时，卸载单个模块。当不指定时，重新加载所有已加载模块。
         """
         if module_names is None:
-            for name, module in self._modules.items():
-                if isinstance(module, ModuleInfo):
-                    module.reload()
+            self.clean()
+            mods = list(self._modules.keys())
+            self.load_module(mods)
 
             self.info(f"所有配置模块全部重新加载完成.")
 
@@ -2637,17 +2434,14 @@ class Session:
             for mod in module_names:
                 mod = mod.strip()
                 if mod in self._modules.keys():
-                    module = self._modules[mod]
-                    if isinstance(module, ModuleInfo):
-                        module.reload()
+                    self.load_module(mod)
                 else:
                     self.warning(f"指定模块名称 {mod} 并未加载，无法重新加载.")
 
         elif isinstance(module_names, str):
             if module_names in self._modules.keys():
-                module = self._modules[module_names]
-                if isinstance(module, ModuleInfo):
-                    module.reload()
+                mod = module_names.strip()
+                self.load_module(mod)
             else:
                 self.warning(f"指定模块名称 {module_names} 并未加载，无法重新加载.")
         
@@ -2731,7 +2525,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} 既未找到模块，也未找到插件，重新加载失败..")
 
@@ -2785,29 +2579,12 @@ class Session:
             - #reload
         '''
 
-        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")
+        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 的执行函数，复位全部脚本。该命令不带参数。
@@ -2827,8 +2604,7 @@ class Session:
 
     def handle_save(self, code: CodeLine = None, *args, **kwargs):
         '''
-        嵌入命令 #save 的执行函数，保存当前会话变量（系统变量和临时变量除外）至文件。该命令不带参数。
-        系统变量包括 %line, %copy 和 %raw 三个，临时变量是指变量名已下划线开头的变量
+        嵌入命令 #save 的执行函数，保存当前会话变量（系统变量除外）至文件。该命令不带参数。
         该函数不应该在代码中直接调用。
 
         使用:
@@ -2849,10 +2625,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)
@@ -2951,7 +2727,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, True)
+                self.writetobuffer(plugin.help)
 
     def handle_replace(self, code: CodeLine = None, *args, **kwargs):
         '''
@@ -3130,8 +2906,8 @@ class Session:
 
         示例:
             - ``#log`` : 在当前会话窗口列出所有记录器状态
-            - ``#log start`` : 启动本会话默认记录器（记录器名为会话名）。该记录器以纯文本模式，将后续所有屏幕输出、键盘键入、命令输入等记录到 log 目录下 name.log 文件的后端
-            - ``#log start -r`` : 启动本会话默认记录器。该记录器以raw模式，将后续所有屏幕输出、键盘键入、命令输入等记录到 log 目录下 name.log 文件的后端
+            - ``#log start`` : 启动本会话默认记录器（记录器名为会话名）。该记录器以纯文本模式，将后续所有屏幕输出、键盘键入、命令输入等记录到 name.log 文件的后端
+            - ``#log start -r`` : 启动本会话默认记录器。该记录器以raw模式，将后续所有屏幕输出、键盘键入、命令输入等记录到 name.log 文件的后端
             - ``#log start chat`` : 启动名为 chat 的记录器。该记录器以纯文本模式，记录代码中调用过该记录器 .log 进行记录的信息
             - ``#log stop`` : 停止本会话默认记录器（记录器名为会话名）。
 
@@ -3189,19 +2965,8 @@ class Session:
             elif (args[0] == "show"):
                 if len(args) > 1 and not args[1].startswith('-'):
                     file = args[1]
-                    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} 不存在！')
-                    
+                    self.application.logFileShown = file
+                    self.application.showLogInTab()
                 else:
                     self.application.show_logSelectDialog()