pymud 0.21.0a4__py3-none-any.whl → 0.21.0a5__py3-none-any.whl

pymud/modules.py

@@ -1,175 +1,9 @@
 
-import importlib, importlib.util, functools
-from abc import ABC, ABCMeta
-from typing import Any, Optional, Union, List, Dict
-from .objects import BaseObject, Command, Trigger, Alias, Timer, GMCPTrigger
+import importlib, importlib.util, traceback
+from typing import Any
 from .settings import Settings
 from .extras import DotDict
-
-
-class PymudDecorator:
-    """
-    装饰器基类。使用装饰器可以快捷创建各类Pymud基础对象。
-    
-        :param type: 装饰器的类型，用于区分不同的装饰器，为字符串类型。
-        :param args: 可变位置参数，用于传递额外的参数。
-        :param kwargs: 可变关键字参数，用于传递额外的键值对参数。
-    """
-    def __init__(self, type: str, *args, **kwargs):
-        self.type = type
-        self.args = args
-        self.kwargs = kwargs
-
-    def __call__(self, func):
-        decos = getattr(func, "__pymud_decorators__", [])
-        decos.append(self)
-        func.__pymud_decorators__ = decos
-
-        return func
-        return self
-
-    def __repr__(self):
-        return f"<{self.__class__.__name__} type = {self.type} args = {self.args} kwargs = {self.kwargs}>"
-
-
-def alias(
-        patterns: Union[List[str], str], 
-        id: Optional[str] = None, 
-        group: str = "", 
-        enabled: bool = True, 
-        ignoreCase: bool = False, 
-        isRegExp: bool = True, 
-        keepEval: bool = False, 
-        expandVar: bool = True, 
-        priority: int = 100, 
-        oneShot: bool = False,  
-        *args, **kwargs):
-    """
-    使用装饰器创建一个别名（Alias）对象。被装饰的函数将在别名成功匹配时调用。
-    被装饰的函数，除第一个参数为类实例本身self之外，另外包括id, line, wildcards三个参数。
-    其中id为别名对象的唯一标识符，line为匹配的文本行，wildcards为匹配的通配符列表。
-
-    :param patterns: 别名匹配的模式。
-    :param id: 别名对象的唯一标识符，不指定时将自动生成唯一标识符。
-    :param group: 别名所属的组名，默认为空字符串。
-    :param enabled: 别名是否启用，默认为 True。
-    :param ignoreCase: 匹配时是否忽略大小写，默认为 False。
-    :param isRegExp: 模式是否为正则表达式，默认为 True。
-    :param keepEval: 若存在多个可匹配的别名时，是否持续匹配，默认为 False。
-    :param expandVar: 是否展开变量，默认为 True。
-    :param priority: 别名的优先级，值越小优先级越高，默认为 100。
-    :param oneShot: 别名是否只触发一次后自动失效，默认为 False。
-    :param args: 可变位置参数，用于传递额外的参数。
-    :param kwargs: 可变关键字参数，用于传递额外的键值对参数。
-    :return: PymudDecorator 实例，类型为 "alias"。
-    """
-    # 将传入的参数更新到 kwargs 字典中
-    kwargs.update({
-        "patterns": patterns,
-        "id": id, 
-        "group": group, 
-        "enabled": enabled, 
-        "ignoreCase": ignoreCase, 
-        "isRegExp": isRegExp, 
-        "keepEval": keepEval, 
-        "expandVar": expandVar, 
-        "priority": priority, 
-        "oneShot": oneShot})
-    
-    # 如果 id 为 None，则从 kwargs 中移除 "id" 键
-    if not id:
-        kwargs.pop("id")
-
-    return PymudDecorator("alias", *args, **kwargs)
-
-def trigger(
-        patterns: Union[List[str], str], 
-        id: Optional[str] = None, 
-        group: str = "", 
-        enabled: bool = True, 
-        ignoreCase: bool = False, 
-        isRegExp: bool = True, 
-        keepEval: bool = False, 
-        expandVar: bool = True, 
-        raw: bool = False, 
-        priority: int = 100, 
-        oneShot: bool = False,  
-        *args, **kwargs):
-    """
-    使用装饰器创建一个触发器（Trigger）对象。
-
-    :param patterns: 触发器匹配的模式。单行模式可以是字符串或正则表达式，多行模式必须是元组或列表，其中每个元素都是字符串或正则表达式。
-    :param id: 触发器对象的唯一标识符，不指定时将自动生成唯一标识符。
-    :param group: 触发器所属的组名，默认为空字符串。
-    :param enabled: 触发器是否启用，默认为 True。
-    :param ignoreCase: 匹配时是否忽略大小写，默认为 False。
-    :param isRegExp: 模式是否为正则表达式，默认为 True。
-    :param keepEval: 若存在多个可匹配的触发器时，是否持续匹配，默认为 False。
-    :param expandVar: 是否展开变量，默认为 True。
-    :param raw: 是否使用原始匹配方式，默认为 False。原始匹配方式下，不对 VT100 下的 ANSI 颜色进行解码，因此可以匹配颜色；正常匹配仅匹配文本。
-    :param priority: 触发器的优先级，值越小优先级越高，默认为 100。
-    :param oneShot: 触发器是否只触发一次后自动失效，默认为 False。
-    :param args: 可变位置参数，用于传递额外的参数。
-    :param kwargs: 可变关键字参数，用于传递额外的键值对参数。
-    :return: PymudDecorator 实例，类型为 "trigger"。
-    """
-    # 将传入的参数更新到 kwargs 字典中
-    kwargs.update({
-        "patterns": patterns,
-        "id": id, 
-        "group": group, 
-        "enabled": enabled, 
-        "ignoreCase": ignoreCase, 
-        "isRegExp": isRegExp, 
-        "keepEval": keepEval, 
-        "expandVar": expandVar, 
-        "raw": raw,
-        "priority": priority, 
-        "oneShot": oneShot})
-    if not id:
-        kwargs.pop("id")
-    return PymudDecorator("trigger", *args, **kwargs)
-
-def timer(timeout: float, id: Optional[str] = None, group: str = "", enabled: bool = True, *args, **kwargs):
-    """
-    使用装饰器创建一个定时器（Timer）对象。
-
-    :param timeout: 定时器超时时间，单位为秒。
-    :param id: 定时器对象的唯一标识符，不指定时将自动生成唯一标识符。
-    :param group: 定时器所属的组名，默认为空字符串。
-    :param enabled: 定时器是否启用，默认为 True。
-    :param args: 可变位置参数，用于传递额外的参数。
-    :param kwargs: 可变关键字参数，用于传递额外的键值对参数。
-    :return: PymudDecorator 实例，类型为 "timer"。
-    """
-    kwargs.update({
-        "timeout": timeout,
-        "id": id,
-        "group": group,
-        "enabled": enabled
-        })
-    if not id:
-        kwargs.pop("id")
-    return PymudDecorator("timer", *args, **kwargs)
-
-def gmcp(name: str, group: str = "", enabled: bool = True, *args, **kwargs):
-    """
-    使用装饰器创建一个GMCP触发器（GMCPTrigger）对象。
-
-    :param name: GMCP触发器的名称。
-    :param group: GMCP触发器所属的组名，默认为空字符串。
-    :param enabled: GMCP触发器是否启用，默认为 True。
-    :param args: 可变位置参数，用于传递额外的参数。
-    :param kwargs: 可变关键字参数，用于传递额外的键值对参数。
-    :return: PymudDecorator 实例，类型为 "gmcp"。
-    """
-    kwargs.update({
-        "id": name,
-        "group": group,
-        "enabled": enabled
-        })
-    
-    return PymudDecorator("gmcp", *args, **kwargs)
+from .decorators import exception, async_exception, PymudDecorator, print_exception
 
 class PymudMeta(type):
     def __new__(cls, name, bases, attrs):
