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

pymud/dialogs.py

@@ -1,7 +1,7 @@
 import asyncio, webbrowser
 
 from prompt_toolkit.layout import AnyContainer, ConditionalContainer, Float, VSplit, HSplit, Window, WindowAlign, ScrollablePane, ScrollOffsets
-from prompt_toolkit.widgets import Button, Dialog, Label, MenuContainer, MenuItem, TextArea, SystemToolbar, Frame, RadioList
+from prompt_toolkit.widgets import Button, Dialog, Label, MenuContainer, MenuItem, TextArea, SystemToolbar, Frame, RadioList 
 from prompt_toolkit.layout.dimension import Dimension, D
 from prompt_toolkit import ANSI, HTML
 from prompt_toolkit.mouse_events import MouseEvent, MouseEventType
@@ -133,12 +133,14 @@ class LogSelectionDialog(BasicDialog):
     def __init__(self, text, values, modal=True):
         self._header_text = text
         self._selection_values = values
-        self._radio_list = RadioList(values = self._selection_values)
+        self._itemsCount = len(values)
+        if len(values) > 0:
+            self._radio_list = RadioList(values = self._selection_values)
+        else:
+            self._radio_list = Label('无记录'.center(13))
         super().__init__('选择查看的记录', modal)
 
     def create_body(self) -> AnyContainer:
