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

pymud/session.py

@@ -1,10 +1,15 @@
-import asyncio, logging, re, math, os, pickle, datetime, importlib, importlib.util, sysconfig
+import asyncio, logging, re, math, os, pickle, datetime, importlib, importlib.util, sysconfig, time
 from collections.abc import Iterable
 from collections import OrderedDict
-
-from .extras import SessionBuffer, DotDict, Plugin
+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 .protocol import MudClientProtocol
-from .objects import Trigger, Alias, Command, Timer, SimpleAlias, SimpleTrigger, SimpleTimer, GMCPTrigger, CodeBlock, CodeLine
+from .modules import ModuleInfo
+from .objects import BaseObject, Trigger, Alias, Command, Timer, SimpleAlias, SimpleTrigger, SimpleTimer, GMCPTrigger, CodeBlock, CodeLine
 from .settings import Settings
 
 
@@ -25,13 +30,14 @@ class Session:
 
     """
     #_esc_regx = re.compile("\x1b\\[[^mz]+[mz]")
-    _esc_regx = re.compile("\x1b\\[[\d;]+[abcdmz]", flags = re.IGNORECASE)
+    _esc_regx = re.compile(r"\x1b\[[\d;]+[abcdmz]", flags = re.IGNORECASE)
 
     _sys_commands = (
         "help",
         "exit",
         "close",
         "connect",      # 连接到服务器
+        "disconnect",   # 从服务器断开连接
 
         "info",         # 输出蓝色info
         "warning",      # 输出黄色warning
@@ -73,6 +79,8 @@ class Session:
         "py",           # 直接执行python语句
 
         "all",          # 所有会话执行
+
+        "log",          # 记录处置
     )
 
     _commands_alias = {
@@ -83,6 +91,7 @@ class Session:
         "var" : "variable",
         "rep" : "repeat",
         "con" : "connect",
+        "dis" : "disconnect",
         "wa"  : "wait",
         "mess": "message",
         "action": "trigger",
@@ -96,7 +105,8 @@ class Session:
     def __init__(self, app, name, host, port, encoding = None, after_connect = None, loop = None, **kwargs):
         self.pyversion = sysconfig.get_python_version()   
         self.loop = loop or asyncio.get_running_loop()    
-        self.log = logging.getLogger("pymud.Session")
+        self.syslog = logging.getLogger("pymud.Session")
+
         self.application = app
         self.name = name
         self._transport = None
@@ -132,8 +142,13 @@ 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
@@ -159,7 +174,6 @@ class Session:
                             self.warning(f"自动从{file}中加载变量失败，错误消息为： {e}")
 
         
-
         if self._auto_script:
             self.info(f"即将自动加载以下模块:{self._auto_script}")
             self.load_module(self._auto_script)
@@ -167,6 +181,10 @@ class Session:
         if Settings.client["auto_connect"]:
             self.open()
 
+    def __del__(self):
+        self.clean()
+        self.closeLoggers()
+
     def initialize(self):
         "初始化Session有关对象。 **无需脚本调用。**"
         self._line_buffer = bytearray()
@@ -239,11 +257,6 @@ class Session:
         if self.connected:
             self.write_eof()
 
-            # 两次保存，删掉一次
-            # # 断开时自动保存变量数据
-            # if Settings.client["var_autosave"]:
-            #     self.handle_save()
-
     def onDisconnected(self, protocol):
         "当从服务器连接断开时执行的操作。包括保存变量(若设置)、打印断开时间、执行自定义事件(若设置)等。"
         # 断开时自动保存变量数据
@@ -281,6 +294,15 @@ 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):
         """
@@ -340,6 +362,42 @@ class Session:
     def event_disconnected(self, event):
         self._events["disconnected"] = event
 
