pymud 0.19.3.post2__py3-none-any.whl → 0.20.0__py3-none-any.whl

pymud/__init__.py

@@ -1,8 +1,12 @@
 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
+from .logger import Logger
+from .main import main
 
 __all__ = [
-    "Settings", "CodeBlock", "Alias", "SimpleAlias", "Trigger", "SimpleTrigger", "Command", "SimpleCommand", "Timer", "SimpleTimer", "GMCPTrigger", "Session", "PyMudApp", "DotDict"
+    "IConfig", "PyMudApp", "Settings", "CodeBlock", "Alias", "SimpleAlias", "Trigger", "SimpleTrigger", "Command", "SimpleCommand", "Timer", "SimpleTimer", "GMCPTrigger", "Session", "PyMudApp", "DotDict", "Logger", "main"
 ]

pymud/__main__.py

@@ -1,102 +1,4 @@
-import sys, os, json, platform, shutil, logging
-from .pymud import main
-from .settings import Settings
-
-CFG_TEMPLATE = {
-    "client": {
-        "buffer_lines"      : 5000,                 # 保留缓冲行数
-
-        "interval"          : 10,                   # 在自动执行中，两次命令输入中的间隔时间（ms）
-        "auto_connect"      : True,                 # 创建会话后，是否自动连接
-        "auto_reconnect"    : False,                # 在会话异常断开之后，是否自动重连
-        "var_autosave"      : True,                 # 断开时自动保存会话变量
-        "var_autoload"      : True,                 # 初始化时自动加载会话变量
-
-        "echo_input"        : False,
-        "beautify"          : True,                 # 专门为解决控制台下PKUXKX字符画对不齐的问题
-
-        "status_display"    : 1,                    # 状态窗口显示情况设置，0-不显示，1-显示在下方，2-显示在右侧
-        "status_height"     : 4,                    # 下侧状态栏的高度
-        "status_width"      : 30,                   # 右侧状态栏的宽度
-
-    },
-    "sessions" : {
-        "pkuxkx" : {
-            "host" : "mud.pkuxkx.net",
-            "port" : "8081",
-            "encoding" : "utf8",
-            "autologin" : "{0};{1}",
-            "default_script": "examples",
-            "chars" : {
-                "display_title" : ["yourid", "yourpassword", ""],
-            }
-        }
-    },
-    "keys" : {
-        "f3"    : "#ig",
-        "f4"    : "#clear",
-        "f11"   : "#close",
-        "f12"   : "#exit",
-    }
-}
+from .main import main
 
 if __name__ == "__main__":
-    args = sys.argv
-    if (len(args) == 2) and (args[1] == "init"):
-        print(f"欢迎使用PyMUD, 版本{Settings.__version__}. 使用PyMUD时, 建议建立一个新目录（任意位置），并将自己的脚本以及配置文件放到该目录下.")
-        print("即将开始为首次运行初始化环境...")
-        uname = platform.uname()
-        system  = uname[0].lower()
-        if system == "windows":
-            dir = input("检测到当前系统为Windows, 请指定游戏脚本的目录（若目录不存在会自动创建），直接回车表示使用默认值[d:\pkuxkx\]:")
-            if not dir: dir = "d:\\pkuxkx\\"
-        elif system == "linux":
-            dir = input("检测到当前系统为Linux, 请指定游戏脚本的目录（若目录不存在会自动创建），直接回车表示使用默认值[~/pkuxkx/]:")
-            if not dir: dir = "~/pkuxkx/"
-
-        if not os.path.exists(dir):
-            print(f'检测到给定目录 {dir} 不存在，正在创建目录...', end = "")
-            os.mkdir(dir)
-            os.chdir(dir)
-            print(f'完成!')
-
-        if os.path.exists('pymud.cfg'):
-            print(f'检测到脚本目录下已存在pymud.cfg文件，将直接使用此文件进入PyMUD...')
-        else:
-            print(f'检测到脚本目录下不存在pymud.cfg文件，将使用默认内容创建该配置文件...')
-            with open('pymud.cfg', mode = 'x') as fp:
-                fp.writelines(json.dumps(CFG_TEMPLATE, indent = 4))
-
-        if not os.path.exists('examples.py'):
-            from pymud import pkuxkx
-            module_dir = pkuxkx.__file__
-            shutil.copyfile(module_dir, 'examples.py')
-            print(f'已将样例脚本拷贝至脚本目录，并加入默认配置文件')
-
-        print(f"后续可自行修改 {dir} 目录下的 pymud.cfg 文件以进行配置。")
-        if system == "linux":
-            print(f"后续运行PyMUD， 请在 {dir} 目录下键入命令： python3 -m pymud")
-        else:
-            print(f"后续运行PyMUD， 请在 {dir} 目录下键入命令： python -m pymud")
-
-        input('所有内容已初始化完毕, 请按回车进入PyMUD.')
-
-    if (len(args) == 2) and (args[1] == "withlog"):
-        # 指定带log时，打印log信息
-        # 所有级别log都存入文件
-        logging.basicConfig(level=logging.NOTSET,
-                            format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s',
-                            datefmt='%m-%d %H:%M',
-                            filename='myapp.log',
-                            filemode='a')
-        
-    else:
-        logging.disable()
-
-    cfg = "pymud.cfg"
-    if os.path.exists(cfg):
-        with open(cfg, "r", encoding="utf8", errors="ignore") as fp:
-            cfg_data = json.load(fp)
-            main(cfg_data)
-    else:
-        main()
+    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
+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
@@ -127,3 +127,35 @@ class NewSessionDialog(BasicDialog):
         encoding = get_app().layout.get_buffer_by_name("encoding").text
         result = (name, host, port, encoding)
         self.set_done(result)