-        
-
         body=HSplit([
             Label(text = self._header_text, dont_extend_height=True), 
             self._radio_list
@@ -151,6 +153,9 @@ class LogSelectionDialog(BasicDialog):
         return [ok_button, cancel_button]
     
     def btn_ok_clicked(self):
-        result = self._radio_list.current_value
-        self.set_done(result)
+        if self._itemsCount:
+            result = self._radio_list.current_value
+            self.set_done(result)
+        else:
+            self.set_done(False)
     

pymud/extras.py

@@ -1,8 +1,7 @@
 # External Libraries
 from unicodedata import east_asian_width
 from wcwidth import wcwidth
-from typing import Any
-import time, datetime
+import time, re, logging
 
 from typing import Iterable
 from prompt_toolkit import ANSI
@@ -65,6 +64,10 @@ class MudFormatProcessor(Processor):
         self.FULL_BLOCKS = set("▂▃▅▆▇▄█")
         self.SINGLE_LINES = set("┌└├┬┼┴╭╰─")
         self.DOUBLE_LINES = set("╔╚╠╦╪╩═")
+        self.START_COLOR_REGX  = re.compile(r"^\[[\d;]+m")
+        self.COLOR_REGX   = re.compile(r"\[[\d;]+m")
+        self._color_start = ""
+        self._color_correction = False
 
     def width_correction(self, line: str) -> str:
         new_str = []
@@ -88,11 +91,36 @@ class MudFormatProcessor(Processor):
     def tab_correction(self, line: str):
         return line.replace("\t", " " * Settings.client["tabstop"])
 
+    def color_correction(self, line: str):
+        # 注：发现processer处理并非自上而下逐行处理的，因此不能使用这种颜色校正方式。
+        if self._color_correction:
+            other = self.COLOR_REGX.findall(line)
+
+            line = f"{self._color_start}{line}"
+            logging.debug(f"已校正增加颜色标志 {self._color_start}: {line}")
+
+            if other:
+                self._color_correction = False
+                self._color_start = ""
+                logging.debug(f"颜色校正结束: {line}")
+        else:
+            color = self.START_COLOR_REGX.findall(line)
+            if color:
+                other = self.COLOR_REGX.findall(line)
+                if len(other) == 1:
+                    self._color_correction = True
+                    self._color_start = color[0]
+                    logging.debug(f"获取到一个颜色开头 {color[0]}: {line}")
+
+        return line
+
     def line_correction(self, line: str):
         # 处理\r符号（^M）
         line = self.return_correction(line)
         # 处理Tab(\r)符号（^I）
         line = self.tab_correction(line)
+        # 处理颜色跨行问题。发现processer处理并非自上而下逐行处理的，因此不能使用这种颜色校正方式。
+        # line = self.color_correction(line)
         # 美化（解决中文英文在Console中不对齐的问题）
         if Settings.client["beautify"]:
             line = self.width_correction(line)
@@ -430,9 +458,9 @@ class SessionBufferControl(BufferControl):
 
                     if double_click:
                         start = buffer.document.translate_row_col_to_index(position.y, 0)
-                        end = buffer.document.translate_row_col_to_index(position.y, 10000000)
+                        end = buffer.document.translate_row_col_to_index(position.y + 1, 0) - 1
                         buffer.cursor_position = start
-                        buffer.start_selection(selection_type=SelectionType.CHARACTERS)
+                        buffer.start_selection(selection_type=SelectionType.LINES)
                         buffer.cursor_position = end
 
                 else:
@@ -1008,76 +1036,5 @@ class DotDict(dict):
     def __setstate__(self, state):
         self.update(state)
 
-import importlib
-import importlib.util
-
-class Plugin:
-    """
-    插件管理类。对加载的插件文件进行管理。该类型由PyMudApp进行管理，无需人工创建。
-
-    有关插件的详细信息，请参见 `插件 <plugins.html>`_
-
-    :param name: 插件的文件名, 如'myplugin.py'
-    :param location: 插件所在的目录。自动加载的插件包括PyMUD包目录下的plugins目录以及当前目录下的plugins目录
-
-    """
-    def __init__(self, name, location):
-        self._plugin_file = name
-        self._plugin_loc  = location
-
-        self.reload()
-
-    def reload(self):
-        "加载/重新加载插件对象"
-        #del self.modspec, self.mod
-        self.modspec = importlib.util.spec_from_file_location(self._plugin_file[:-3], self._plugin_loc)
-        self.mod     = importlib.util.module_from_spec(self.modspec)
-        self.modspec.loader.exec_module(self.mod)
-
-        self._app_init = self.mod.__dict__["PLUGIN_PYMUD_START"]
-        self._session_create = self.mod.__dict__["PLUGIN_SESSION_CREATE"]
-        self._session_destroy = self.mod.__dict__["PLUGIN_SESSION_DESTROY"]
-        
-    @property
-    def name(self):
-        "插件名称，由插件文件中的 PLUGIN_NAME 常量定义"
-        return self.mod.__dict__["PLUGIN_NAME"]
-    
-    @property
-    def desc(self):
-        "插件描述，由插件文件中的 PLUGIN_DESC 常量定义"
-        return self.mod.__dict__["PLUGIN_DESC"]
-    
-    @property
-    def help(self):
-        "插件帮助，由插件文件中的文档字符串定义"
-        return self.mod.__doc__
-    
-    def onAppInit(self, app):
-        """
-        PyMUD应用启动时对插件执行的操作，由插件文件中的 PLUGIN_PYMUD_START 函数定义
-
-        :param app: 启动的 PyMudApp 对象实例
-        """
-        self._app_init(app)
-
-    def onSessionCreate(self, session):
-        """
-        新会话创建时对插件执行的操作，由插件文件中的 PLUGIN_SESSION_CREATE 函数定义
-
-        :param session: 新创建的会话对象实例
-        """
-        self._session_create(session)
-
-    def onSessionDestroy(self, session):
-        """
-        会话关闭时（注意不是断开）对插件执行的操作，由插件文件中的 PLUGIN_SESSION_DESTROY 函数定义
-
-        :param session: 所关闭的会话对象实例
-        """
-        self._session_destroy(session)
 
-    def __getattr__(self, __name: str) -> Any:
-        if hasattr(self.mod, __name):
-            return self.mod.__getattribute__(__name)
         

pymud/logger.py

@@ -1,9 +1,10 @@
-import os, re, datetime, threading
+import os, re, datetime, threading, pathlib
 from queue import SimpleQueue, Empty
+from pathlib import Path
 
 class Logger:
     """
-    PyMUD 的记录器类型，可用于会话中向文件记录数据
+    PyMUD 的记录器类型，可用于会话中向文件记录数据。记录文件保存在当前目录下的 log 子目录中
     
     :param name: 记录器名称，各记录器名称应保持唯一。记录器名称会作为记录文件名称的主要参数
     :param mode: 记录模式。可选模式包括 a, w, n 三种。
@@ -56,7 +57,12 @@ class Logger:
                     now = datetime.datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
                     filename = f"{self.name}.{now}.log"
 
-                filename = os.path.abspath(filename)
+                logdir = Path.cwd().joinpath('log')
+                if not logdir.exists() or not logdir.is_dir():
+                    logdir.mkdir()
+
+                filename = logdir.joinpath(filename)
+                #filename = os.path.abspath(filename)
                 self._stream = open(filename, mode = mode, encoding = self._encoding, errors = self._errors)
                 self._thread = t = threading.Thread(target=self._monitor)
                 t.daemon = True

pymud/modules.py

@@ -1,11 +1,23 @@
 
-import importlib
+import importlib, importlib.util
 from abc import ABC, ABCMeta
+from typing import Any
+from .objects import BaseObject, Command
 
 class ModuleInfo:
+    """
+    模块管理类。对加载的模块文件进行管理。该类型由Session类进行管理，无需人工创建和干预。
+
+    有关模块的分类和使用的详细信息，请参见 `脚本 <scripts.html>`_
+
+    :param module_name: 模块的名称, 应与 import xxx 语法中的 xxx 保持一致
+    :param session: 加载/创建本模块的会话
+
+    """
     def __init__(self, module_name: str, session):
         self.session = session
         self._name = module_name 
+        self._ismainmodule = False
         self.load()
        
     def _load(self, reload = False):
@@ -20,61 +32,157 @@ class ModuleInfo:
             if isinstance(attr, type) and attr.__module__ == self._module.__name__:
                 if (attr_name == "Configuration") or issubclass(attr, IConfig):
                     try:
-                        self._config[f"{self.name}.{attr_name}"] = attr(self.session)
-                        self.session.info(f"配置对象 {self.name}.{attr_name} 创建成功.")
+                        self._config[f"{self.name}.{attr_name}"] = attr(self.session, reload = reload)
+                        self.session.info(f"配置对象 {self.name}.{attr_name} {'重新' if reload else ''}创建成功.")
                     except Exception as e:
                         result = False
                         self.session.error(f"配置对象 {self.name}.{attr_name} 创建失败. 错误信息为: {e}")
-
+        self._ismainmodule = (self._config != {})
         return result
     
     def _unload(self):
         for key, config in self._config.items():
-            if hasattr(config, "__unload__"):
-                unload = getattr(config, "__unload__", None)
-                if callable(unload): unload()
-                
-            if hasattr(config, "unload"):
-                unload = getattr(config, "unload", None)
-                if callable(unload): unload()
+            if isinstance(config, Command):
+                # Command 对象在从会话中移除时，自动调用其 unload 系列方法，因此不能产生递归
+                self.session.delObject(config)
+            
+            else:
+
+                if hasattr(config, "__unload__"):
+                    unload = getattr(config, "__unload__", None)
+                    if callable(unload): unload()
+                    
+                if hasattr(config, "unload"):
+                    unload = getattr(config, "unload", None)
+                    if callable(unload): unload()
+
+                if isinstance(config, BaseObject):
+                    self.session.delObject(config)
 
             del config
         self._config.clear()
 
     def load(self):
+        "加载模块内容"
         if self._load():
             self.session.info(f"{'主' if self.ismainmodule else '从'}配置模块 {self.name} 加载完成.")
         else:
             self.session.error(f"{'主' if self.ismainmodule else '从'}配置模块 {self.name} 加载失败.")
 
     def unload(self):
+        "卸载模块内容"
         self._unload()
+        self._loaded = False
         self.session.info(f"{'主' if self.ismainmodule else '从'}配置模块 {self.name} 卸载完成.")
 
     def reload(self):
+        "模块文件更新后调用，重新加载已加载的模块内容"
         self._unload()
         self._load(reload = True)
         self.session.info(f"{'主' if self.ismainmodule else '从'}配置模块 {self.name} 重新加载完成.")
 
     @property
     def name(self):
+        "只读属性，模块名称"
         return self._name
 
     @property
     def module(self):
+        "只读属性，模块文件的 ModuleType 对象"
         return self._module
     
     @property
     def config(self):
+        "只读字典属性，根据模块文件 ModuleType 对象创建的其中名为 Configuration 的类型或继承自 IConfig 的子类型实例（若有）"
         return self._config
     
     @property
     def ismainmodule(self):
-        return self._config != {}
+        "只读属性，区分是否主模块（即包含具体config的模块）"
+        return self._ismainmodule
 
 class IConfig(metaclass = ABCMeta):
+    """
+    用于提示PyMUD应用是否自动创建该配置类型的基础类（模拟接口）。
+    
+    继承 IConfig 类型让应用自动管理该类型，唯一需要的是，构造函数中，仅存在一个必须指定的参数 Session。
+
+    在应用自动创建 IConfig 实例时，除 session 参数外，还会传递一个 reload 参数 （bool类型），表示是首次加载还是重新加载特性。
+    可以从kwargs 中获取该参数，并针对性的设计相应代码。例如，重新加载相关联的其他模块等。
+    """
     def __init__(self, session, *args, **kwargs):
         self.session = session
 
     def __unload__(self):
-        self.session.delObject(self)
+        if self.session:
+            self.session.delObject(self)
+
+class Plugin:
+    """
+    插件管理类。对加载的插件文件进行管理。该类型由PyMudApp进行管理，无需人工创建。
+
+    有关插件的详细信息，请参见 `插件 <plugins.html>`_
+
+    :param name: 插件的文件名, 如'myplugin.py'
+    :param location: 插件所在的目录。自动加载的插件包括PyMUD包目录下的plugins目录以及当前目录下的plugins目录
+
+    """
+    def __init__(self, name, location):
+        self._plugin_file = name
+        self._plugin_loc  = location
+
+        self.reload()
+
+    def reload(self):
+        "加载/重新加载插件对象"
+        #del self.modspec, self.mod
+        self.modspec = importlib.util.spec_from_file_location(self._plugin_file[:-3], self._plugin_loc)
+        self.mod     = importlib.util.module_from_spec(self.modspec)
+        self.modspec.loader.exec_module(self.mod)
+
+        self._app_init = self.mod.__dict__["PLUGIN_PYMUD_START"]
+        self._session_create = self.mod.__dict__["PLUGIN_SESSION_CREATE"]
+        self._session_destroy = self.mod.__dict__["PLUGIN_SESSION_DESTROY"]
+        
+    @property
+    def name(self):
+        "插件名称，由插件文件中的 PLUGIN_NAME 常量定义"
+        return self.mod.__dict__["PLUGIN_NAME"]
+    
+    @property
+    def desc(self):
+        "插件描述，由插件文件中的 PLUGIN_DESC 常量定义"
+        return self.mod.__dict__["PLUGIN_DESC"]
+    
+    @property
+    def help(self):
+        "插件帮助，由插件文件中的文档字符串定义"
+        return self.mod.__doc__
+    
+    def onAppInit(self, app):
+        """
+        PyMUD应用启动时对插件执行的操作，由插件文件中的 PLUGIN_PYMUD_START 函数定义
+
+        :param app: 启动的 PyMudApp 对象实例
+        """
+        self._app_init(app)
+
+    def onSessionCreate(self, session):
+        """
+        新会话创建时对插件执行的操作，由插件文件中的 PLUGIN_SESSION_CREATE 函数定义
+
+        :param session: 新创建的会话对象实例
+        """
+        self._session_create(session)
+
+    def onSessionDestroy(self, session):
+        """
+        会话关闭时（注意不是断开）对插件执行的操作，由插件文件中的 PLUGIN_SESSION_DESTROY 函数定义
+
+        :param session: 所关闭的会话对象实例
+        """
+        self._session_destroy(session)
+
+    def __getattr__(self, __name: str) -> Any:
+        if hasattr(self.mod, __name):
+            return self.mod.__getattribute__(__name)

pymud/objects.py

@@ -322,7 +322,12 @@ class BaseObject:
     "内部缩写代码前缀"
 
     def __init__(self, session, *args, **kwargs):
-        self.session    = session
+        from .session import Session
+        if isinstance(session, Session):
+            self.session    = session
+        else:
+            assert("session must be an instance of class Session!")
+            
         self._enabled   = True              # give a default value
         self.log        = logging.getLogger(f"pymud.{self.__class__.__name__}")
         self.id         = kwargs.get("id", session.getUniqueID(self.__class__.__abbr__))
@@ -395,7 +400,8 @@ class BaseObject:
         return self.__detailed__()
     
     def __detailed__(self) -> str:
-        return f'<{self.__class__.__name__}> id = "{self.id}" group = "{self.group}" enabled = {self.enabled}'
+        group = f'group = "{self.group}" ' if self.group else ''
+        return f'<{self.__class__.__name__}> id = "{self.id}" {group}enabled = {self.enabled}'
 
 class GMCPTrigger(BaseObject):
     """
@@ -445,7 +451,8 @@ class GMCPTrigger(BaseObject):
             self._onSuccess(self.id, value, value_exp)
 
     def __detailed__(self) -> str:
-        return f'<{self.__class__.__name__}> name = "{self.id}" value = "{self.value}" group = "{self.group}" enabled = {self.enabled} '
+        group = f'group = "{self.group}" ' if self.group else ''
+        return f'<{self.__class__.__name__}> name = "{self.id}" value = "{self.value}" {group}enabled = {self.enabled} '
             
 class MatchObject(BaseObject):
     """
@@ -519,11 +526,11 @@ class MatchObject(BaseObject):
                 self._mline = 0
 
     def reset(self):
-        "复位事件，用于async执行未等待结果时，对事件的复位"
+        "复位事件，用于async执行未等待结果时，对事件的复位。仅异步有效。"
         self.event.clear()
 
     def set(self):
-        "设置事件标记，用于人工强制触发"
+        "设置事件标记，可以用于人工强制触发，仅在异步触发器下生效。"
         self.event.set()
 
     def match(self, line: str, docallback = True) -> BaseObject.State:
@@ -590,14 +597,16 @@ class MatchObject(BaseObject):
         state = BaseObject.State(result, self.id, "\n".join(self.lines), tuple(self.wildcards))
 
         # 采用回调方式执行的时候，执行函数回调（仅当self.sync和docallback均为真时才执行同步
-        if self.sync and docallback:
-            if state.result == self.SUCCESS:
-                self._onSuccess(state.id, state.line, state.wildcards)
-                self.event.set()
-            elif state.result == self.FAILURE:
-                self._onFailure(state.id, state.line, state.wildcards)
-            elif state.result == self.TIMEOUT:
-                self._onTimeout(state.id, state.line, state.wildcards)
+        # 当docallback为真时，是真正的进行匹配和触发，为false时，仅返回匹配结果，不实际触发
+        if docallback:
+            self.event.set()
+            if self.sync:
+                if state.result == self.SUCCESS:
+                    self._onSuccess(state.id, state.line, state.wildcards)
+                elif state.result == self.FAILURE:
+                    self._onFailure(state.id, state.line, state.wildcards)
+                elif state.result == self.TIMEOUT:
+                    self._onTimeout(state.id, state.line, state.wildcards)
 
         self.state = state
         return state
@@ -619,7 +628,8 @@ class MatchObject(BaseObject):
         return self.state
     
     def __detailed__(self) -> str:
-        return f'<{self.__class__.__name__}> id = "{self.id}" group = "{self.group}" enabled = {self.enabled} patterns = "{self.patterns}"'
+        group = f'group = "{self.group}" ' if self.group else ''
+        return f'<{self.__class__.__name__}> id = "{self.id}" {group}enabled = {self.enabled} patterns = "{self.patterns}"'
 
 class Alias(MatchObject):
     """
@@ -649,7 +659,8 @@ class SimpleAlias(Alias):
         self._codeblock.execute(self.session, id = id, line = line, wildcards = wildcards)
 
     def __detailed__(self) -> str:
-        return f'<{self.__class__.__name__}> id = "{self.id}" group = "{self.group}" enabled = {self.enabled} patterns = "{self.patterns}" code = "{self._code}"'
+        group = f'group = "{self.group}" ' if self.group else ''
+        return f'<{self.__class__.__name__}> id = "{self.id}" {group}enabled = {self.enabled} patterns = "{self.patterns}" code = "{self._code}"'
     
     def __repr__(self) -> str:
         return self.__detailed__()
@@ -700,7 +711,8 @@ class SimpleTrigger(Trigger):
         self._codeblock.execute(self.session, id = id, line = line, raw = raw, wildcards = wildcards)
 
     def __detailed__(self) -> str:
-        return f'<{self.__class__.__name__}> id = "{self.id}" group = "{self.group}" enabled = {self.enabled} patterns = "{self.patterns}" code = "{self._code}"'
+        group = f'group = "{self.group}" ' if self.group else ''
+        return f'<{self.__class__.__name__}> id = "{self.id}" {group}enabled = {self.enabled} patterns = "{self.patterns}" code = "{self._code}"'
     
     def __repr__(self) -> str:
         return self.__detailed__()
@@ -986,7 +998,8 @@ class Timer(BaseObject):
             self.startTimer()
 
     def __detailed__(self) -> str:
-        return f'<{self.__class__.__name__}> id = "{self.id}" group = "{self.group}" enabled = {self.enabled} timeout = {self.timeout}'
+        group = f'group = "{self.group}" ' if self.group else ''
+        return f'<{self.__class__.__name__}> id = "{self.id}" {group}enabled = {self.enabled} timeout = {self.timeout}'
     
     def __repr__(self) -> str:
         return self.__detailed__()
@@ -1008,5 +1021,6 @@ class SimpleTimer(Timer):
         self._codeblock.execute(self.session, id = id)
 
     def __detailed__(self) -> str:
-        return f'<{self.__class__.__name__}> id = "{self.id}" group = "{self.group}" enabled = {self.enabled} timeout = {self.timeout} code = "{self._code}"'
+        group = f'group = "{self.group}" ' if self.group else ''
+        return f'<{self.__class__.__name__}> id = "{self.id}" {group}enabled = {self.enabled} timeout = {self.timeout} code = "{self._code}"'
 

pymud/pymud.py

@@ -1,6 +1,6 @@
-import asyncio, functools, re, logging, math, json, os, webbrowser, threading
+import asyncio, functools, re, os, webbrowser, threading
 from datetime import datetime
-import importlib.util
+from pathlib import Path
 from prompt_toolkit.shortcuts import set_title, radiolist_dialog
 from prompt_toolkit.output import ColorDepth
 from prompt_toolkit.clipboard.pyperclip import PyperclipClipboard
@@ -36,7 +36,8 @@ from prompt_toolkit.layout.processors import (
 from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
 
 from .objects import CodeBlock
-from .extras import MudFormatProcessor, SessionBuffer, EasternMenuContainer, VSplitWindow, SessionBufferControl, DotDict, Plugin
+from .extras import MudFormatProcessor, SessionBuffer, EasternMenuContainer, VSplitWindow, SessionBufferControl, DotDict
+from .modules import Plugin
 from .session import Session
 from .settings import Settings
 from .dialogs import MessageDialog, WelcomeDialog, QueryDialog, NewSessionDialog, LogSelectionDialog
@@ -92,6 +93,7 @@ class PyMudApp:
         self._mouse_support = True
         self._plugins  = DotDict()              # 增加 插件 字典
         self._globals  = DotDict()              # 增加所有session使用的全局变量
+        self._onTimerCallbacks = dict()
         self.sessions = {}
         self.current_session = None
         self.status_display = STATUS_DISPLAY(Settings.client["status_display"])
@@ -149,6 +151,24 @@ class PyMudApp:
 
         self.load_plugins()
 
+    async def onSystemTimerTick(self):
+        while True:
+            await asyncio.sleep(1)
+            self.app.invalidate()
+            for callback in self._onTimerCallbacks.values():
+                if callable(callback):
+                    callback()
+
+    def addTimerTickCallback(self, name, func):
+        '注册一个系统定时器回调，每1s触发一次。指定name为回调函数关键字，func为回调函数。'
+        if callable(func) and (not name in self._onTimerCallbacks.keys()):
+            self._onTimerCallbacks[name] = func
+
+    def removeTimerTickCallback(self, name):
+        '从系统定时器回调中移除一个回调函数。指定name为回调函数关键字。'
+        if name in self._onTimerCallbacks.keys():
+            self._onTimerCallbacks.pop(name)
+
     def initUI(self):
         """初始化UI界面"""
         self.style = Style.from_dict(Settings.styles)
@@ -567,6 +587,7 @@ class PyMudApp:
             log_list = list()
             files = [f for f in os.listdir('.') if os.path.isfile(f) and f.endswith('.log')]
             for file in files:
+                file = os.path.abspath(file)
                 filename = os.path.basename(file).ljust(20)
                 filesize = f"{os.path.getsize(file):,} Bytes".rjust(20)
                 # ctime   = datetime.fromtimestamp(os.path.getctime(file)).strftime('%Y-%m-%d %H:%M:%S').rjust(23)
@@ -574,6 +595,19 @@ class PyMudApp:
                 
                 file_display_line = "{}{}{}".format(filename, filesize, mtime)
                 log_list.append((file, file_display_line))
+
+            logDir = os.path.abspath(os.path.join(os.curdir, 'log'))
+            if os.path.exists(logDir):
+                files = [f for f in os.listdir(logDir) if f.endswith('.log')]
+                for file in files:
+                    file = os.path.join(logDir, file)
+                    filename = ('log/' + os.path.basename(file)).ljust(20)
+                    filesize = f"{os.path.getsize(file):,} Bytes".rjust(20)
+                    # ctime   = datetime.fromtimestamp(os.path.getctime(file)).strftime('%Y-%m-%d %H:%M:%S').rjust(23)
+                    mtime   = datetime.fromtimestamp(os.path.getmtime(file)).strftime('%Y-%m-%d %H:%M:%S').rjust(23)
+                    
+                    file_display_line = "{}{}{}".format(filename, filesize, mtime)
+                    log_list.append((file, file_display_line))
             
             dialog = LogSelectionDialog(
                 text = head_line,
@@ -1130,16 +1164,17 @@ class PyMudApp:
 
     async def run_async(self):
         "以异步方式运行本程序"
-        await self.app.run_async()
+        asyncio.create_task(self.onSystemTimerTick())
+        await self.app.run_async(set_exception_handler = False)
 
     def run(self):
         "运行本程序"
-        self.app.run()
-        #asyncio.run(self.run_async())
+        #self.app.run(set_exception_handler = False)
+        asyncio.run(self.run_async())
 
     def get_width(self):
-        "获取ConsoleView的实际宽度，等于输出宽度-4,（左右线条宽度, 滚动条宽度，右边让出的1列）"
-        size = self.app.output.get_size().columns - 4
+        "获取ConsoleView的实际宽度，等于输出宽度,（已经没有左右线条和滚动条了）"
+        size = self.app.output.get_size().columns
         if Settings.client["status_display"] == 2:
             size = size - Settings.client["status_width"] - 1
         return size

pymud/session.py

@@ -4,9 +4,9 @@ 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
@@ -100,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):
@@ -558,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:
@@ -653,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:
@@ -764,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")
 
@@ -773,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")
 
@@ -1280,6 +1282,8 @@ class Session:
         """
         从会话中移除一个对象，可直接删除 Alias, Trigger, GMCPTrigger, Command, Timer 或它们的子类本身
         
+        ** 注 ** 现在 delObject 和 delObjects 使用结果相同，都可以清除单个对象、对个对象的list, tuple或dict, 可以有效防止代码写错
+
         :param obj: 要删除的多个特定对象组成的元组、列表或者字典，可以为 Alias, Trigger, GMCPTrigger, Command, Timer 或其子类
 
         示例:
@@ -1316,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 或它们的子类
 
         示例:
@@ -1351,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):
         """
         向会话中增加多个别名
@@ -1952,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
@@ -1960,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)
@@ -1975,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)
 
@@ -2035,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
@@ -2058,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), "全局变量")
             