+    def getLogger(self, name, mode = 'a', encoding = 'utf-8', encoding_errors = 'ignore', raw = False) -> Logger:
+        """
+        根据指定名称和参数获取并返回一个记录器。若指定名称不存在，则创建一个该名称记录器。
+        
+        :param name: 指定的记录器名称
+        :param mode: 记录器的模式，可接受值为 a, w, n。 具体请参见 Logger 对象中 mode 参数
+        :param encoding: 记录文件的编码格式
+        :param encoding_errors: 编码错误的处理方式
+        :param raw: 是否以带ANSI标记的原始格式进行记录
+
+        :return 指定名称的记录器 Logger 对象
+        """
+        if name not in self.application.loggers.keys():
+            logger = Logger(name, mode, encoding, encoding_errors, raw)
+            self._loggers[name] = logger
+            self.application.loggers[name] = logger
+
+        else:
+            if name not in self._loggers.keys():
+                self.warning(f"其它会话中已存在一个名为 {name} 的记录器，将直接返回该记录器")
+
+            logger = self.application.loggers[name]
+            logger.mode = mode
+            logger.raw = raw
+
+        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:
         """
@@ -484,6 +542,7 @@ class Session:
         :param newline: 是否额外增加换行符
         """
         self.buffer.insert_text(data)
+        self.log.log(data)
 
         if len(data) > 0 and (data[-1] == "\n"):
             self._line_count += 1
@@ -491,6 +550,7 @@ class Session:
         if newline:
             self.buffer.insert_text(self.newline_cli)
             self._line_count += 1
+            self.log.log(self.newline_cli)
 
     def clear_half(self):
         """
@@ -520,7 +580,7 @@ class Session:
         if self.connected:
             self._transport.write_eof()
         self.state = "DISCONNECTED"
-        self.log.info(f"服务器断开连接! {self._protocol.__repr__}")
+        self.syslog.info(f"服务器断开连接! {self._protocol.__repr__}")
     
     def feed_gmcp(self, name, value) -> None:
         """
@@ -703,22 +763,48 @@ class Session:
         if self.seperator in line:
             lines = line.split(self.seperator)
             for ln in lines:
+                if Settings.client["echo_input"]:
+                    self.writetobuffer(f"\x1b[32m{ln}\x1b[0m", True)
+                else:
+                    self.log.log(f"\x1b[32m{ln}\x1b[0m\n")
+
                 cmd = ln + self.newline
                 self.write(cmd.encode(self.encoding, Settings.server["encoding_errors"]))
                 
-                if Settings.client["echo_input"]:
-                    self.writetobuffer(f"\x1b[32m{cmd}\x1b[0m")
-
         else:
+            if Settings.client["echo_input"]:
+                self.writetobuffer(f"\x1b[32m{line}\x1b[0m", True)
+            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"]))
 
-            #if Settings.client["echo_input"]:
-            if Settings.client["echo_input"] and (len(cmd) > len(self.newline)):        # 修改2023-12-3， 向服务器发送空回车时，不回显
-                self.writetobuffer(f"\x1b[32m{cmd}\x1b[0m")
+        self._activetime = time.time()
     
-    def exec(self, cmd: str, name = None, *args, **kwargs):
+    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可以不一致。
@@ -733,7 +819,7 @@ class Session:
         示例:
             .. code:: Python
 
-                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.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.exec("cb j1a")
         """
         name = name or self.name
@@ -754,12 +840,10 @@ class Session:
         name = name or self.name
         if name in self.application.sessions.keys():
             session = self.application.sessions[name]
-            await session.exec_command_async(cmd, *args, **kwargs)
+            return 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。
@@ -833,6 +917,7 @@ class Session:
         :param args: 保留兼容与扩展性所需
         :param kwargs: 保留兼容与扩展性所需
         """
+
         if cl.length == 0:
             self.writeline("")
 
@@ -860,9 +945,9 @@ class Session:
                 else:
                     try:
                         cb = CodeBlock(sess_cmd)
-                        await cb.async_execute(session, *args, **kwargs)
+                        return await cb.async_execute(session, *args, **kwargs)
                     except Exception as e:
-                        await session.exec_command_async(sess_cmd)
+                        return await session.exec_command_async(sess_cmd)
             
             else:
                 if cmd in self._commands_alias.keys():
@@ -879,7 +964,7 @@ class Session:
 
         else:
             cmdtext, code = cl.expand(self, *args, **kwargs)
-            await self.exec_text_async(cmdtext)
+            return await self.exec_text_async(cmdtext)
             
     def exec_text(self, cmdtext: str):
         """
@@ -919,14 +1004,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，以便于后续查错
-                    await self.create_task(command.execute(cmdtext), name = "task-{0}".format(command.id))
+                    result = await self.create_task(command.execute(cmdtext), name = "task-{0}".format(command.id))
                     isNotCmd = False
                     break
 
@@ -944,6 +1029,8 @@ class Session:
             if notAlias:
                 self.writeline(cmdtext)
 
+        return result
+
     def exec_command(self, line: str, *args, **kwargs) -> None:
         """
         在当前会话中执行MUD命令。多个命令可以用分隔符隔开。