+
+
+class LogSelectionDialog(BasicDialog):
+    def __init__(self, text, values, modal=True):
+        self._header_text = text
+        self._selection_values = 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
+            ])
+        return body
+    
+    def create_buttons(self):
+        ok_button = EasternButton(text="确定", handler=self.btn_ok_clicked)
+        cancel_button = EasternButton(text="取消", handler=(lambda: self.set_done(False)))
+        return [ok_button, cancel_button]
+    
+    def btn_ok_clicked(self):
+        if self._itemsCount:
+            result = self._radio_list.current_value
+            self.set_done(result)
+        else:
+            self.set_done(False)
+    

pymud/extras.py

@@ -1,7 +1,6 @@
 # External Libraries
 from unicodedata import east_asian_width
 from wcwidth import wcwidth
-from typing import Any
 import time
 
 from typing import Iterable
@@ -434,6 +433,7 @@ class SessionBufferControl(BufferControl):
                         buffer.cursor_position = start
                         buffer.start_selection(selection_type=SelectionType.CHARACTERS)
                         buffer.cursor_position = end
+
                 else:
                     # Don't handle scroll events here.
                     return NotImplemented
@@ -1007,75 +1007,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

@@ -0,0 +1,160 @@
+import os, re, datetime, threading, pathlib
+from queue import SimpleQueue, Empty
+from pathlib import Path
+
+class Logger:
+    """
+    PyMUD 的记录器类型，可用于会话中向文件记录数据。记录文件保存在当前目录下的 log 子目录中
+    
+    :param name: 记录器名称，各记录器名称应保持唯一。记录器名称会作为记录文件名称的主要参数
+    :param mode: 记录模式。可选模式包括 a, w, n 三种。
+       - a为添加模式，当新开始记录时，会添加在原有记录文件（name.log）之后。
+       - w为覆写模式，当新开始记录时，会覆写原记录文件（name.log）。
+       - n为新建模式，当新开始记录时，会以name和当前时间为参数新建一个文件（name.now.log）用于记录。
+    :param encoding: 记录文件的编码格式，默认为 "utf-8"
+    :param errors: 当编码模式失败时的处理方式，默认为 "ignore"
+    :param raw: 记录带ANSI标记的原始内容，还是记录纯文本内容，默认为True，即记录带ANSI标记的原始内容。
+    """
+
+    _esc_regx = re.compile(r"\x1b\[[\d;]+[abcdmz]", flags = re.IGNORECASE)
+
+    def __init__(self, name, mode = 'a', encoding = "utf-8", errors = "ignore", raw = False):
+        self._name = name
+        self._enabled = False
+        self._raw = raw
+        self.mode = mode
+        self._encoding = encoding
+        self._errors = errors
+        self._lock = threading.RLock()
+        self._stream = None
+        
+        self._queue = SimpleQueue()
+
+    @property
+    def name(self):
+        "记录器名称，仅在创建时设置，过程中只读"
+        return self._name
+
+    @property
+    def enabled(self):
+        """
+        使能属性。
+        从false切换到true时，会打开文件，创建后台线程进行记录。
+        从true切换到false时，会终止后台记录线程，并关闭记录文件。
+        """
+        return self._enabled
+
+    @enabled.setter
+    def enabled(self, enabled):
+        if self._enabled != enabled:
+            if enabled:
+                mode = "a"
+
+                if self._mode in ("a", "w"):
+                    filename = f"{self.name}.log"
+                    mode = self._mode
+                elif self._mode == "n":
+                    now = datetime.datetime.now().strftime("%Y_%m_%d_%H_%M_%S")
+                    filename = f"{self.name}.{now}.log"
+
+                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
+                t.start()
+
+            else:
+                self._queue.put_nowait(None)
+                self._thread.join()
+                self._thread = None
+                self._closeFile()
+
+            self._enabled = enabled
+
+    @property
+    def raw(self):
+        "属性，设置和获取是否记录带有ANSI标记的原始记录"
+        return self._raw
+    
+    @raw.setter
+    def raw(self, val: bool):
+        self._raw = val
+
+    @property
+    def mode(self):
+        "属性，记录器模式，可为 a, w, n"
+        return self._mode
+    
+    @mode.setter
+    def mode(self, value):
+        if value in ("a", "w", "n"):
+            self._mode = value
+
+    def _closeFile(self):
+        """
+        Closes the stream.
+        """
+        self._lock.acquire()
+        try:
+            if self._stream:
+                try:
+                    self._stream.flush()
+                finally:
+                    stream = self._stream
+                    self._stream = None
+                    stream.close()
+        finally:
+            self._lock.release()
+
+    def log(self, msg):
+        """
+        向记录器记录信息。记录的信息会通过队列发送到独立的记录线程。
+        当记录器未使能时，使用该函数调用也不会记录。
+        
+        :param msg: 要记录的信息
+        """
+        if self._enabled:
+            self._queue.put_nowait(msg)
+
+    def _monitor(self):
+        """
+        Monitor the queue for records, and ask the handler
+        to deal with them.
+
+        This method runs on a separate, internal thread.
+        The thread will terminate if it sees a sentinel object in the queue.
+        """
+        newline = True
+        while True:
+            try:
+                data = self._queue.get(block = True)
+                if data:
+                    self._lock.acquire()
+
+                    if newline:
+                        now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                        header = f"{now} {self._name}: "
+                        self._stream.write(header)
+                        newline = False
+
+                    if data.endswith("\n"):
+                        data = data.rstrip("\n").rstrip("\r") + "\n"
+                        newline = True
+
+                    if not self._raw:
+                        data = self._esc_regx.sub("", data)
+
+                    self._stream.write(data)
+
+                    self._stream.flush()
+                    self._lock.release()
+
+                else:
+                    break
+            except Empty:
+                break