@@ -2714,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} 既未找到模块，也未找到插件，重新加载失败..")
 
@@ -2855,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 之后的所有内容
@@ -2878,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):
         '''
@@ -2934,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):
         '''
@@ -3054,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):
@@ -3113,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`` : 停止本会话默认记录器（记录器名为会话名）。
 
@@ -3172,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 作者"

{pymud-0.20.0a5.dist-info → pymud-0.20.1.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: pymud
-Version: 0.20.0a5
+Version: 0.20.1
 Summary: a MUD Client written in Python
-Author-email: "newstart@pkuxkx" <crapex@crapex.cc>
-Maintainer-email: "newstart@pkuxkx" <crapex@crapex.cc>
+Author-email: "newstart@pkuxkx" <crapex@hotmail.com>
+Maintainer-email: "newstart@pkuxkx" <crapex@hotmail.com>
 License: GNU GENERAL PUBLIC LICENSE
                                Version 3, 29 June 2007
         
@@ -684,7 +684,7 @@ Project-URL: Bug Reports, https://github.com/crapex/pymud/issues
 Project-URL: Source, https://github.com/crapex/pymud/
 Project-URL: document, https://pymud.readthedocs.io/
 Keywords: MUD,multi-user dungeon,client
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: End Users/Desktop
 Classifier: Topic :: Games/Entertainment :: Multi-User Dungeons (MUD)
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
@@ -707,7 +707,7 @@ Requires-Dist: prompt-toolkit
 # PyMUD - Python原生MUD客户端
 ## 简介
 
-### 帮助文件见北侠WIKI：  https://www.pkuxkx.net/wiki/tools/pymud
+### 北侠WIKI：  https://www.pkuxkx.net/wiki/tools/pymud
 ### 源代码地址: https://github.com/crapex/pymud
 ### 帮助文档地址： https://pymud.readthedocs.org
 ### PyPi项目地址： https://pypi.org/project/pymud
@@ -729,9 +729,20 @@ Requires-Dist: prompt-toolkit
 + Python拥有极为丰富的第三方库，能支持的第三方库，就能在PyMud中支持
 + 我自己还在玩，所以本客户端会持续进行更新:)
 