@@ -193,7 +27,9 @@ class ModuleInfo:
 
     """
     def __init__(self, module_name: str, session):
-        self.session = session
+        from .session import Session
+        if isinstance(session, Session):
+            self.session = session
         self._name = module_name 
         self._ismainmodule = False
         self.load()
@@ -223,6 +59,7 @@ class ModuleInfo:
         return result
     
     def _unload(self):
+        from .objects import BaseObject, Command
         for key, config in self._config.items():
             if isinstance(config, Command):
                 # Command 对象在从会话中移除时，自动调用其 unload 系列方法，因此不能产生递归
@@ -283,17 +120,15 @@ class ModuleInfo:
         "只读属性，区分是否主模块（即包含具体config的模块）"
         return self._ismainmodule
 
-class IConfig(metaclass = PymudMeta):
+class IConfigBase(metaclass = PymudMeta):
     """
-    用于提示PyMUD应用是否自动创建该配置类型的基础类。
-    
-    继承 IConfig 类型让应用自动管理该类型，唯一需要的是，构造函数中，仅存在一个必须指定的参数 Session。
-
-    在应用自动创建 IConfig 实例时，除 session 参数外，还会传递一个 reload 参数 （bool类型），表示是首次加载还是重新加载特性。
-    可以从kwargs 中获取该参数，并针对性的设计相应代码。例如，重新加载相关联的其他模块等。
+    用于支持对装饰器写法对象进行管理的基础类。
+    该类型相当于原来的IConfig类，唯一区别时，模块加载时，不会对本类型创建实例对象。
+    主要用于对插件中定义的Command提供装饰器写法支持，因为这些Command是在会话构建时创建，因此不能在模块加载时自动创建，也就不能继承自IConfig。
     """
     def __init__(self, session, *args, **kwargs):
         from .session import Session
+        from .objects import Alias, Trigger, Timer, GMCPTrigger
         if isinstance(session, Session):
             self.session = session
         self.__inline_objects__ = DotDict()
@@ -323,6 +158,7 @@ class IConfig(metaclass = PymudMeta):
                             self.__inline_objects__[gmcp.id] = gmcp
 
     def __unload__(self):
+        from .objects import BaseObject
         if self.session:
             self.session.delObjects(self.__inline_objects__)
             if isinstance(self, BaseObject):
@@ -333,9 +169,19 @@ class IConfig(metaclass = PymudMeta):
         "返回内联自动创建的对象字典"
         return self.__inline_objects__
     
-    def obj(self, obj_id: str) -> BaseObject:
+    def obj(self, obj_id: str):
         "根据对象ID返回内联自动创建的对象"
         return self.__inline_objects__.get(obj_id, None) # type: ignore
+
+class IConfig(IConfigBase):
+    """
+    用于提示PyMUD应用是否自动创建该配置类型的基础类。
+    
+    继承 IConfig 类型让应用自动管理该类型，唯一需要的是，构造函数中，仅存在一个必须指定的参数 Session。
+
+    在应用自动创建 IConfig 实例时，除 session 参数外，还会传递一个 reload 参数 （bool类型），表示是首次加载还是重新加载特性。
+    可以从kwargs 中获取该参数，并针对性的设计相应代码。例如，重新加载相关联的其他模块等。
+    """
         
 class Plugin:
     """