pymud/main.py

@@ -0,0 +1,142 @@
+import os, sys, json, platform, shutil, logging, argparse
+from pathlib import Path
+from .pymud import PyMudApp
+from .settings import Settings
+
+CFG_TEMPLATE = {
+    "client": {
+        "buffer_lines"      : 5000,                 # 保留缓冲行数
+
+        "interval"          : 10,                   # 在自动执行中，两次命令输入中的间隔时间（ms）
+        "auto_connect"      : True,                 # 创建会话后，是否自动连接
+        "auto_reconnect"    : False,                # 在会话异常断开之后，是否自动重连
+        "var_autosave"      : True,                 # 断开时自动保存会话变量
+        "var_autoload"      : True,                 # 初始化时自动加载会话变量
+
+        "echo_input"        : False,
+        "beautify"          : True,                 # 专门为解决控制台下PKUXKX字符画对不齐的问题
+
+        "status_display"    : 1,                    # 状态窗口显示情况设置，0-不显示，1-显示在下方，2-显示在右侧
+        "status_height"     : 4,                    # 下侧状态栏的高度
+        "status_width"      : 30,                   # 右侧状态栏的宽度
+
+    },
+    "sessions" : {
+        "pkuxkx" : {
+            "host" : "mud.pkuxkx.net",
+            "port" : "8081",
+            "encoding" : "utf8",
+            "autologin" : "{0};{1}",
+            "default_script": "examples",
+            "chars" : {
+                "display_title" : ["yourid", "yourpassword", ""],
+            }
+        }
+    },
+    "keys" : {
+        "f3"    : "#ig",
+        "f4"    : "#clear",
+        "f11"   : "#close",
+        "f12"   : "#exit",
+    }
+}
+
+def init_pymud_env(args):
+    print(f"欢迎使用PyMUD, 版本{Settings.__version__}. 使用PyMUD时, 建议建立一个新目录（任意位置），并将自己的脚本以及配置文件放到该目录下.")
+    print("即将开始为首次运行初始化环境...")
+    
+    dir = args.dir
+    if dir:
+        print(f"你已经指定了创建脚本的目录为 {args.dir}")
+        dir = Path(dir)
+    else:
+        dir = Path.home().joinpath('pkuxkx')
+
+        system = platform.system().lower()
+        dir_enter = input(f"检测到当前系统为 {system}, 请指定游戏脚本的目录（若目录不存在会自动创建），直接回车表示使用默认值 [{dir}]:")
+        if dir_enter:
+            dir = Path(dir_enter)
+                      
+    if dir.exists() and dir.is_dir():
+        print(f'检测到给定目录 {dir} 已存在，切换至此目录...')
+    else:
+        print(f'检测到给定目录 {dir} 不存在，正在创建并切换至目录...')
+        dir.mkdir()
+    
+    os.chdir(dir)
+
+    if os.path.exists('pymud.cfg'):
+        print(f'检测到脚本目录下已存在pymud.cfg文件，将直接使用此文件进入PyMUD...')
+    else:
+        print(f'检测到脚本目录下不存在pymud.cfg文件，将使用默认内容创建该配置文件...')
+        with open('pymud.cfg', mode = 'x') as fp:
+            fp.writelines(json.dumps(CFG_TEMPLATE, indent = 4))
+
+    if not os.path.exists('examples.py'):
+        from pymud import pkuxkx
+        module_dir = pkuxkx.__file__
+        shutil.copyfile(module_dir, 'examples.py')
+        print(f'已将样例脚本拷贝至脚本目录，并加入默认配置文件')
+
+    print(f"后续可自行修改 {dir} 目录下的 pymud.cfg 文件以进行配置。")
+    if system == "windows":
+        print(f"后续运行PyMUD， 请在 {dir} 目录下键入命令： python -m pymud")
+    else:
+        print(f"后续运行PyMUD， 请在 {dir} 目录下键入命令： python3 -m pymud")
+
+    input('所有内容已初始化完毕, 请按回车进入PyMUD.')
+
+    startApp(args)
+
+def startApp(args):
+    startup_path = Path(args.startup_dir).resolve()
+    sys.path.append(f"{startup_path}")
+    os.chdir(startup_path)
+
+    if args.debug:
+        logging.basicConfig(level = logging.NOTSET,
+            format = '%(asctime)s %(name)-12s %(levelname)-8s %(message)s',
+            datefmt = '%m-%d %H:%M',
+            filename = args.logfile,
+            filemode = 'a' if args.filemode else 'w',
+            encoding = "utf-8"
+            )
+        
+    else:
+        logging.basicConfig(level = logging.NOTSET,
+            format = '%(asctime)s %(name)-12s: %(message)s',
+            datefmt = '%m-%d %H:%M',
+            handlers = [logging.NullHandler()],
+            )
+
+    cfg = startup_path.joinpath("pymud.cfg")
+    cfg_data = None
+    if os.path.exists(cfg):
+        with open(cfg, "r", encoding="utf8", errors="ignore") as fp:
+            cfg_data = json.load(fp)
+
+    app = PyMudApp(cfg_data)
+    app.run()
+
+def main():
+    parser = argparse.ArgumentParser(prog = "pymud", description = "PyMUD命令行参数帮助")
+    subparsers = parser.add_subparsers(help = 'init用于初始化运行环境')
+
+    par_init = subparsers.add_parser('init', description = '初始化pymud运行环境, 包括建立脚本目录, 创建默认配置文件, 创建样例脚本等.')
+    par_init.add_argument('-d', '--dir', dest = 'dir', metavar = 'dir', type = str, default = '', help = '指定构建脚本目录的名称, 不指定时会根据操作系统选择不同默认值')
+    par_init.set_defaults(func = init_pymud_env)
+
+    parser.add_argument('-d', '--debug', dest = 'debug', action = 'store_true', default = False, help = '指定以调试模式进入PyMUD。此时，系统log等级将设置为logging.NOTSET, 所有log数据均会被记录。默认不启用。')
+    parser.add_argument('-l', '--logfile', dest = 'logfile', metavar = 'logfile', default = 'pymud.log', help = '指定调试模式下记录文件名，不指定时，默认为当前目录下的pymud.log')
+    parser.add_argument('-a', '--appendmode', dest = 'filemode', action = 'store_true', default = True, help = '指定log文件的访问模式是否为append尾部添加模式，默认为True。当为False时，使用w模式，即每次运行清空之前记录')
+    parser.add_argument('-s', '--startup_dir', dest = 'startup_dir', metavar = 'startup_dir', default = '.', help = '指定启动目录，默认为当前目录。使用该参数可以在任何目录下，通过指定脚本目录来启动')
+
+    args=parser.parse_args()
+
+    if hasattr(args, 'func'):
+        args.func(args)
+    else:
+        startApp(args)
+
+if __name__ == "__main__":
+    main()