+### 哪些人适合使用PyMUD
++ 比较熟悉Python语言，会使用Python写代码的 -> PyMUD是纯Python原生开发，不会有其他客户端对Python的支持能比得过PyMUD
++ 虽不太熟悉Python语言，但有想法想学习Python语言的 -> 正好使用PyMUD玩北侠写脚本的过程中学习Python语言
++ 觉得还有些功能现在所有客户端都没有的 -> 你有需求，我来增加，就是这么方便
++ 觉得也想自己整一个定制客户端玩玩的 -> PyMUD完全开源，且除ui框架外全部都是一行一行代码自己写的，可以直接参考PyMUD的设计
+
 ## 版本更新信息
 
-## 0.20.0 (2024-08-XX)
+### 0.20.1 (2024-11-16)
++ 功能调整: 会话中触发器匹配实现进行部分调整，减少循环次数以提高响应速度
++ 功能调整: #test / #show 触发器测试功能调整，现在会对使能的和未使能的触发器均进行匹配测试。其中，#show 命令仅测试，而 #test 命令会导致触发器真正响应。
++ 功能新增: pymud对象新增了一个持续运行的1s的周期定时任务。该任务中会刷新页面显示。可以使用 session.application.addTimerTickCallback 和 session.application.removeTimerTickCallback 来注册和解除定时器回调。
+
+## 0.20.0 (2024-08-25)
 + 功能调整: 将模块主入口函数从__main__.py中移动到main.py中，以使可以在当前目录下，可直接使用pymud，也可使用python -m pymud启动
 + 功能调整: 使用argsparser标准模块来配置命令行，可以使用 pymud -h 查看命令行具体参数及说明
 + 功能新增: 命令行参数增加指定启动目录的功能，参数为 -s, --startup_dir。即可以从任意目录通过指定脚本目录方式启动PyMUD了。
