pymud 0.20.2a4__py3-none-any.whl → 0.20.3__py3-none-any.whl

pymud/logger.py

@@ -1,162 +1,162 @@
-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:
-                        from .session import Session
-                        data = Session.PLAIN_TEXT_REGX.sub("", data)
-                        #data = self._esc_regx.sub("", data)
-
-                    self._stream.write(data)
-
-                    self._stream.flush()
-                    self._lock.release()
-
-                else:
-                    break
-            except Empty:
-                break
+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:
+                        from .session import Session
+                        data = Session.PLAIN_TEXT_REGX.sub("", data)
+                        #data = self._esc_regx.sub("", data)
+
+                    self._stream.write(data)
+
+                    self._stream.flush()
+                    self._lock.release()
+
+                else:
+                    break
+            except Empty:
+                break

pymud/main.py

@@ -1,142 +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__":
+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()