@@ -994,15 +1081,18 @@ 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:
-                await self.exec_text_async(cmd)
+                result = await self.exec_text_async(cmd)
                 if Settings.client["interval"] > 0:
                     await asyncio.sleep(Settings.client["interval"] / 1000.0)
         else:
             cb = CodeBlock(line)
-            await cb.async_execute(self)
+            result = await cb.async_execute(self)
+
+        return result
 
     def write_eof(self) -> None:
         """
@@ -1066,50 +1156,212 @@ 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 _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 _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 _delObject(self, id, cls: type):
         if cls == Alias:
             self._aliases.pop(id, None)
         elif cls == Command:
-            self._commands.pop(id, None)
+            cmd = self._commands.pop(id, None)
+            if isinstance(cmd, Command):
+                cmd.reset()
+                cmd.unload()
+                cmd.__unload__()
+
         elif cls == Trigger:
             self._triggers.pop(id, None)
         elif cls == Timer:
-            self._timers.pop(id, None)
+            timer = self._timers.pop(id, None)
+            if isinstance(timer, Timer):
+                timer.enabled = False
         elif cls == GMCPTrigger:
             self._gmcp.pop(id, None)
 
+
     def _delObjects(self, ids: Iterable, cls: type):
         "删除多个指定元素"
         for id in ids:
             self._delObject(id, cls)
 
-    def addAliases(self, alis: dict):
+    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):
         """
         向会话中增加多个别名
 
@@ -1130,55 +1382,55 @@ class Session:
                         self._aliases['my_ali2'] = SimpleAlias(self.session, "s", "south", id = "my_ali2")
                         self.session.addAliases(self._aliases)
         """
-        self._addObjects(alis, Alias)
+        self._addObjects(alis)
 
-    def addCommands(self, cmds: dict):
+    def addCommands(self, cmds):
         """
         向会话中增加多个命令。使用方法与 addAliases 类似。
 
         :param cmds: 多个命令的字典。字典 key 应为每个命令的 id。
         """
-        self._addObjects(cmds, Command)
+        self._addObjects(cmds)
 
-    def addTriggers(self, tris: dict):
+    def addTriggers(self, tris):
         """
         向会话中增加多个触发器。使用方法与 addAliases 类似。
 
         :param tris: 多个触发器的字典。字典 key 应为每个触发器的 id。
         """
-        self._addObjects(tris, Trigger)
+        self._addObjects(tris)
 
-    def addGMCPs(self, gmcps: dict):
+    def addGMCPs(self, gmcps):
         """
         向会话中增加多个GMCPTrigger。使用方法与 addAliases 类似。
 
         :param gmcps: 多个GMCPTrigger的字典。字典 key 应为每个GMCPTrigger的 id。
         """
-        self._addObjects(gmcps, GMCPTrigger)
+        self._addObjects(gmcps)
 
-    def addTimers(self, tis: dict):
+    def addTimers(self, tis):
         """
         向会话中增加多个定时器。使用方法与 addAliases 类似。
 
         :param tis: 多个定时器的字典。字典 key 应为每个定时器的 id。
         """
-        self._addObjects(tis, Timer)
+        self._addObjects(tis)
 
-    def addAlias(self, ali: Alias):
+    def addAlias(self, ali):
         """
         向会话中增加一个别名。
 
         :param ali: 要增加的别名对象，应为 Alias 类型或其子类
         """
-        self._addObject(ali, Alias)
+        self._addObject(ali)
 
-    def addCommand(self, cmd: Command):
+    def addCommand(self, cmd):
         """
         向会话中增加一个命令。
 
         :param cmd: 要增加的命令对象，应为 Command 类型或其子类
         """
-        self._addObject(cmd, Command)
+        self._addObject(cmd)
 
     def addTrigger(self, tri: Trigger):
         """
@@ -1186,7 +1438,7 @@ class Session:
 
         :param tri: 要增加的触发器对象，应为 Trigger 类型或其子类
         """
-        self._addObject(tri, Trigger)
+        self._addObject(tri)
 
     def addTimer(self, ti: Timer):
         """