@@ -768,11 +779,6 @@ Requires-Dist: prompt-toolkit
     - 使用示例:
 
     ```Python
-        # 所有对象均可以使用 addObject 直接添加到会话中，而不用管是什么具体类型
-        session.addObject(Timer(...))
-        session.addObject(Trigger(...))
-        session.addObject(Alias(...))
-
         # 所有对象均可以使用 delObject 直接从会话中移除，会自动根据对象类型推断，无需通过函数名区分
         session.delObject(self.tri1)
         session.delObject(self.ali1)
@@ -786,7 +792,6 @@ Requires-Dist: prompt-toolkit
             GMCPTrigger(session, xxx)
         ]
 
-        session.addObjects(objs)    # 可以直接将一个数组中所有对象添加到会话中，会自动判断各对象类别
         session.delObjects(objs)    # 可以直接从会话中移除一个数组中的所有对象，会自动判断对象类别
     ```
 
@@ -795,7 +800,9 @@ Requires-Dist: prompt-toolkit
     - 例如， result = await self.session.cmds.cmd_runto.execute('rt yz') 与 result = await self.session.exec_async('rt yz') 等价，返回值相同
     - 但     result = await self.session.exec_async('rt yz;dzt')，该返回的result 仅是 dzt 命令的 execute 的返回值。 rt yz 命令返回值被丢弃。
 + 功能新增: 增加临时变量概念，变量名以下划线开头的为临时变量，此类变量不会被保存到 .mud 文件中。
