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

pymud/__init__.py

@@ -1,5 +1,6 @@
 from .settings import Settings
 from .pymud import PyMudApp
+from .modules import IConfig
 from .objects import CodeBlock, Alias, SimpleAlias, Trigger, SimpleTrigger, Command, SimpleCommand, Timer, SimpleTimer, GMCPTrigger
 from .extras import DotDict
 from .session import Session
@@ -7,5 +8,5 @@ from .logger import Logger
 from .main import main
 
 __all__ = [
-    "PyMudApp", "Settings", "CodeBlock", "Alias", "SimpleAlias", "Trigger", "SimpleTrigger", "Command", "SimpleCommand", "Timer", "SimpleTimer", "GMCPTrigger", "Session", "PyMudApp", "DotDict", "Logger", "main"
+    "IConfig", "PyMudApp", "Settings", "CodeBlock", "Alias", "SimpleAlias", "Trigger", "SimpleTrigger", "Command", "SimpleCommand", "Timer", "SimpleTimer", "GMCPTrigger", "Session", "PyMudApp", "DotDict", "Logger", "main"
 ]

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

@@ -0,0 +1,188 @@
+
+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):
+        result = True
+        if reload:
+            self._module = importlib.reload(self._module)
+        else:
+            self._module = importlib.import_module(self.name)
+        self._config = {}
+        for attr_name in dir(self._module):
+            attr = getattr(self._module, attr_name)
+            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, 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 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):
+        "只读属性，区分是否主模块（即包含具体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):
+        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

@@ -2,7 +2,8 @@
 MUD会话(session)中, 支持的对象列表
 """
 
-import asyncio, logging, re
+import asyncio, logging, re, importlib
+from abc import ABC, ABCMeta, abstractmethod
 from collections.abc import Iterable
 from collections import namedtuple
 from typing import Any
@@ -321,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__))
@@ -342,6 +348,8 @@ class BaseObject:
 
         self.log.debug(f"对象实例 {self} 创建成功.")
 
+        self.session.addObject(self)
+
     @property
     def enabled(self):
         "可读写属性，使能或取消使能本对象"
@@ -392,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):
     """
@@ -442,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):
     """
@@ -477,7 +487,7 @@ class MatchObject(BaseObject):
         super().__init__(session, patterns = patterns, *args, **kwargs)
 
     def __del__(self):
-        self.reset()
+        pass
 
     @property
     def patterns(self):
@@ -516,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:
@@ -587,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
@@ -616,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):
     """
@@ -646,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__()
@@ -697,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__()
@@ -983,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__()
@@ -1005,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