@@ -411,7 +257,11 @@ class Plugin:
 
         :param session: 新创建的会话对象实例
         """
-        self._session_create(session)
+        try:
+            self._session_create(session)
+        except Exception as e:
+            print_exception(session, e)
+            
 
     def onSessionDestroy(self, session):
         """
@@ -419,7 +269,10 @@ class Plugin:
 
         :param session: 所关闭的会话对象实例
         """
-        self._session_destroy(session)
+        try:
+            self._session_destroy(session)
+        except Exception as e:
+            print_exception(session, e)
 
     def onAppDestroy(self, app):
         """

pymud/objects.py

@@ -9,6 +9,7 @@ from collections.abc import Iterable
 from collections import namedtuple
 from typing import Any
 from .settings import Settings
+from .decorators import exception, async_exception, print_exception
 
 class CodeLine:
     """
@@ -448,10 +449,13 @@ class GMCPTrigger(BaseObject):
 
         self.line  = value
         self.value = value_exp
-
+        
         if callable(self._onSuccess):
             self.event.set()
-            self._onSuccess(self.id, value, value_exp)
+            try:
+                self._onSuccess(self.id, value, value_exp)
+            except Exception as e:
+                print_exception(self.session, e)
 
     def __detailed__(self) -> str:
         group = f'group = "{self.group}" ' if self.group else ''
@@ -548,76 +552,79 @@ class MatchObject(BaseObject):
 
         :return: BaseObject.State 类型，一个包含 result, id, name, line, wildcards 的命名元组对象
         """
-        result = self.NOTSET
-
-        if not self.multiline:                              # 非多行
-            if self.isRegExp:
-                m = self._regExp.match(line)
-                if m:
-                    result = self.SUCCESS
-                    self.wildcards.clear()
-                    if len(m.groups()) > 0:
-                        self.wildcards.extend(m.groups())
+        try:
+            result = self.NOTSET
 