-
++ 功能新增: 为 BaseObject 基类的 self.session 增加了 Session 类型限定，现在自定义 Command 等时候，使用 self.session 时会有 IntelliSence 函数智能提示了，所有帮助说明已补全
++ 问题修复: 修复 #var 等命令中，若含有中文则等号位置不对齐的问题
++ 功能调整: 在 #tri 等命令中，当对象的 group 为空时，将不再显示 group 属性，减少无用信息
 
 ## 0.19.4 (2024-04-20)
 + 功能调整: info 现在 msg 恢复为可接受任何类型参数，不一定是 str

pymud-0.20.1.dist-info/RECORD

@@ -0,0 +1,19 @@
+pymud/__init__.py,sha256=AP4Edhx90gMKrNfD1O_KVciA3SOnyX5Qt9fZY_JhsTY,574
+pymud/__main__.py,sha256=hFzZjadLlcOuoLM7D8wFiFVO8mqF7vMuo9y-9xfIhRc,64
+pymud/dialogs.py,sha256=p-LidObSuDyOeMif5CsqhF5qq3rizZ1lmThWHrxDyRg,6726
+pymud/extras.py,sha256=Gr-gX7YRWZMmeKV73sk7h_Gf5eZVJ6GcAXvSEfJ4uMI,41124
+pymud/logger.py,sha256=gtGm8y9RY_CpRpJ0udgKknRxyjsEPrrRyWecUDgBgZM,5662
+pymud/main.py,sha256=b_Ui_cN4W8IfhYNyc1duwr3Bp7pYYZQusKTSafCWZIA,6534
+pymud/modules.py,sha256=XoqTeYfZCgqDsV3SYxeehzsbkTzs0swelAUIxyWuL9g,7423
+pymud/objects.py,sha256=hJc_GfvSUcAqXSHIWKlOg8yOKHnCK9aaoWDwAuP1YtA,39377
+pymud/pkuxkx.py,sha256=jRQRUs2xtw7GzYHtLYZXOASnqMumKh0iCoOeKZs8NnU,11467
+pymud/protocol.py,sha256=QfDXjlg2OcJXmVoXf_3mAemnYotRXDUlEZNQjhkfXdA,49106
+pymud/pymud.py,sha256=pkTb21UV2ccYhG44JjfGdvUSPIWbu_y-vUwBqqzeHaM,51425
+pymud/session.py,sha256=GAxenTtUy75A-LAfznMOx753BWd-tyozgngeNdJux4Q,135208
+pymud/settings.py,sha256=ZsKGkjcNGNwqeb2DztwhIrCcRDPYYN1SxtdjWNAJ9CY,7145
+pymud-0.20.1.dist-info/LICENSE.txt,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+pymud-0.20.1.dist-info/METADATA,sha256=Mhl90M3VE2V8zoZ82q5ySzDIknD2XNWlXPdxSvoNuF8,74344
+pymud-0.20.1.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
+pymud-0.20.1.dist-info/entry_points.txt,sha256=diPUOtTkhgC1hVny7Cdg4aRhaHSynMQoraE7ZhJxUcw,37
+pymud-0.20.1.dist-info/top_level.txt,sha256=8Gp1eXjxixXjqhhti6tLCspV_8s9sNV3z5Em2_KRhD4,6
+pymud-0.20.1.dist-info/RECORD,,

