pymud 0.20.0a1__py3-none-any.whl → 0.20.0a3__py3-none-any.whl

pymud/__init__.py

@@ -4,7 +4,8 @@ from .objects import CodeBlock, Alias, SimpleAlias, Trigger, SimpleTrigger, Comm
 from .extras import DotDict
 from .session import Session
 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"
+    "PyMudApp", "Settings", "CodeBlock", "Alias", "SimpleAlias", "Trigger", "SimpleTrigger", "Command", "SimpleCommand", "Timer", "SimpleTimer", "GMCPTrigger", "Session", "PyMudApp", "DotDict", "Logger", "main"
 ]

pymud/__main__.py

@@ -1,140 +1,4 @@
-import sys, os, json, platform, shutil, logging, argparse
-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",
-    }
-}
-
-def init_pymud_env(args):
-    print(f"欢迎使用PyMUD, 版本{Settings.__version__}. 使用PyMUD时, 建议建立一个新目录（任意位置），并将自己的脚本以及配置文件放到该目录下.")
-    print("即将开始为首次运行初始化环境...")
-    system = platform.system().lower()
-
-    dir = args.dir
-    if dir:
-        print(f"你已经指定了创建脚本的目录为 {args.dir}, 将不再检测操作系统")
-
-    else:
-        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"
-
-        elif system == "darwin":
-            dir = input("检测到当前系统为MacOS, 请指定游戏脚本的目录（若目录不存在会自动创建），直接回车表示使用默认值[~/pkuxkx]:")
-            if not dir: dir = "~/pkuxkx"
-
-        else:
-            print(f"当前系统不是Windows、Linux或MacOS, 无法通过init来进行配置, 请手动配置. 默认配置即将推出")
-
-
-    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 == "windows":
-        print(f"后续运行PyMUD， 请在 {dir} 目录下键入命令： python -m pymud")
-    else:
-        print(f"后续运行PyMUD， 请在 {dir} 目录下键入命令： python3 -m pymud")
-
-    input('所有内容已初始化完毕, 请按回车进入PyMUD.')
-
-    module_entry(args)
-
-def module_entry(args):
-    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 = "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()
-
+from .main import main
 
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser(prog = "pymud", usage = "python -m pymud [-h] [-d] [-l logfile] [-a] {init} ...", description = "PyMUD命令行参数帮助")
-    subparsers = parser.add_subparsers(help = 'init用于初始化运行环境')
-
-    par_init = subparsers.add_parser('init', usage = "python -m pymud init [-h] [-d dir]", 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模式，即每次运行清空之前记录')
-
-    args=parser.parse_args()
-    if hasattr(args, 'func'):
-        args.func(args)
-    else:
-        module_entry(args)
+    main()

pymud/logger.py

@@ -15,7 +15,7 @@ class Logger:
     :param raw: 记录带ANSI标记的原始内容，还是记录纯文本内容，默认为True，即记录带ANSI标记的原始内容。
     """
 
-    _esc_regx = re.compile("\x1b\\[[\d;]+[abcdmz]", flags = re.IGNORECASE)
+    _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

pymud/main.py

@@ -0,0 +1,141 @@
+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):
+    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()],
+            )
+
+    startup_path = Path(args.startup_dir).resolve()
+    sys.path.append(f"{startup_path}")
+    os.chdir(startup_path)
+    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()

pymud/pymud.py

@@ -318,8 +318,8 @@ class PyMudApp:
                 ),
 
                 MenuItem(
-                    "",    # 增加一个空名称MenuItem，阻止右侧空白栏点击响应
-                    children=[]
+                    "",    # 增加一个空名称MenuItem，单机后焦点移动至命令行输入处，阻止右侧空白栏点击响应
+                    handler = lambda : self.app.layout.focus(self.commandLine)
                 )
             ],
             floats=[
@@ -340,34 +340,9 @@ class PyMudApp:
         ss = Settings.sessions
 
         for key, site in ss.items():
-            host = site["host"]
-            port = site["port"]
-            encoding = site["encoding"]
-            autologin = site["autologin"]
-            scripts = list()
-            default_script = site["default_script"]
-            
-            def_scripts = list()
-            if isinstance(default_script, str):
-                def_scripts.extend(default_script.split(","))
-            elif isinstance(default_script, (list, tuple)):
-                def_scripts.extend(default_script)
-
             menu = MenuItem(key)
-            for name, info in site["chars"].items():
-                after_connect = autologin.format(info[0], info[1])
-                sess_scripts = list()
-                sess_scripts.extend(def_scripts)
-                
-                if len(info) == 3:
-                    session_script = info[2]
-                    if session_script:
-                        if isinstance(session_script, str):
-                            sess_scripts.extend(session_script.split(","))
-                        elif isinstance(session_script, (list, tuple)):
-                            sess_scripts.extend(session_script)
-
-                sub = MenuItem(name, handler = functools.partial(self.create_session, name, host, port, encoding, after_connect, sess_scripts, info[0]))
+            for name in site["chars"].keys():
+                sub = MenuItem(name, handler = functools.partial(self._quickHandleSession, key, name))
                 menu.children.append(sub)
             menus.append(menu)
 
@@ -506,7 +481,7 @@ class PyMudApp:
                     line = self.mudFormatProc.line_correction(b.document.current_line)
                     start = max(0, scol)
                     end = min(ecol, len(line))
-                    line_plain = re.sub("\x1b\\[[\d;]+[abcdmz]", "", line, flags = re.IGNORECASE).replace("\r", "").replace("\x00", "")
+                    line_plain = re.sub(r"\x1b\[[\d;]+[abcdmz]", "", line, flags = re.IGNORECASE).replace("\r", "").replace("\x00", "")
                     #line_plain = re.sub("\x1b\\[[^mz]+[mz]", "", line).replace("\r", "").replace("\x00", "")
                     selection = line_plain[start:end]
                     self.app.clipboard.set_text(selection)
@@ -518,7 +493,7 @@ class PyMudApp:
                     lines = []
                     for row in range(srow, erow + 1):
                         line = b.document.lines[row]
-                        line_plain = re.sub("\x1b\\[[\d;]+[abcdmz]", "", line, flags = re.IGNORECASE).replace("\r", "").replace("\x00", "")
+                        line_plain = re.sub(r"\x1b\[[\d;]+[abcdmz]", "", line, flags = re.IGNORECASE).replace("\r", "").replace("\x00", "")
                         lines.append(line_plain)
 
                     self.app.clipboard.set_text("\n".join(lines))
@@ -663,6 +638,7 @@ class PyMudApp:
                         plugin.onSessionDestroy(self.current_session)
 
                 name = self.current_session.name
+                self.current_session.closeLoggers()
                 self.current_session.clean()
                 self.current_session = None
                 self.consoleView.buffer = SessionBuffer()
@@ -918,6 +894,50 @@ class PyMudApp:
         self.status_message = msg
         self.app.invalidate()
 
+    def _quickHandleSession(self, group, name):
+        '''
+        根据指定的组名和会话角色名，从Settings内容，创建一个会话
+        '''
+        handled = False
+        if name in self.sessions.keys():
+           self.activate_session(name)
+           handled = True
+
+        else:
+            site = Settings.sessions[group]
+            if name in site["chars"].keys():
+                host = site["host"]
+                port = site["port"]
+                encoding = site["encoding"]
+                autologin = site["autologin"]
+                default_script = site["default_script"]
+                
+                def_scripts = list()
+                if isinstance(default_script, str):
+                    def_scripts.extend(default_script.split(","))
+                elif isinstance(default_script, (list, tuple)):
+                    def_scripts.extend(default_script)
+
+                charinfo = site["chars"][name]
+
+                after_connect = autologin.format(charinfo[0], charinfo[1])
+                sess_scripts = list()
+                sess_scripts.extend(def_scripts)
+                    
+                if len(charinfo) == 3:
+                    session_script = charinfo[2]
+                    if session_script:
+                        if isinstance(session_script, str):
+                            sess_scripts.extend(session_script.split(","))
+                        elif isinstance(session_script, (list, tuple)):
+                            sess_scripts.extend(session_script)
+
+                self.create_session(name, host, port, encoding, after_connect, sess_scripts, charinfo[0])
+                handled = True
+        
+        return handled
+
+
     def handle_session(self, *args):
         '''
         嵌入命令 #session 的执行函数，创建一个远程连接会话。
@@ -928,12 +948,18 @@ class PyMudApp:
             - 当不指定 Encoding: 时, 默认使用utf-8编码
             - 可以直接使用 #{名称} 切换会话和操作会话命令
 
+            - #session {group}.{name}
+            - 相当于直接点击菜单{group}下的{name}菜单来创建会话. 当该会话已存在时，切换到该会话
+
         参数:
             :name: 会话名称
             :host: 服务器域名或IP地址
             :port: 端口号
             :encoding: 编码格式，不指定时默认为 utf8
     
+            :group: 组名, 即配置文件中, sessions 字段下的某个关键字
+            :name: 会话快捷名称, 上述 group 关键字下的 chars 字段中的某个关键字
+
         示例:
             ``#session {名称} {宿主机} {端口} {编码}`` 
                 创建一个远程连接会话，使用指定编码格式连接到远程宿主机的指定端口并保存为 {名称} 。其中，编码可以省略，此时使用Settings.server["default_encoding"]的值，默认为utf8
@@ -946,6 +972,9 @@ class PyMudApp:
             ``#newstart give miui gold`` 
                 使名称为newstart的会话执行give miui gold指令，但不切换到该会话
 
+            ``#session pkuxkx.newstart``
+                通过指定快捷配置创建会话，相当于点击 世界->pkuxkx->newstart 菜单创建会话。若该会话存在，则切换到该会话
+
         相关命令:
             - #close
             - #exit
@@ -953,8 +982,17 @@ class PyMudApp:
         '''
 
         nothandle = True
+        errmsg = "错误的#session命令"
+        if len(args) == 1:
+            host_session = args[0]
+            if '.' in host_session:
+                group, name = host_session.split('.')
+                nothandle = not self._quickHandleSession(group, name)
 
-        if len(args) >= 3:
+            else:
+                errmsg = f'通过单一参数快速创建会话时，要使用 group.name 形式，如 #session pkuxkx.newstart'
+
+        elif len(args) >= 3:
             session_name = args[0]
             session_host = args[1]
             session_port = int(args[2])
@@ -967,7 +1005,7 @@ class PyMudApp:
             nothandle = False
         
         if nothandle:
-            self.set_status("错误的#session命令")
+            self.set_status(errmsg)
 
     def enter_pressed(self, buffer: Buffer):
         "命令行回车按键处理"
@@ -1161,21 +1199,6 @@ class PyMudApp:
             plugin.onSessionCreate(session)
         
 
-def main(cfg_data = None):
+def startApp(cfg_data = None):
     app = PyMudApp(cfg_data)
     app.run()
-
-if __name__ == "__main__":
-
-    cfg = "pymud.cfg"
-    import sys
-    args = sys.argv
-    if len(args) > 1:
-        cfg = args[1]
-
-    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()

pymud/session.py

@@ -8,7 +8,7 @@ from logging.handlers import QueueHandler, QueueListener
 from .logger import Logger
 from .extras import SessionBuffer, DotDict, Plugin
 from .protocol import MudClientProtocol
-from .objects import Trigger, Alias, Command, Timer, SimpleAlias, SimpleTrigger, SimpleTimer, GMCPTrigger, CodeBlock, CodeLine
+from .objects import BaseObject, Trigger, Alias, Command, Timer, SimpleAlias, SimpleTrigger, SimpleTimer, GMCPTrigger, CodeBlock, CodeLine
 from .settings import Settings
 
 
@@ -29,13 +29,14 @@ class Session:
 
     """
     #_esc_regx = re.compile("\x1b\\[[^mz]+[mz]")
-    _esc_regx = re.compile("\x1b\\[[\d;]+[abcdmz]", flags = re.IGNORECASE)
+    _esc_regx = re.compile(r"\x1b\[[\d;]+[abcdmz]", flags = re.IGNORECASE)
 
     _sys_commands = (
         "help",
         "exit",
         "close",
         "connect",      # 连接到服务器
+        "disconnect",   # 从服务器断开连接
 
         "info",         # 输出蓝色info
         "warning",      # 输出黄色warning
@@ -89,6 +90,7 @@ class Session:
         "var" : "variable",
         "rep" : "repeat",
         "con" : "connect",
+        "dis" : "disconnect",
         "wa"  : "wait",
         "mess": "message",
         "action": "trigger",
@@ -116,9 +118,6 @@ class Session:
         self._events["connected"]    = None
         self._events["disconnected"] = None
 
-        self._loggers = dict()
-        self.log = self.getLogger(name)
-
         self._auto_script = kwargs.get("scripts", None)
 
         self._cmds_handler = dict()                         # 支持的命令的处理函数字典
@@ -144,6 +143,9 @@ class Session:
 
         self.initialize()
 
+        self._loggers = dict()
+        self.log = self.getLogger(name)
+
         self.host = host
         self.port = port
         self.encoding = encoding or self.encoding
@@ -176,6 +178,10 @@ class Session:
         if Settings.client["auto_connect"]:
             self.open()
 
+    def __del__(self):
+        self.clean()
+        self.closeLoggers()
+
     def initialize(self):
         "初始化Session有关对象。 **无需脚本调用。**"
         self._line_buffer = bytearray()
@@ -376,6 +382,15 @@ class Session:
 
         return logger
 
+    def closeLoggers(self):
+        "移除本会话所有相关Logger"
+        for name in self._loggers.keys():
+            if isinstance(self._loggers[name], Logger):
+                self._loggers[name].enabled = False
+            
+            if name in self.application.loggers.keys():
+                self.application.loggers.pop(name)
+
     @property
     def modules(self) -> OrderedDict:
         """
@@ -758,6 +773,27 @@ class Session:
             cmd = line + self.newline
             self.write(cmd.encode(self.encoding, Settings.server["encoding_errors"]))
     
+    async def waitfor(self, line: str, awaitable, wait_time = 0.05) -> None:
+        """
+        调用writline向服务器中写入一行后，等待到可等待对象再返回。
+        
+        :param line: 使用writeline写入的行
+        :param awaitable: 等待的可等待对象
+        :param wait_time: 写入行前等待的延时，单位为s。默认0.05
+
+        由于异步的消息循环机制，如果在写入命令之后再创建可等待对象，则有可能服务器响应在可等待对象的创建之前
+        此时使用await就无法等待到可等待对象的响应，会导致任务出错。
+        一种解决方式是先创建可等待对象，然后写入命令，然后再等待可等待对象，但这种情况下需要写入三行代码，书写麻烦
+        因此该函数是用于简化此类使用时的写法。
+
+        示例:
+            await session.waitfor('a_cmd', self.create_task(a_tri.triggered()))
+            done, pending = await session.waitfor('a_cmd', asyncio.wait([self.create_task(a_tri.triggered()), self.create_task(b_tri.triggered())], return_when = 'FIRST_COMPLETED'))
+        """
+        await asyncio.sleep(wait_time)
+        self.writeline(line)
+        return await awaitable
+
     def exec(self, cmd: str, name = None, *args, **kwargs):
         """
         在名称为name的会话中使用exec_command执行MUD命令。当不指定name时，在当前会话中执行。
@@ -774,7 +810,7 @@ class Session:
         示例:
             .. code:: Python
 
-                session.addAlias(SimpleAlias(self.session, "^cb\s(\S+)\s(\S+)", "#3 get %1 from jinnang;#wa 250;combine gem;#wa 250;pack gem", id = "ali_combine"))
+                session.addAlias(SimpleAlias(self.session, r"^cb\s(\S+)\s(\S+)", "#3 get %1 from jinnang;#wa 250;combine gem;#wa 250;pack gem", id = "ali_combine"))
                 session.exec("cb j1a")
         """
         name = name or self.name
@@ -1107,31 +1143,100 @@ class Session:
 
         return counts
 
-    def _addObjects(self, objs: dict, cls: type):
-        if cls == Alias:
-            self._aliases.update(objs)
-        elif cls == Command:
-            self._commands.update(objs)
-        elif cls == Trigger:
-            self._triggers.update(objs)
-        elif cls == Timer:
-            self._timers.update(objs)
-        elif cls == GMCPTrigger:
-            self._gmcp.update(objs)
-
-    def _addObject(self, obj, cls: type):
-        #if type(obj) == cls:
-        if isinstance(obj, cls):
-            if cls == Alias:
-                self._aliases[obj.id] = obj
-            elif cls == Command:
-                self._commands[obj.id] = obj
-            elif cls == Trigger:
-                self._triggers[obj.id] = obj
-            elif cls == Timer:
-                self._timers[obj.id] = obj
-            elif cls == GMCPTrigger:
-                self._gmcp[obj.id] = obj
+    # def _addObjects(self, objs: dict, cls: type):
+    #     if cls == Alias:
+    #         self._aliases.update(objs)
+    #     elif cls == Command:
+    #         self._commands.update(objs)
+    #     elif cls == Trigger:
+    #         self._triggers.update(objs)
+    #     elif cls == Timer:
+    #         self._timers.update(objs)
+    #     elif cls == GMCPTrigger:
+    #         self._gmcp.update(objs)
+
+    def _addObjects(self, objs):
+        if isinstance(objs, list) or isinstance(objs, tuple):
+            for item in objs:
+                self._addObject(item)
+
+        elif isinstance(objs, dict):
+            for key, item in objs.items():
+                if isinstance(item, BaseObject):
+                    if key != item.id:
+                        self.warning(f'对象 {item} 字典键值 {key} 与其id {item.id} 不一致，将丢弃键值，以其id添加到会话中...')
+
+                    self._addObject(item)
+
+    # def _addObject(self, obj, cls: type):
+    #     #if type(obj) == cls:
+    #     if isinstance(obj, cls):
+    #         if cls == Alias:
+    #             self._aliases[obj.id] = obj
+    #         elif cls == Command:
+    #             self._commands[obj.id] = obj
+    #         elif cls == Trigger:
+    #             self._triggers[obj.id] = obj
+    #         elif cls == Timer:
+    #             self._timers[obj.id] = obj
+    #         elif cls == GMCPTrigger:
+    #             self._gmcp[obj.id] = obj
+
+    def _addObject(self, obj):
+        if isinstance(obj, Alias):
+            self._aliases[obj.id] = obj
+        elif isinstance(obj, Command):
+            self._commands[obj.id] = obj
+        elif isinstance(obj, Trigger):
+            self._triggers[obj.id] = obj
+        elif isinstance(obj, Timer):
+            self._timers[obj.id] = obj
+        elif isinstance(obj, GMCPTrigger):
+            self._gmcp[obj.id] = obj
+
+    def addObject(self, obj: BaseObject):
+        """
+        向会话中增加单个对象，可直接添加 Alias, Trigger, GMCPTrigger, Command, Timer 或它们的子类
+
+        :param obj: 特定对象本身，可以为 Alias, Trigger, GMCPTrigger, Command, Timer 或其子类
+
+        示例:
+            .. code:: Python
+
+                class Configuration:
+                    def __init__(self, session):
+                        self.session = session
+                    
+                        self.session.addObject(SimpleAlias(session, r'^gta$', 'get all'),)
+                        self.session.addObject(SimpleTrigger(session, r'^[> ]*你嘻嘻地笑了起来.+', 'haha'))
+                        self.session.addObject(SimpleTimer(session, 'xixi', timeout = 10))
+
+        """
+        self._addObject(obj)
+
+    def addObjects(self, objs):
+        """
+        向会话中增加多个对象，可直接添加 Alias, Trigger, GMCPTrigger, Command, Timer 或它们的子类的元组、列表或者字典(保持兼容性)
+
+        :param objs: 多个特定对象组成的元组、列表或者字典，可以为 Alias, Trigger, GMCPTrigger, Command, Timer 或其子类
+
+        示例:
+            .. code:: Python
+
+                class Configuration:
+                    def __init__(self, session):
+                        self.session = session
+                    
+                        self.objs = [
+                            SimpleAlias(session, r'^gta$', 'get all;xixi'),
+                            SimpleTrigger(session, r'^[> ]*你嘻嘻地笑了起来.+', 'haha'),
+                            SimpleTimer(session, 'xixi', timeout = 10)
+                        ]
+
+                        self.session.addObjects(self.objs)
+
+        """
+        self._addObjects(objs)
 
     def _delObject(self, id, cls: type):
         if cls == Alias:
@@ -1141,16 +1246,103 @@ class Session:
         elif cls == Trigger:
             self._triggers.pop(id, None)
         elif cls == Timer:
-            self._timers.pop(id, None)
+            timer = self._timers.pop(id, None)
+            if isinstance(timer, Timer):
+                timer.enabled = False
         elif cls == GMCPTrigger:
             self._gmcp.pop(id, None)
 
+    # def _delObject(self, obj):
+    #     if isinstance(obj, Alias):
+    #         self._aliases.pop(obj.id, None)
+    #     elif isinstance(obj, Command):
+    #         self._commands.pop(obj.id, None)
+    #     elif isinstance(obj, Trigger):
+    #         self._triggers.pop(obj.id, None)
+    #     elif isinstance(obj, Timer):
+    #         self._timers.pop(obj.id, None)
+    #     elif isinstance(obj, GMCPTrigger):
+    #         self._gmcp.pop(obj.id, None)
+
     def _delObjects(self, ids: Iterable, cls: type):
         "删除多个指定元素"
         for id in ids:
             self._delObject(id, cls)
 
-    def addAliases(self, alis: dict):
+    def delObject(self, obj):
+        """
+        从会话中移除一个对象，可直接删除 Alias, Trigger, GMCPTrigger, Command, Timer 或它们的子类本身
+        
+        :param obj: 要删除的多个特定对象组成的元组、列表或者字典，可以为 Alias, Trigger, GMCPTrigger, Command, Timer 或其子类
+
+        示例:
+            .. code:: Python
+
+                class Configuration:
+                    def __init__(self, session):
+                        self.session = session
+
+                        ali = Alias(session, "s", "south", id = "my_ali1")
+                        
+                        # 以下几种方式均可将该别名添加到会话
+                        session.addObject(ali)
+                        session.addAlias(ali)
+
+                        # 以下三种方式均可以删除该别名
+                        session.delObjec(ali)
+                        session.delAlias(ali)
+                        session.delAlias("my_ali1")
+
+        """
+        if isinstance(obj, Alias):
+            self._aliases.pop(obj.id, None)
+        elif isinstance(obj, Command):
+            self._commands.pop(obj.id, None)
+        elif isinstance(obj, Trigger):
+            self._triggers.pop(obj.id, None)
+        elif isinstance(obj, Timer):
+            timer = self._timers.pop(obj.id, None)
+            if isinstance(timer, Timer):
+                timer.enabled = False
+        elif isinstance(obj, GMCPTrigger):
+            self._gmcp.pop(obj.id, None)
+
+    def delObjects(self, objs):
+        """
+        从会话中移除一组对象，可直接删除  Alias, Trigger, GMCPTrigger, Command, Timer 或它们的子类的元组、列表或者字典(保持兼容性)
+        
+        :param objs: 要删除的对象本身，可以为 Alias, Trigger, GMCPTrigger, Command, Timer 或它们的子类
+
+        示例:
+
+        .. code:: Python
+
+            class Configuration:
+                def __init__(self, session):
+                    self.session = session
+                
+                    self.objs = [
+                        SimpleAlias(session, r'^gta$', 'get all;xixi'),
+                        SimpleTrigger(session, r'^[> ]*你嘻嘻地笑了起来.+', 'haha'),
+                        SimpleTimer(session, 'xixi', timeout = 10)
+                    ]
+
+                    self.session.addObjects(self.objs)
+
+                def __unload__(self):
+                    "卸载本模块时，删除所有本模块添加的对象"
+                    self.session.delObjects(self.objs)
+
+        """
+        if isinstance(objs, list) or isinstance(objs, tuple):
+            for item in objs:
+                self.delObject(item)
+
+        elif isinstance(objs, dict):
+            for key, item in objs.items():
+                    self.delObject(item)
+
+    def addAliases(self, alis):
         """
         向会话中增加多个别名
 
@@ -1171,55 +1363,55 @@ class Session:
                         self._aliases['my_ali2'] = SimpleAlias(self.session, "s", "south", id = "my_ali2")
                         self.session.addAliases(self._aliases)
         """
-        self._addObjects(alis, Alias)
+        self._addObjects(alis)
 
-    def addCommands(self, cmds: dict):
+    def addCommands(self, cmds):
         """
         向会话中增加多个命令。使用方法与 addAliases 类似。
 
         :param cmds: 多个命令的字典。字典 key 应为每个命令的 id。
         """
-        self._addObjects(cmds, Command)
+        self._addObjects(cmds)
 
-    def addTriggers(self, tris: dict):
+    def addTriggers(self, tris):
         """
         向会话中增加多个触发器。使用方法与 addAliases 类似。
 
         :param tris: 多个触发器的字典。字典 key 应为每个触发器的 id。
         """
-        self._addObjects(tris, Trigger)
+        self._addObjects(tris)
 
-    def addGMCPs(self, gmcps: dict):
+    def addGMCPs(self, gmcps):
         """
         向会话中增加多个GMCPTrigger。使用方法与 addAliases 类似。
 
         :param gmcps: 多个GMCPTrigger的字典。字典 key 应为每个GMCPTrigger的 id。
         """
-        self._addObjects(gmcps, GMCPTrigger)
+        self._addObjects(gmcps)
 
-    def addTimers(self, tis: dict):
+    def addTimers(self, tis):
         """
         向会话中增加多个定时器。使用方法与 addAliases 类似。
 
         :param tis: 多个定时器的字典。字典 key 应为每个定时器的 id。
         """
-        self._addObjects(tis, Timer)
+        self._addObjects(tis)
 
-    def addAlias(self, ali: Alias):
+    def addAlias(self, ali):
         """
         向会话中增加一个别名。
 
         :param ali: 要增加的别名对象，应为 Alias 类型或其子类
         """
-        self._addObject(ali, Alias)
+        self._addObject(ali)
 
-    def addCommand(self, cmd: Command):
+    def addCommand(self, cmd):
         """
         向会话中增加一个命令。
 
         :param cmd: 要增加的命令对象，应为 Command 类型或其子类
         """
-        self._addObject(cmd, Command)
+        self._addObject(cmd)
 
     def addTrigger(self, tri: Trigger):
         """
@@ -1227,7 +1419,7 @@ class Session:
 
         :param tri: 要增加的触发器对象，应为 Trigger 类型或其子类
         """
-        self._addObject(tri, Trigger)
+        self._addObject(tri)
 
     def addTimer(self, ti: Timer):
         """
@@ -1235,7 +1427,7 @@ class Session:
 
         :param ti: 要增加的定时器对象，应为 Timer 类型或其子类
         """
-        self._addObject(ti, Timer)
+        self._addObject(ti)
 
     def addGMCP(self, gmcp: GMCPTrigger):
         """
@@ -1244,7 +1436,7 @@ class Session:
         :param gmcp: 要增加的GMCP触发器对象，应为 GMCPTrigger 类型或其子类
         """
 
-        self._addObject(gmcp, GMCPTrigger)
+        self._addObject(gmcp)
 
     def delAlias(self, ali):
         """
@@ -1363,7 +1555,7 @@ class Session:
         for ti in ti_s:
             self.delTimer(ti)
 
-    def delGMCP(self, gmcp: GMCPTrigger):
+    def delGMCP(self, gmcp):
         """
         从会话中移除一个GMCP触发器，可接受 GMCPTrigger 对象或其的id。使用方法与 delAlias 类似
         
@@ -1679,6 +1871,7 @@ class Session:
         该函数不应该在代码中直接调用。
         
         相关命令:
+            - #disconnect
             - #close
             - #exit
         '''
@@ -1700,6 +1893,18 @@ class Session:
 
             self.info("已经与服务器连接了 {}".format(time_msg))
 
+    def handle_disconnect(self, code: CodeLine = None, *args, **kwargs):
+        '''
+        嵌入命令 #disconnect / #dis 的执行函数，断开到远程服务器的连接（仅当远程服务器已连接时有效）。
+        该函数不应该在代码中直接调用。
+        
+        相关命令:
+            - #connect
+            - #close
+        '''
+
+        self.disconnect()
+
     def handle_variable(self, code: CodeLine = None, *args, **kwargs):
         '''
         嵌入命令 #variable / #var 的执行函数，操作会话变量。
@@ -1933,7 +2138,7 @@ class Session:
                             self.info("创建Timer {} 成功: {}".format(ti.id, ti.__repr__()))
 
     def handle_alias(self, code: CodeLine = None, *args, **kwargs):
-        '''
+        """
         嵌入命令 #alias / #ali 的执行函数，操作别名。该命令可以不带参数、带一个参数或者两个参数。
         该函数不应该在代码中直接调用。
 
@@ -1964,7 +2169,7 @@ class Session:
             - #trigger
             - #timer
             - #command
-        '''
+        """
 
         self._handle_objs("Alias", self._aliases, *code.code[2:])
 
@@ -2359,10 +2564,11 @@ class Session:
                 mod = self._modules[module_name]["module"]
                 config = self._modules[module_name]["config"]
                 if config: 
-                    if hasattr(config, "unload"):
-                        unload = getattr(config, "unload", None)
+                    if hasattr(config, "__unload__") or hasattr(config, "unload"):
+                        unload = getattr(config, "__unload__", None) or getattr(config, "unload", None)
                         if callable(unload):
-                            unload(config)
+                            unload()
+
                     del config
                 mod = importlib.reload(mod)
                 if hasattr(mod, 'Configuration'):
@@ -2402,10 +2608,10 @@ class Session:
             mod = self._modules[module_name]["module"]
             config = self._modules[module_name]["config"]
             if config: 
-                if hasattr(config, "unload"):
-                    unload = getattr(config, "unload", None)
+                if hasattr(config, "__unload__") or hasattr(config, "unload"):
+                    unload = getattr(config, "__unload__", None) or getattr(config, "unload", None)
                     if callable(unload):
-                        unload(config)
+                        unload()
 
                 del config
             del mod

pymud/settings.py

@@ -13,7 +13,7 @@ class Settings:
     "APP 简要描述"
     __version__   = "0.20.0"
     "APP 当前版本"
-    __release__   = "2024-08-14"
+    __release__   = "2024-08-19"
     "APP 当前版本发布日期"
     __author__    = "本牛(newstart)@北侠"
     "APP 作者"

{pymud-0.20.0a1.dist-info → pymud-0.20.0a3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pymud
-Version: 0.20.0a1
+Version: 0.20.0a3
 Summary: a MUD Client written in Python
 Author-email: "newstart@pkuxkx" <crapex@crapex.cc>
 Maintainer-email: "newstart@pkuxkx" <crapex@crapex.cc>
@@ -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 :: 5 - Production/Stable
+Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: End Users/Desktop
 Classifier: Topic :: Games/Entertainment :: Multi-User Dungeons (MUD)
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
@@ -694,6 +694,7 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3 :: Only
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
@@ -971,8 +972,26 @@ Requires-Dist: prompt-toolkit
 + 功能调整: 变量替代时，会自动实现类型转化，当被替代变量值为非 str 类型时不会再报错
 + 问题修复: 修复之前从后向前选择时，无法复制的问题
 
-### 0.19.5 (2024-08-XX)
+### 0.20.0a1 (2024-08-14)
++ 功能调整: 使用argsparser标准模块来配置命令行，可以使用 python -m pymud -h 查看命令行具体参数及说明
 + 功能调整: 恢复在__init__.py中增加PyMudApp的导出，可以恢复使用from pymud import PyMudApp了
 + 功能调整: 在没有session的时候，也可以执行#exit命令
 + 功能调整: 模块加载和重新加载前，会自动调用模块的unload方法（若有）
-+ 功能新增: 增加log功能（待设计）
++ 功能新增: 增加log功能，详见 #log 命令介绍、类参考中的 Logger 类，以及 Session 类的 handle_log 方法
+
+### 0.20.0a2 (2024-08-19)
++ 问题修复: 关闭会话时未关闭相关记录器，导致后续会话无法启动
++ 问题修复: MacOS下 python -m pymud init 创建目录报错的问题。同时，将所有系统上的默认目录均使用 ~/pkuxkx （影响windows）
++ 功能新增: Session类新增waitfor函数，用于执行一段代码后立即等待某个触发器的情况，简化原三行代码写法
+
+### 0.20.0 (2024-08-XX)
++ 功能调整: 将模块主入口函数从__main__.py中移动到main.py中，以使可以在当前目录下，可直接使用pymud，也可使用python -m pymud启动
++ 问题修复: 修复部分正则表达式书写错误问题
++ 功能调整: Session类的addTriggers等方法接受的dict中，会将对象本身id作为会话处理id。当该id与key不一致时，会同时显示警告。
++ 功能新增: Session类新增addObject, addObjects, delObject, delObjects用于操作别名、定时器、触发器、GMCP触发器、命令等对象。
++ 功能新增: 主模块卸载现在既可以定义在__unload__方法中，也可以定义在unload方法中
++ 问题修复: 修复原unload方法不能正确卸载的问题
++ 功能新增: 命令行参数增加指定启动目录的功能，参数为 -s, --startup_dir。即可以从任意目录通过指定脚本目录方式启动PyMUD了。例如， PS C:\> pymud -s d:\prog\pkuxkx 相当于 PS D:\prog\pkuxk> pymud
++ 功能新增: 增加 #disconnect, #dis 命令，可以使当前会话从服务器断开。相当于操作菜单 会话->断开连接
++ 功能新增: #session 命令增加快捷创建会话功能，假如已有快捷菜单 世界->pkuxkx->newstart , 则可以通过 #session pkuxkx.newstart 直接创建该会话，效果等同于点击该菜单
++ 功能调整: 点击菜单创建会话时，若会话已存在，则将该会话切换为当前会话

pymud-0.20.0a3.dist-info/RECORD

@@ -0,0 +1,18 @@
+pymud/__init__.py,sha256=hvX7Ga2xPG9J3ZpxBLrC6BvrzUo-Dj26HsRKf41Brhw,533
+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=wpL1t88qcnYDq1vyguj2NOMpD9yVgZeuAJSMWEbDeiI,6532
+pymud/objects.py,sha256=0aUc-PZfVSdYPEAamY0eO6k3P9wJcw6PNxfSE8eZZeE,38072
+pymud/pkuxkx.py,sha256=vWXHU6GF0HQ0eWb3LmxFVRP0cKnigffCX7Z-LJvwVtw,11496
+pymud/protocol.py,sha256=QfDXjlg2OcJXmVoXf_3mAemnYotRXDUlEZNQjhkfXdA,49106
+pymud/pymud.py,sha256=N9WxaHDqqsTWIBG8UJ38gdMC_pQ30wphcN2LtT66eA4,49584
+pymud/session.py,sha256=Ea5pqFFMQ1NWct51g3LCWpyVzM83puFzLhdE7I4WEy4,129768
+pymud/settings.py,sha256=CRNpHl4RjOuQYzAIWyUEvOo7q-f4lo01X1v_CriHWO4,7145
+pymud-0.20.0a3.dist-info/LICENSE.txt,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+pymud-0.20.0a3.dist-info/METADATA,sha256=rXogwgamQhQ1geFAq3eH-Vyi2m521g2vevHm9XEf3Rg,70341
+pymud-0.20.0a3.dist-info/WHEEL,sha256=nCVcAvsfA9TDtwGwhYaRrlPhTLV9m-Ga6mdyDtuwK18,91
+pymud-0.20.0a3.dist-info/entry_points.txt,sha256=diPUOtTkhgC1hVny7Cdg4aRhaHSynMQoraE7ZhJxUcw,37
+pymud-0.20.0a3.dist-info/top_level.txt,sha256=8Gp1eXjxixXjqhhti6tLCspV_8s9sNV3z5Em2_KRhD4,6
+pymud-0.20.0a3.dist-info/RECORD,,

{pymud-0.20.0a1.dist-info → pymud-0.20.0a3.dist-info}/WHEEL

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

pymud-0.20.0a1.dist-info/RECORD

@@ -1,17 +0,0 @@
-pymud/__init__.py,sha256=Ep6JrWv2wwlLV5nI7F6BOA7Ei6yVgnxvhIRwFGPr2Oc,501
-pymud/__main__.py,sha256=ybi8pA0BXCZJ_GWgndllT7f1FBBE2tGNCByN0zkaSu0,6748
-pymud/dialogs.py,sha256=D0ZtCeoBchF5eYzXumkOi3p-maCQZu4v9-wJgxQ790o,6500
-pymud/extras.py,sha256=QwWwLavVtuXfg0Qb0f_040va1_kej27P-ZB_19HB6Qk,42422
-pymud/logger.py,sha256=39I_rFBU5MEiOTJyU7GAy9cY_MpYHKiXNgBhpokQrTA,5358
-pymud/objects.py,sha256=0aUc-PZfVSdYPEAamY0eO6k3P9wJcw6PNxfSE8eZZeE,38072
-pymud/pkuxkx.py,sha256=vWXHU6GF0HQ0eWb3LmxFVRP0cKnigffCX7Z-LJvwVtw,11496
-pymud/protocol.py,sha256=QfDXjlg2OcJXmVoXf_3mAemnYotRXDUlEZNQjhkfXdA,49106
-pymud/pymud.py,sha256=2dbgnzlG9476esOfyp9sv-lRSTpMuRaCXnqrOofOu24,48182
-pymud/session.py,sha256=uAWt0-AZWpDvVfCjzoxWDpuOwCQ8s1DN_DZ-rVAC5xs,121232
-pymud/settings.py,sha256=XkyFWTskPGZljuWCaC8cU18ie8-FkecEtb0h3OfcfjU,7145
-pymud-0.20.0a1.dist-info/LICENSE.txt,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-pymud-0.20.0a1.dist-info/METADATA,sha256=N57G7pGHXWfYKJ2YwJjWFMSYxvfkvwIpmsTKTR1hjro,68201
-pymud-0.20.0a1.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
-pymud-0.20.0a1.dist-info/entry_points.txt,sha256=diPUOtTkhgC1hVny7Cdg4aRhaHSynMQoraE7ZhJxUcw,37
-pymud-0.20.0a1.dist-info/top_level.txt,sha256=8Gp1eXjxixXjqhhti6tLCspV_8s9sNV3z5Em2_KRhD4,6
-pymud-0.20.0a1.dist-info/RECORD,,