-                    self.lines.clear()
-                    self.lines.append(line)
-            else:
-                #if line.find(self.patterns) >= 0:
-                #if line == self.patterns:
-                if isinstance(self.patterns, str) and (self.patterns in line):
-                    result = self.SUCCESS
-                    self.lines.clear()
-                    self.lines.append(line)
-                    self.wildcards.clear()
-
-        else:                                               # 多行匹配情况
-            # multilines match. 多行匹配时，受限于行的捕获方式，必须一行一行来，设置状态标志进行处理。
-            if self._mline == 0:                            # 当尚未开始匹配时，匹配第1行
-                m = self._regExps[0].match(line)
-                if m:
-                    self.lines.clear()
-                    self.lines.append(line)
-                    self.wildcards.clear()
-                    if len(m.groups()) > 0:
-                        self.wildcards.extend(m.groups())
-                    self._mline = 1                         # 下一状态 （中间行）
-            elif (self._mline > 0) and (self._mline < self.linesToMatch - 1):
-                m = self._regExps[self._mline].match(line)
-                if m:
-                    self.lines.append(line)
-                    if len(m.groups()) > 0:
-                        self.wildcards.extend(m.groups())
-                    self._mline += 1
+            if not self.multiline:                              # 非多行
+                if self.isRegExp:
+                    m = self._regExp.match(line)
+                    if m:
+                        result = self.SUCCESS
+                        self.wildcards.clear()
+                        if len(m.groups()) > 0:
+                            self.wildcards.extend(m.groups())
+
+                        self.lines.clear()
+                        self.lines.append(line)
                 else:
-                    self._mline = 0
-            elif self._mline == self.linesToMatch - 1:      # 最终行
-                m = self._regExps[self._mline].match(line)
-                if m:
-                    self.lines.append(line)
-                    if len(m.groups()) > 0:
-                        self.wildcards.extend(m.groups())
-                    result = self.SUCCESS
-
-                self._mline = 0
+                    #if line.find(self.patterns) >= 0:
+                    #if line == self.patterns:
+                    if isinstance(self.patterns, str) and (self.patterns in line):
+                        result = self.SUCCESS
+                        self.lines.clear()
+                        self.lines.append(line)
+                        self.wildcards.clear()
+
+            else:                                               # 多行匹配情况
+                # multilines match. 多行匹配时，受限于行的捕获方式，必须一行一行来，设置状态标志进行处理。
+                if self._mline == 0:                            # 当尚未开始匹配时，匹配第1行
+                    m = self._regExps[0].match(line)
+                    if m:
+                        self.lines.clear()
+                        self.lines.append(line)
+                        self.wildcards.clear()
+                        if len(m.groups()) > 0:
+                            self.wildcards.extend(m.groups())
+                        self._mline = 1                         # 下一状态 （中间行）
+                elif (self._mline > 0) and (self._mline < self.linesToMatch - 1):
+                    m = self._regExps[self._mline].match(line)
+                    if m:
+                        self.lines.append(line)
+                        if len(m.groups()) > 0:
+                            self.wildcards.extend(m.groups())
+                        self._mline += 1
+                    else:
+                        self._mline = 0
+                elif self._mline == self.linesToMatch - 1:      # 最终行
+                    m = self._regExps[self._mline].match(line)
+                    if m:
+                        self.lines.append(line)
+                        if len(m.groups()) > 0:
+                            self.wildcards.extend(m.groups())
+                        result = self.SUCCESS
 
-        state = BaseObject.State(result, self.id, "\n".join(self.lines), tuple(self.wildcards))
+                    self._mline = 0
 