{pymud-0.20.0a5.dist-info → pymud-0.20.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (73.0.1)
+Generator: setuptools (75.5.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pymud-0.20.0a5.dist-info/RECORD

@@ -1,19 +0,0 @@
-pymud/__init__.py,sha256=AP4Edhx90gMKrNfD1O_KVciA3SOnyX5Qt9fZY_JhsTY,574
-pymud/__main__.py,sha256=hFzZjadLlcOuoLM7D8wFiFVO8mqF7vMuo9y-9xfIhRc,64
-pymud/dialogs.py,sha256=D0ZtCeoBchF5eYzXumkOi3p-maCQZu4v9-wJgxQ790o,6500
-pymud/extras.py,sha256=QwWwLavVtuXfg0Qb0f_040va1_kej27P-ZB_19HB6Qk,42422
-pymud/logger.py,sha256=elYfbpvmKYJfB-rnPYZWY5r8ROu9yja9t-dBi1faRGc,5358
-pymud/main.py,sha256=b_Ui_cN4W8IfhYNyc1duwr3Bp7pYYZQusKTSafCWZIA,6534
-pymud/modules.py,sha256=GoNmGnMfi2BEsonJA4iq-unkgHkZRR-XBr1Wix_3-a4,2756
-pymud/objects.py,sha256=5lx9Z9ijrwpqy2KNJu0OyUxXVh_VVYP2PTE82inAW9c,38623
-pymud/pkuxkx.py,sha256=jRQRUs2xtw7GzYHtLYZXOASnqMumKh0iCoOeKZs8NnU,11467
-pymud/protocol.py,sha256=QfDXjlg2OcJXmVoXf_3mAemnYotRXDUlEZNQjhkfXdA,49106
-pymud/pymud.py,sha256=N9WxaHDqqsTWIBG8UJ38gdMC_pQ30wphcN2LtT66eA4,49584
-pymud/session.py,sha256=3u_ctb3ev5MPYfB7-vrLDd9ag9yw1z-K24hQ40hSrME,129365
-pymud/settings.py,sha256=CRNpHl4RjOuQYzAIWyUEvOo7q-f4lo01X1v_CriHWO4,7145
-pymud-0.20.0a5.dist-info/LICENSE.txt,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-pymud-0.20.0a5.dist-info/METADATA,sha256=kaZCuQ8_FyybVKP0c7ksj_jk_qksVwda-YEgSCsmqT4,73061
-pymud-0.20.0a5.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
-pymud-0.20.0a5.dist-info/entry_points.txt,sha256=diPUOtTkhgC1hVny7Cdg4aRhaHSynMQoraE7ZhJxUcw,37
-pymud-0.20.0a5.dist-info/top_level.txt,sha256=8Gp1eXjxixXjqhhti6tLCspV_8s9sNV3z5Em2_KRhD4,6
-pymud-0.20.0a5.dist-info/RECORD,,