@@ -1194,7 +1446,7 @@ class Session:
 
         :param ti: 要增加的定时器对象，应为 Timer 类型或其子类
         """
-        self._addObject(ti, Timer)
+        self._addObject(ti)
 
     def addGMCP(self, gmcp: GMCPTrigger):
         """
@@ -1203,7 +1455,7 @@ class Session:
         :param gmcp: 要增加的GMCP触发器对象，应为 GMCPTrigger 类型或其子类
         """
 
-        self._addObject(gmcp, GMCPTrigger)
+        self._addObject(gmcp)
 
     def delAlias(self, ali):
         """
@@ -1322,7 +1574,7 @@ class Session:
         for ti in ti_s:
             self.delTimer(ti)
 
-    def delGMCP(self, gmcp: GMCPTrigger):
+    def delGMCP(self, gmcp):
         """
         从会话中移除一个GMCP触发器，可接受 GMCPTrigger 对象或其的id。使用方法与 delAlias 类似
         
@@ -1604,7 +1856,8 @@ class Session:
             - #session
         '''
 
-        self.application.close_session()
+        #self.application.close_session()
+        self.application.act_close_session()
 
     async def handle_wait(self, code: CodeLine = None, *args, **kwargs):
         '''
@@ -1637,6 +1890,7 @@ class Session:
         该函数不应该在代码中直接调用。
         
         相关命令:
+            - #disconnect
             - #close
             - #exit
         '''
@@ -1658,6 +1912,18 @@ 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 的执行函数，操作会话变量。
@@ -1696,7 +1962,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
@@ -1704,6 +1970,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)
@@ -1719,14 +1986,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)
 
@@ -1779,7 +2050,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
@@ -1802,21 +2073,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), "全局变量")
             
@@ -1891,7 +2164,7 @@ class Session:
                             self.info("创建Timer {} 成功: {}".format(ti.id, ti.__repr__()))
 
     def handle_alias(self, code: CodeLine = None, *args, **kwargs):
-        '''
+        r"""
         嵌入命令 #alias / #ali 的执行函数，操作别名。该命令可以不带参数、带一个参数或者两个参数。
         该函数不应该在代码中直接调用。
 
@@ -1922,7 +2195,7 @@ class Session:
             - #trigger
             - #timer
             - #command
-        '''
+        """
 
         self._handle_objs("Alias", self._aliases, *code.code[2:])
 
@@ -2281,6 +2554,7 @@ class Session:
         self._variables.clear()
         self._tasks.clear()
 
+
     def load_module(self, module_names):
         """
         模块加载函数。
@@ -2304,27 +2578,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: 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
@@ -2350,20 +2609,11 @@ class Session:
             self._unload_module(mod)
 
     def _unload_module(self, module_name):
-        "卸载指定名称模块。卸载支持需要模块的Configuration实现__del__方法"
+        "卸载指定名称模块。卸载支持需要模块的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"):
-                    unload = getattr(config, "unload", None)
-                    if callable(unload):
-                        unload(config)
-
-                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} 并未加载.")
@@ -2377,9 +2627,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"所有配置模块全部重新加载完成.")
 
@@ -2387,14 +2637,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} 并未加载，无法重新加载.")
         
@@ -2478,7 +2731,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} 既未找到模块，也未找到插件，重新加载失败..")
 
@@ -2532,12 +2785,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 的执行函数，复位全部脚本。该命令不带参数。
@@ -2557,7 +2827,8 @@ class Session:
 
     def handle_save(self, code: CodeLine = None, *args, **kwargs):
         '''
-        嵌入命令 #save 的执行函数，保存当前会话变量（系统变量除外）至文件。该命令不带参数。
+        嵌入命令 #save 的执行函数，保存当前会话变量（系统变量和临时变量除外）至文件。该命令不带参数。
+        系统变量包括 %line, %copy 和 %raw 三个，临时变量是指变量名已下划线开头的变量
         该函数不应该在代码中直接调用。
 
         使用:
@@ -2578,10 +2849,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)
@@ -2680,7 +2951,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):
         '''
@@ -2832,3 +3103,105 @@ class Session:
         :param style: 要输出信息的格式(ANSI)， 默认为 ERR_STYLE, \x1b[31m
         """
         self.info2(msg, title, style)
+
+    def handle_log(self, code: CodeLine = None, *args, **kwargs):
+        '''
+        嵌入命令 #log 的执行函数，控制当前会话的记录状态。
+        该函数不应该在代码中直接调用。
+
+        使用:
+            - #log : 显示所有记录器的状态情况
+            - #log start [logger-name] [-a|-w|-n] [-r] : 启动一个记录器
+
+                参数:
+                    - :logger-name: 记录器名称。当不指定时，选择名称为会话名称的记录器（会话默认记录器）
+                    - :-a|-w|-n: 记录器模式选择。 -a 为添加模式（未指定时默认值），在原记录文件后端添加； -w 为覆写模式，清空原记录文件并重新记录； -n 为新建模式，以名称和当前时间为参数，使用 name.now.log 形式创建新的记录文件
+                    - :-r: 指定记录器是否使用 raw 模式
+
+            - #log stop [logger-name] : 停止一个记录器
+                
+                参数:
+                    - :logger-name: 记录器名称。当不指定时，选择名称为会话名称的记录器（会话默认记录器）
+
+            - #log show [loggerFile]: 显示全部日志记录或指定记录文件
+
+                参数:
+                    - :loggerFile: 要显示的记录文件名称。当不指定时，弹出对话框列出当前目录下所有记录文件
+
+        示例:
+            - ``#log`` : 在当前会话窗口列出所有记录器状态
+            - ``#log start`` : 启动本会话默认记录器（记录器名为会话名）。该记录器以纯文本模式，将后续所有屏幕输出、键盘键入、命令输入等记录到 log 目录下 name.log 文件的后端
+            - ``#log start -r`` : 启动本会话默认记录器。该记录器以raw模式，将后续所有屏幕输出、键盘键入、命令输入等记录到 log 目录下 name.log 文件的后端
+            - ``#log start chat`` : 启动名为 chat 的记录器。该记录器以纯文本模式，记录代码中调用过该记录器 .log 进行记录的信息
+            - ``#log stop`` : 停止本会话默认记录器（记录器名为会话名）。
+
+        注意:
+            - 记录器文件模式（-a|-w|-n）在修改后，只有在下一次该记录器启动时才会生效
+            - 记录器记录模式（-r）在修改后立即生效
+        '''
+        
+        args = list()
+        if isinstance(code, CodeLine):
+            args = code.code[2:]
+
+        if len(args) == 0:
+            session_loggers = set(self._loggers.keys())
+            app_loggers = set(self.application.loggers.keys()).difference(session_loggers)
+            self.info("本会话中的记录器情况:")
+            for name in session_loggers:
+                logger = self.application.loggers[name]
+                self.info(f"记录器 {logger.name}, 当前状态: {'开启' if logger.enabled else '关闭'}, 文件模式: {logger.mode}, 记录模式: {'ANSI' if logger.raw else '纯文本'}")
+
+            if len(app_loggers) > 0:
+                self.info("本应用其他会话中的记录器情况:")
+                for name in app_loggers:
+                    logger = self.application.loggers[name]
+                    self.info(f"记录器 {logger.name}, 当前状态: {'开启' if logger.enabled else '关闭'}, 文件模式: {logger.mode}, 记录模式: {'ANSI' if logger.raw else '纯文本'}")
+
+        else:
+            name = self.name
+            if len(args) > 1 and not args[1].startswith('-'):
+                name = args[1]
+
+            if (args[0] == "start"):
+                if "-n" in args:
+                    mode = "n"
+                    mode_name = '新建'
+                elif "-w" in args:
+                    mode = "w"
+                    mode_name = '覆写'
+                else:
+                    mode = "a"
+                    mode_name = '添加'
+
+                raw = True if "-r" in args else False
+                raw_name = '原始ANSI' if raw else '纯文本'
+
+                logger = self.getLogger(name = name, mode = mode, raw = raw)
+                logger.enabled = True
+
+                self.info(f"{datetime.datetime.now()}: 记录器{name}以{mode_name}文件模式以及{raw_name}记录模式开启。")
+
+            elif (args[0] == "stop"):
+                self.info(f"{datetime.datetime.now()}: 记录器{name}记录已关闭。")
+                self.log.enabled = False
+
+            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} 不存在！')
+                    
+                else:
+                    self.application.show_logSelectDialog()
+