-        # 采用回调方式执行的时候，执行函数回调（仅当self.sync和docallback均为真时才执行同步
-        # 当docallback为真时，是真正的进行匹配和触发，为false时，仅返回匹配结果，不实际触发
-        if docallback:
-            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)
-            
-            if state.result == self.SUCCESS:
-                self.event.set()
+            state = BaseObject.State(result, self.id, "\n".join(self.lines), tuple(self.wildcards))
+
+            # 采用回调方式执行的时候，执行函数回调（仅当self.sync和docallback均为真时才执行同步
+            # 当docallback为真时，是真正的进行匹配和触发，为false时，仅返回匹配结果，不实际触发
+            if docallback:
+                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
+                if state.result == self.SUCCESS:
+                    self.event.set()
+                    
+            self.state = state
+            return state
+        except Exception as e:
+            print_exception(self.session, e)
     
     async def matched(self) -> BaseObject.State:
         """
@@ -630,10 +637,10 @@ class MatchObject(BaseObject):
             self.reset()
             await self.event.wait()
             self.reset()
-        except Exception as e:
-            self.error(Settings.gettext("exception_in_async", e))
 
-        return self.state
+            return self.state
+        except Exception as e:
+            print_exception(self.session, e)
     
     def __detailed__(self) -> str:
         group = f'group = "{self.group}" ' if self.group else ''

pymud/protocol.py

@@ -146,7 +146,7 @@ class MudClientProtocol(Protocol):
             subfunc = getattr(self, f"handle_{v.lower()}_sb", None)         # 子协商处理函数
             self._iac_subneg_handlers[k] = subfunc
 
-        self.encoding = Settings.server["default_encoding"]                 # 字节串基本编码
+        self.encoding = kwargs.get("encoding", Settings.server["default_encoding"])                 # 字节串基本编码
         self.encoding_errors = Settings.server["encoding_errors"]           # 编码解码错误时的处理
         self.mnes = Settings.mnes
 
@@ -767,9 +767,9 @@ class MudClientProtocol(Protocol):
                     state_machine = "wait_val_in_table"
                 elif byte in (IAC, MSDP_VAR, MSDP_VAL):     # 正常数据 value 结束
                     current_val = val_in_text.decode(self.encoding)
-                    msdp_data[current_var] = current_val
+                    msdp_data[current_var] = current_val # type: ignore
                     state_machine = "wait_end"
-                    self.log.debug(f"收到文本形式的MSDP子协商数据： {current_var} = '{current_val}'")
+                    self.log.debug(f"收到文本形式的MSDP子协商数据： {current_var} = '{current_val}'") # type: ignore
                 else:                           # value是正常数据
                     val_in_text.append(byte)
             elif state_machine == "wait_val_in_array":
@@ -777,9 +777,9 @@ class MudClientProtocol(Protocol):
                     # 最后一个val 已结束
                     val_in_array.append(val_in_text.decode(self.encoding))
                     val_in_text.clear()
-                    msdp_data[current_var] = val_in_array
+                    msdp_data[current_var] = val_in_array # type: ignore
                     state_machine = "wait_end"
-                    self.log.debug(f"收到数组形式的MSDP子协商数据： {current_var} = '{val_in_array}'")
+                    self.log.debug(f"收到数组形式的MSDP子协商数据： {current_var} = '{val_in_array}'") # type: ignore
                 elif byte == MSDP_VAL:
                     if len(val_in_text) > 0:                # 一个VAL已完成，保存到array，后面还有val
                         val_in_array.append(val_in_text.decode(self.encoding))
@@ -791,9 +791,9 @@ class MudClientProtocol(Protocol):
                 if byte == MSDP_TABLE_CLOSE:
                     # 最后一组已结束
                     val_in_table[table_var_name.decode(self.encoding)] = table_var_value.decode(self.encoding)
-                    msdp_data[current_var] = val_in_table
+                    msdp_data[current_var] = val_in_table # type: ignore
                     state_machine = "wait_end"
-                    self.log.debug(f"收到表格形式的MSDP子协商数据： {current_var} = '{val_in_table}'")
+                    self.log.debug(f"收到表格形式的MSDP子协商数据： {current_var} = '{val_in_table}'") # type: ignore
                 elif byte == MSDP_VAR:
                     if len(table_var_name) > 0:             # 上一个VAL已完成，保存到table，后面继续为VAR
                         val_in_table[table_var_name.decode(self.encoding)] = table_var_value.decode(self.encoding)

pymud/pymud.py

@@ -765,21 +765,21 @@ class PyMudApp:
         val = not Settings.client["beautify"]
         Settings.client["beautify"] = val
         if self.current_session:
-            self.current_session.info(f'{Settings.gettext("msg_beautify")}{Settings.gettext("open") if val else Settings.gettext("close")}!')
+            self.current_session.info(f'{Settings.gettext("msg_beautify")}{Settings.gettext("msg_open") if val else Settings.gettext("msg_close")}!')
 
     def act_echoinput(self):
         "菜单: 显示/隐藏输入指令"
         val = not Settings.client["echo_input"]
         Settings.client["echo_input"] = val
         if self.current_session:
-            self.current_session.info(f'{Settings.gettext("msg_echoinput")}{Settings.gettext("open") if val else Settings.gettext("close")}!')
+            self.current_session.info(f'{Settings.gettext("msg_echoinput")}{Settings.gettext("msg_open") if val else Settings.gettext("msg_close")}!')
 
     def act_autoreconnect(self):
         "菜单: 打开/关闭自动重连"
         val = not Settings.client["auto_reconnect"]
         Settings.client["auto_reconnect"] = val
         if self.current_session:
-            self.current_session.info(f'{Settings.gettext("msg_autoreconnect")}{Settings.gettext("open") if val else Settings.gettext("close")}')
+            self.current_session.info(f'{Settings.gettext("msg_autoreconnect")}{Settings.gettext("msg_open") if val else Settings.gettext("msg_close")}')
 
     def act_copy(self):
         "菜单: 复制纯文本"