pyobject 1.2.9.2__tar.gz → 1.3.0__tar.gz

{pyobject-1.2.9.2/pyobject.egg-info → pyobject-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyobject
-Version: 1.2.9.2
+Version: 1.3.0
 Summary: A multifunctional all-in-one utility tool for managing internal Python objects, compatible with nearly all Python 3 versions. 一个多功能合一的提供操作Python对象底层工具的Python包, 支持几乎所有Python 3版本。 
 Home-page: https://github.com/qfcy/pyobject
 Author: qfcy
@@ -394,11 +394,12 @@ Python内部的字节码对象\ ``CodeType``\ ，如\ ``func.__code__``\ ，是
 lst调用多次==运算符(``__eq__``)相比，
 本函数直接比较对象的指针，提高了效率。
 
-**``pyobject``\ 当前版本**: 1.2.9.2
+**``pyobject``\ 当前版本**: 1.3.0
 
 更新日志:
 ---------
 
+| 2025-6-6(v1.3.0):性能优化，提升了pyobject.objproxy模块的性能。
 | 2025-4-30(v1.2.9):改进和增强了子模块pyobject.objproxy，重命名子模块pyobject.code_为pyobject.code。
 | 2025-3-31(v1.2.8):将pyobject.super_proxy重命名为pyobject.objproxy，并正式发布；修改了pyobject.pyobj_extension模块。
 | 2025-3-6(v1.2.7):为pyobject.browser新增了\ ``dir()``\ 中不存在的类属性（如\ ``__flags__``,
@@ -886,11 +887,13 @@ Python call “obj in lst” that invokes the “==” operator (``__eq__``)
 multiple times, this function directly compares the pointers to improve
 efficiency.
 
-**Current Version of ``pyobject``**: 1.2.9.2
+**Current Version of ``pyobject``**: 1.3.0
 
 Change Log
 ----------
 
+| 2025-6-6(v1.3.0): Optimized the performance of the pyobject.objproxy
+  module.
 | 2025-4-30(v1.2.9): Improved and enhanced the sub-module
   ``pyobject.objproxy``, and renamed the sub-module ``pyobject.code_``
   to ``pyobject.code``.

{pyobject-1.2.9.2 → pyobject-1.3.0}/README.rst

@@ -377,11 +377,12 @@ Python内部的字节码对象\ ``CodeType``\ ，如\ ``func.__code__``\ ，是
 lst调用多次==运算符(``__eq__``)相比，
 本函数直接比较对象的指针，提高了效率。
 
-**``pyobject``\ 当前版本**: 1.2.9.2
+**``pyobject``\ 当前版本**: 1.3.0
 
 更新日志:
 ---------
 
+| 2025-6-6(v1.3.0):性能优化，提升了pyobject.objproxy模块的性能。
 | 2025-4-30(v1.2.9):改进和增强了子模块pyobject.objproxy，重命名子模块pyobject.code_为pyobject.code。
 | 2025-3-31(v1.2.8):将pyobject.super_proxy重命名为pyobject.objproxy，并正式发布；修改了pyobject.pyobj_extension模块。
 | 2025-3-6(v1.2.7):为pyobject.browser新增了\ ``dir()``\ 中不存在的类属性（如\ ``__flags__``,
@@ -869,11 +870,13 @@ Python call “obj in lst” that invokes the “==” operator (``__eq__``)
 multiple times, this function directly compares the pointers to improve
 efficiency.
 
-**Current Version of ``pyobject``**: 1.2.9.2
+**Current Version of ``pyobject``**: 1.3.0
 
 Change Log
 ----------
 
+| 2025-6-6(v1.3.0): Optimized the performance of the pyobject.objproxy
+  module.
 | 2025-4-30(v1.2.9): Improved and enhanced the sub-module
   ``pyobject.objproxy``, and renamed the sub-module ``pyobject.code_``
   to ``pyobject.code``.

{pyobject-1.2.9.2 → pyobject-1.3.0}/pyobject/__init__.py

@@ -6,7 +6,7 @@ import sys
 from warnings import warn
 from pprint import pprint
 
-__version__="1.2.9.2"
+__version__="1.3.0"
 
 __all__=["objectname","bases","describe","desc"]
 _ignore_names=["__builtins__","__doc__"]
@@ -97,8 +97,8 @@ try:
                     "set_type_subclasses_by_cls"])
 except ImportError:warn("Failed to import pyobject.pyobj_extension.")
 try:
-    from pyobject.objproxy import DynObj,ObjChain,ProxiedObj
-    __all__.extend(["DynObj","ObjChain","ProxiedObj"])
+    from pyobject.objproxy import ObjChain,ProxiedObj,unproxy_obj
+    __all__.extend(["ObjChain","ProxiedObj","unproxy_obj"])
 except (ImportError, SyntaxError):
     warn("Failed to import pyobject.objproxy.") # Python 3.5及以下不支持f-string，无法使用objproxy库
 

{pyobject-1.2.9.2 → pyobject-1.3.0}/pyobject/examples/test_inject.py

@@ -7,7 +7,7 @@ except ImportError:
     from importlib._bootstrap import MAGIC_NUMBER
 
 MARK=b"#####MyPython####"
-TARGET='empty_cp37.pyc' # 需要用Python 3.7
+TARGET='empty_cp37.pyc' # 需Python 3.7
 
 def extract_file(filename):
     # 将py,pyc文件还原为Code对象
@@ -121,10 +121,10 @@ def spread_to_mod(modname,use_pycache=True):
     if use_pycache and file.endswith('.py') or file.endswith('.pyw'):
         # 获取目标文件位置
         splited=os.path.split(file)
-        os.makedirs(splited[0] + '\\__pycache__',exist_ok=True)
+        os.makedirs(splited[0] + '/__pycache__',exist_ok=True)
         pyc=os.path.splitext(splited[1])[0] + \
              '.cpython-%d%d' % (sys.version_info.major,sys.version_info.minor)
-        target=splited[0] + '\\__pycache__\\'+pyc+'.pyc'
+        target=splited[0] + '/__pycache__/'+pyc+'.pyc'
     else:target=None
     co=spread(file,pycfile=target)
     return co

{pyobject-1.2.9.2 → pyobject-1.3.0}/pyobject/objproxy/__init__.py

@@ -1,6 +1,5 @@
 import functools,itertools,types
 from pyobject import shortrepr
-from pyobject.objproxy.dynobj import DynObj
 from pyobject.objproxy.optimize import optimize_code
 from pyobject.objproxy.utils import *
 
@@ -24,42 +23,6 @@ def unproxy_obj(obj):
         obj = obj._ProxiedObj__target_obj
     return obj
 
-def unproxy_obj_recursive(obj): # 递归解除obj的代理（备用函数）
-    while _isinstance(obj, ProxiedObj):
-        obj = obj._ProxiedObj__target_obj
-    # 递归处理容器
-    if _isinstance(obj, dict):
-        return {unproxy_obj_recursive(k): unproxy_obj_recursive(v)
-                for k, v in obj.items()}
-    elif _isinstance(obj, list):
-        return [unproxy_obj_recursive(item) for item in obj]
-    elif _isinstance(obj, tuple):
-        return tuple(unproxy_obj_recursive(item) for item in obj)
-    elif _isinstance(obj, set):
-        return {unproxy_obj_recursive(item) for item in obj}
-    else:
-        return obj
-def accept_raw_obj(func,process_arg=None,process_kw=None,process_ret=None):
-    # 装饰器，用于有target_obj时只接受原始对象而不是ProxiedObj的函数（备用）
-    @functools.wraps(func)
-    def inner(*args,**kw):
-        args = unproxy_obj_recursive(args)
-        kw = unproxy_obj_recursive(kw)
-
-        if process_arg is not None:
-            args = process_arg(args)
-        if process_kw is not None:
-            kw = process_kw(kw)
-
-        if kw:
-            result = func(*args,**kw)
-        else:
-            result = func(*args)
-        if process_ret is not None:
-            result = process_ret(result)
-        return result
-    return inner
-
 class _EmptyTarget:
     def __bool__(self):return False
 EMPTY_OBJ = _EmptyTarget() # 空对象的特殊值
@@ -87,7 +50,7 @@ def is_trivial_obj(obj): # 检查对象能否被repr()表示（即对象必须
     if type(obj) not in TRIVIAL_TYPES: # 不使用isinstance（由于不能是基本类型子类）
         return False
     if type(obj) in (list, tuple, dict, set):
-        if isinstance(obj, dict):
+        if _isinstance(obj, dict):
             obj = itertools.chain(obj.keys(), obj.values())
         return all(is_trivial_obj(sub) for sub in obj)
     return True
@@ -104,42 +67,12 @@ def is_builtin_type(cls): # 备用函数
         #    return True
     #return False
 
-def proxyCls(T=_EmptyTarget, chain=EMPTY_OBJ, fromvar=None):
-    # 泛型，proxyCls(T)生成类型信息为T的继承自ProxiedObj的类
-    if T is EMPTY_OBJ:
-        return ProxiedObj
-
-    class ProxyCls(ProxiedObj): # 创建同时从ProxiedObj与T继承的类
-        # pylint: disable=unused-private-member
-        __proto = T # 自身使用的原型
-        def __new__(cls,*args,**kw):
-            _chain = args[0] if args else kw.get("chain")
-            if not _isinstance(_chain,ObjChain) and chain is not EMPTY_OBJ:
-                var = chain.new_var(T.__name__)
-                if fromvar is not None:
-                    # pylint: disable=self-cls-assignment
-                    cls = chain.add_existing_obj(T,var,f"{var} = {fromvar}.__class__",
-                                                 [fromvar])
-                else:
-                    cls = chain.add_existing_obj(T,var, # pylint: disable=self-cls-assignment
-                        f"# class {var}: {shortrepr(cls,repr_func=basic_repr)}")
-                if len(args) == 3 and isinstance(T,type):
-                    args=(args[0],tuple(unproxy_obj(cls) for cls in args[1]),args[2])
-
-                if kw:return cls(*args,**kw)
-                return cls(*args) # 返回ProxyCls
-            else:
-                return ProxiedObj.__new__(cls,*args,**kw)
-
-    return ProxyCls
-
 class ObjChain:
     def __init__(self, export_funcs = None, export_attrs = None,
                  export_trivial_obj = False, hook_inheritance = False,
                  hook_method_call = False):
         # ObjChain()的export_funcs和export_attrs作用于当前链的所有对象
         self.codes = []
-        self.indent = 0 # 代码缩进格数（暂未使用）
         self.scope = {} # 上次执行的命名空间
         self.export_funcs = {} # 哪些函数需要导出（键为对象的变量名，值为属性名的列表，属性名可用"."分隔）
         self.export_attrs = {} # 哪些属性需要导出（键为对象的变量名）
@@ -153,19 +86,26 @@ class ObjChain:
         self._var_num = 0 # 变量序号
         self.code_vars = [] # 每行代码修改和依赖于的变量，例如[("result_var",["depend_var1",...],{}),...]，{}为额外信息
         self.code_executed = [] # 代码是否已执行过（确保代码只执行一次）
+        self._executed_idx = 0 # 前面全部执行过的行号
         self._is_evaluating = False # 当前是否正在执行调用（用于代码的_internal信息）
         self.export_trivial_obj = export_trivial_obj # 是否不使用ProxiedObj包装基本类型（如整数、列表等）
         self.hook_inheritance = hook_inheritance # 是否继续hook从ProxiedObj包装的类继承的新类
         self.hook_method_call = hook_method_call # 是否hook实例方法的调用
     def add_code(self,code_line,result_var=None,dependency_vars=None,
                  executed=True,**extra_info):
+        # result_var: 新变量名（每个变量对应的对象id不变，类似js的const）
+        # dependency_vars: 依赖的变量列表（可能会修改对象，但不会修改变量的对象id）
         if dependency_vars is None:
             dependency_vars = []
-        self.codes.append(" "*(self.indent*INDENT)+code_line)
+        self.codes.append(code_line)
         if "_internal" not in extra_info:
             extra_info["_internal"] = self._is_evaluating # _internal: 是否是执行其他生成代码时，递归生成的
         self.code_vars.append((result_var,dependency_vars,extra_info))
         self.code_executed.append(executed)
+    def remove_last_line(self): # 删除最后一行代码
+        self.codes.pop()
+        self.code_vars.pop()
+        self.code_executed.pop()
     def detect_dependency_vars(self,*iterables):
         # 自动检测依赖的变量，返回变量名的列表和未知对象的列表
         result = []; unknown = []
@@ -342,11 +282,11 @@ class ObjChain:
                            remove_export_type=True):
         return optimize_code(self.codes, self.code_vars, no_optimize_vars,
                              remove_internal, remove_export_type)
-    def eval_value(self,var_name=None,end_lineno=None):
+    def eval_value(self,var_name=None,start_lineno=None,end_lineno=None):
         # 一次性执行未执行过的代码（仅用于没有target_obj时）
         if end_lineno is None:end_lineno = len(self.codes)
 
-        exec(self.get_code(end_lineno = end_lineno, _only_not_executed = True),
+        exec(self.get_code(start_lineno, end_lineno, _only_not_executed = True),
              self.scope)
         if var_name is not None:
             return self.scope[var_name]
@@ -356,23 +296,23 @@ class ObjChain:
                            use_exported_obj=False):
         # 依赖于最后一行代码，要求调用之前先调用了add_code
         # var_name为None时，返回None（此时不可使用返回值）
-        if result_getter_func is not None and var_name is None:
-            raise ValueError("result_getter_func requires var_name")
-
         pre_is_evaluating = self._is_evaluating
         self._is_evaluating = True # 记录当前正在执行其他代码
 
         new_code = self.codes[-1]
-        cur_idx = -1
+        cur_idx = len(self.codes) - 1
         if target_obj is not EMPTY_OBJ:
             # 一次执行完前面的全部代码
-            self.eval_value(end_lineno = cur_idx) # 不包括最后一行新加入的代码
+            self.eval_value(start_lineno = self._executed_idx,
+                            end_lineno = cur_idx) # 不包括最后一行新加入的代码
             self.code_executed[cur_idx] = True # 最后一行设为已执行过
+            self._executed_idx = cur_idx + 1
 
             # 实时操作对象，并返回操作结果
             if result_getter_func is not None:
                 result = result_getter_func() # 从外部函数获取返回结果（比exec更快）
-                self.scope[var_name] = result # 将结果存入为scope的变量（此时var_name不为None）
+                if var_name is not None:
+                    self.scope[var_name] = result # 将结果存入为scope的变量（此时var_name不为None）
             else:
                 if export or use_exported_obj: # use_exported_obj: 是否在不导出时也在exec用target_obj作为变量，避免递归
                     scope = {}
@@ -399,35 +339,45 @@ class ObjChain:
         self._is_evaluating = pre_is_evaluating
         return result # result须不为ProxiedObj类型
 
-def magic_meth_chained(fmt = None, use_newvar = True, indent_delta = 0,
-                       export = False, use_exported_obj = True, default_fmt = False):
+def magic_meth_chained(fmt = None, use_newvar = True, export = False,
+                       use_exported_obj = True, default_fmt = False,
+                       no_exec = True, aug_assign = False):
     # fmt: 代码的格式，{_var}表示新变量，{_self}表示自身变量
     # use_newvar: 是否会生成新的返回值变量，为False时用于+=, -=等运算符
-    # indent_delta: 缩进的变化量。export: 是否返回ProxiedObj外的其他类型
     # default_fmt: 自动生成代码的格式，此时use_target_obj总是为True
+    # no_exec: 不使用exec()执行动态生成的代码，用于提高性能
+    # aug_assign: 是否为增强赋值语句（会同时将use_newvar设为False）
+    
     if not use_newvar and export:
-        raise ValueError("can't disable use_newvar while export is set to True")
+        raise ValueError("can't disable use_newvar while export is True")
+    if aug_assign:
+        use_newvar=False # 自动将use_newvar设为False
+        if default_fmt or fmt is None:
+            raise ValueError(
+                "can't use default_fmt=True or fmt=None while aug_assign is True")
+
     def magic_meth_chained_inner(meth):
+        meth_name = meth.__name__ # 方法名，仅default_fmt为True时使用
         if export:
-            DEFAULT_EXPORT_FUNCS.append(meth.__name__) # 自动生成常量DEFAULT_EXPORT_FUNCS
+            DEFAULT_EXPORT_FUNCS.append(meth_name) # 自动生成常量DEFAULT_EXPORT_FUNCS
         @functools.wraps(meth)
         def override(self, *args, **kw):
             nonlocal use_exported_obj
             chain = self._ProxiedObj__chain
-            name = self._ProxiedObj__name
-            meth_name = meth.__name__
+            self_name = self._ProxiedObj__name
             target_obj = self._ProxiedObj__target_obj
             no_target_obj = target_obj is EMPTY_OBJ
 
             # ReprFormatProxy：自定义!r格式化的行为
             fmt_kw = {key:ReprFormatProxy(val,chain.get_repr) for key,val in kw.items()}
-            fmt_kw["_self"] = name
+            fmt_kw["_self"] = self_name
             if use_newvar:
                 new_var = chain.new_var(export=export) # 申请一个新变量名
                 fmt_kw["_var"] = new_var
             else:
                 new_var = None
 
+            # 添加代码并检测依赖的变量
             depend_vars = chain._detect_var_and_add_obj((self,), args, kw.values())
             if fmt is not None:
                 fmt_args = [ReprFormatProxy(arg,chain.get_repr) for arg in args]
@@ -435,28 +385,32 @@ def magic_meth_chained(fmt = None, use_newvar = True, indent_delta = 0,
                 chain.add_code(new_code, new_var, depend_vars, _export_type = export,
                                executed = not no_target_obj) # 加入新的一行代码
             elif default_fmt: # 自动生成格式
-                use_exported_obj = True # 此时use_target_obj总是为True
+                fmt_args = None
+                use_exported_obj = True # 此时use_exported_obj总是为True
                 if use_newvar:
                     new_code = "{} = {}.{}({})".format(
-                        new_var,name,meth_name,format_func_call(args,kw,chain.get_repr))
+                        new_var,self_name,meth_name,format_func_call(args,kw,chain.get_repr))
                 else:
                     new_code = "{}.{}({})".format(
-                        name,meth_name,format_func_call(args,kw,chain.get_repr))
+                        self_name,meth_name,format_func_call(args,kw,chain.get_repr))
                 chain.add_code(new_code, new_var, depend_vars, _export_type = export,
                                executed = not no_target_obj)
             else:
-                pass #new_code = ""
-
-            chain.indent += indent_delta # 变化缩进
+                new_code = fmt_args = None
 
+            getter_func = (lambda:meth(target_obj,
+                *((unproxy_obj(arg) for arg in args) if use_exported_obj else args))) \
+                if no_exec and not no_target_obj else None # no_exec为True时，不使用关键字参数kw
 
             # 不使用use_exported_obj时，result总是为None
             result = chain._get_new_targetobj(target_obj,new_var,
                                               export=export,
-                                              use_exported_obj=use_exported_obj)
+                                              use_exported_obj=use_exported_obj,
+                                              result_getter_func=getter_func)
 
             if export or (self._ProxiedObj__export_trivial_obj
                           and is_trivial_obj(result)):
+                # 返回导出的对象
                 if use_newvar:
                     chain.add_exported_obj(result, new_var) # 继续追踪导出的值
                 if target_obj is not EMPTY_OBJ:
@@ -467,7 +421,23 @@ def magic_meth_chained(fmt = None, use_newvar = True, indent_delta = 0,
             if use_newvar:
                 return proxyCls(type(result),self._ProxiedObj__chain,new_var)(chain,new_var,
                             result,export_trivial_obj=self._ProxiedObj__export_trivial_obj)
-            return self
+            if aug_assign:
+                if result is target_obj:return self
+                else:
+                    result_var = chain.new_var() # 新变量的名称
+                    chain.scope[result_var] = result
+                    chain.remove_last_line() # 回退已生成的代码，重新加入
+                    fmt_kw["_self"] = result_var
+                    chain.add_code(f"{result_var} = {self_name}",result_var,[self_name])
+                    new_code = fmt.format(*fmt_args, **fmt_kw)
+                     # 需加入self_name，由于可能会修改self_name的对象
+                    chain.add_code(new_code, None, [result_var, self_name],
+                                   _export_type = export, executed = not no_target_obj)
+                    return proxyCls(type(result),self._ProxiedObj__chain,result_var)(
+                                    chain,result_var,result,
+                                    export_trivial_obj = \
+                                    self._ProxiedObj__export_trivial_obj)
+            return None
 
         return override
     return magic_meth_chained_inner
@@ -486,7 +456,7 @@ class ProxiedObj:
         self.__name=name
         self.__export_call=_export_call
         if not _export_call and self.__chain.hook_method_call \
-                and isinstance(target_obj,types.MethodType):
+                and _isinstance(target_obj,types.MethodType):
             obj = target_obj.__self__
             if id(obj) in self.__chain.proxies:
                 target_obj = types.MethodType(target_obj.__func__,
@@ -522,7 +492,7 @@ class ProxiedObj:
             self.__chain.add_exported_obj(result, new_var)
             return result # 直接返回结果，不继续返回ProxiedObj
 
-        if isinstance(self.__target_obj,type) and isinstance(result,self.__target_obj):
+        if _isinstance(self.__target_obj,type) and _isinstance(result,self.__target_obj):
             # 自身是类且result为自身的实例化对象，则实例使用类的导出函数、属性
             if self.__name in self.__chain.export_attrs:
                 self.__chain.export_attrs[new_var] = self.__chain.\
@@ -535,26 +505,22 @@ class ProxiedObj:
 
     #@magic_meth_chained("{_var} = {_self}.{}")
     def __getattr__(self,attr):
-        if "_ProxiedObj__chain" not in object.\
-                __getattribute__(self,"__dict__"): # self尚未初始化
-            return object.__getattribute__(self,attr)
         if attr in NOCODE_EXPORT_ATTRS and self.__target_obj is not EMPTY_OBJ:
-            return getattr(self.__target_obj, attr) # 不留下代码的直接导出属性
+            return _getattr(self.__target_obj, attr) # 不留下代码的直接导出属性
 
         new_var=self.__chain.new_var()
         new_code = f"{new_var} = {self.__name}.{attr}"
         self.__chain.add_code(new_code, new_var, [self.__name],
                               executed = self.__target_obj is not EMPTY_OBJ)
 
-        export = self.__chain.is_export_attr(attr, self.__name)
+        is_export = self.__chain.is_export_attr(attr, self.__name)
         result = self.__chain._get_new_targetobj(
-                self.__target_obj,new_var,lambda:getattr(self.__target_obj,attr),
-                export = export) # 获取结果对象
-        if export:
+                self.__target_obj,new_var,lambda:_getattr(self.__target_obj,attr),
+                export = is_export) # 获取结果对象
+        if is_export:
             return result
 
-        if self.__export_trivial_obj and is_trivial_obj(result)\
-                or self.__chain.is_export_attr(attr,self.__name):
+        if self.__export_trivial_obj and is_trivial_obj(result) or is_export:
             self.__chain.add_exported_obj(result, new_var)
             return result # 直接返回结果，不继续返回ProxiedObj
         else:
@@ -564,25 +530,27 @@ class ProxiedObj:
                             self.__chain,new_var,result,
                             self.__chain.is_export_func(attr,self.__name),
                             self.__export_trivial_obj)
-    @magic_meth_chained("{_var} = str({_self})",export=True)
-    def __str__(self): pass
-    @magic_meth_chained("{_var} = repr({_self})",export=True)
-    def __repr__(self): pass
-    @magic_meth_chained("{_var} = dir({_self})",export=True)
-    def __dir__(self): pass
-    @magic_meth_chained("{_self}.{} = {!r}", False)
-    def __setattr_override(self,attr,value):pass
-    def __setattr__(self,attr,value):
+
+    #@magic_meth_chained("{_var} = str({_self})",export=True)
+    #def __str__(self): return str(self)
+    # 优化函数调用开销
+    __str__ = magic_meth_chained("{_var} = str({_self})",export=True)(str)
+    __repr__ = magic_meth_chained("{_var} = repr({_self})",export=True)(repr)
+    __dir__ = magic_meth_chained("{_var} = dir({_self})",export=True)(dir)
+    __setattr_override = magic_meth_chained("{_self}.{} = {!r}", False)(setattr)
+
+    def __setattr__(self,attr,value): # 仅用于__no_self_attr
         dct = object.__getattribute__(self,"__dict__")
         if not dct.get("_ProxiedObj__no_self_attr",False):
             object.__setattr__(self,attr,value)
         else:
             self.__setattr_override(attr,value)
-    def __getattribute__(self,attr):
+    def __getattribute__(self,attr): # 仅用于__no_self_attr
         result = object.__getattribute__(self,attr)
         if object.__getattribute__(self,"__dict__").get(
                 "_ProxiedObj__no_self_attr",False) \
                 and not attr.startswith("_ProxiedObj"):
+            #return type(self).__getattr__(self,attr)
             raise AttributeError # 改用__getattr__
         return result
     def __new__(cls,*args,**kw):
@@ -598,160 +566,182 @@ class ProxiedObj:
 
     # 算术运算符
     @magic_meth_chained("{_var} = {_self} + {!r}")
-    def __add__(self, other): pass
+    def __add__(self, other): return self + other
     @magic_meth_chained("{_var} = {_self} - {!r}")
-    def __sub__(self, other): pass
+    def __sub__(self, other): return self - other
     @magic_meth_chained("{_var} = {_self} * {!r}")
-    def __mul__(self, other): pass
+    def __mul__(self, other): return self * other
     @magic_meth_chained("{_var} = {_self} / {!r}")
-    def __truediv__(self, other): pass
+    def __truediv__(self, other): return self / other
     @magic_meth_chained("{_var} = {_self} // {!r}")
-    def __floordiv__(self, other): pass
+    def __floordiv__(self, other): return self // other
     @magic_meth_chained("{_var} = {_self} % {!r}")
-    def __mod__(self, other): pass
+    def __mod__(self, other): return self % other
     @magic_meth_chained("{_var} = {_self} ** {!r}")
-    def __pow__(self, other): pass
+    def __pow__(self, other): return self ** other
     @magic_meth_chained("{_var} = {_self} << {!r}")
-    def __lshift__(self, other): pass
+    def __lshift__(self, other): return self << other
     @magic_meth_chained("{_var} = {_self} >> {!r}")
-    def __rshift__(self, other): pass
+    def __rshift__(self, other): return self >> other
     @magic_meth_chained("{_var} = {_self} & {!r}")
-    def __and__(self, other): pass
+    def __and__(self, other): return self & other
     @magic_meth_chained("{_var} = {_self} ^ {!r}")
-    def __xor__(self, other): pass
+    def __xor__(self, other): return self ^ other
     @magic_meth_chained("{_var} = {_self} | {!r}")
-    def __or__(self, other): pass
+    def __or__(self, other): return self | other
 
     # 反向算术运算符
+    @magic_meth_chained("{_var} = {!r} + {_self}")
+    def __radd__(self, other): return other + self
     @magic_meth_chained("{_var} = {!r} - {_self}")
-    def __radd__(self, other): pass
-    @magic_meth_chained("{_var} = {!r} - {_self}")
-    def __rsub__(self, other): pass
+    def __rsub__(self, other): return other - self
     @magic_meth_chained("{_var} = {!r} * {_self}")
-    def __rmul__(self, other): pass
+    def __rmul__(self, other): return other * self
     @magic_meth_chained("{_var} = {!r} / {_self}")
-    def __rtruediv__(self, other): pass
+    def __rtruediv__(self, other): return other / self
     @magic_meth_chained("{_var} = {!r} // {_self}")
-    def __rfloordiv__(self, other): pass
+    def __rfloordiv__(self, other): return other // self
     @magic_meth_chained("{_var} = {!r} % {_self}")
-    def __rmod__(self, other): pass
+    def __rmod__(self, other): return other % self
     @magic_meth_chained("{_var} = {!r} ** {_self}")
-    def __rpow__(self, other): pass
+    def __rpow__(self, other): return other ** self
     @magic_meth_chained("{_var} = {!r} << {_self}")
-    def __rlshift__(self, other): pass
+    def __rlshift__(self, other): return other << self
     @magic_meth_chained("{_var} = {!r} >> {_self}")
-    def __rrshift__(self, other): pass
+    def __rrshift__(self, other): return other >> self
     @magic_meth_chained("{_var} = {!r} & {_self}")
-    def __rand__(self, other): pass
+    def __rand__(self, other): return other & self
     @magic_meth_chained("{_var} = {!r} ^ {_self}")
-    def __rxor__(self, other): pass
+    def __rxor__(self, other): return other ^ self
     @magic_meth_chained("{_var} = {!r} | {_self}")
-    def __ror__(self, other): pass
+    def __ror__(self, other): return other | self
 
     # 增量赋值
-    @magic_meth_chained("{_self} += {!r}", False)
-    def __iadd__(self, other): pass
-    @magic_meth_chained("{_self} -= {!r}", False)
-    def __isub__(self, other): pass
-    @magic_meth_chained("{_self} *= {!r}", False)
-    def __imul__(self, other): pass
-    @magic_meth_chained("{_self} /= {!r}", False)
-    def __itruediv__(self, other): pass
-    @magic_meth_chained("{_self} //= {!r}", False)
-    def __ifloordiv__(self, other): pass
-    @magic_meth_chained("{_self} %= {!r}", False)
-    def __imod__(self, other): pass
-    @magic_meth_chained("{_self} **= {!r}", False)
-    def __ipow__(self, other): pass
-    @magic_meth_chained("{_self} <<= {!r}", False)
-    def __ilshift__(self, other): pass
-    @magic_meth_chained("{_self} >>= {!r}", False)
-    def __irshift__(self, other): pass
-    @magic_meth_chained("{_self} &= {!r}", False)
-    def __iand__(self, other): pass
-    @magic_meth_chained("{_self} |= {!r}", False)
-    def __ior__(self, other): pass
-    @magic_meth_chained("{_self} ^= {!r}", False)
-    def __ixor__(self, other): pass
+    @magic_meth_chained("{_self} += {!r}", aug_assign=True)
+    def __iadd__(self, other): self += other; return self
+    @magic_meth_chained("{_self} -= {!r}", aug_assign=True)
+    def __isub__(self, other): self -= other; return self
+    @magic_meth_chained("{_self} *= {!r}", aug_assign=True)
+    def __imul__(self, other): self *= other; return self
+    @magic_meth_chained("{_self} /= {!r}", aug_assign=True)
+    def __itruediv__(self, other): self /= other; return self
+    @magic_meth_chained("{_self} //= {!r}", aug_assign=True)
+    def __ifloordiv__(self, other): self //= other; return self
+    @magic_meth_chained("{_self} %= {!r}", aug_assign=True)
+    def __imod__(self, other): self %= other; return self
+    @magic_meth_chained("{_self} **= {!r}", aug_assign=True)
+    def __ipow__(self, other): self **= other; return self
+    @magic_meth_chained("{_self} <<= {!r}", aug_assign=True)
+    def __ilshift__(self, other): self <<= other; return self
+    @magic_meth_chained("{_self} >>= {!r}", aug_assign=True)
+    def __irshift__(self, other): self >>= other; return self
+    @magic_meth_chained("{_self} &= {!r}", aug_assign=True)
+    def __iand__(self, other): self &= other; return self
+    @magic_meth_chained("{_self} |= {!r}", aug_assign=True)
+    def __ior__(self, other): self |= other; return self
+    @magic_meth_chained("{_self} ^= {!r}", aug_assign=True)
+    def __ixor__(self, other): self ^= other; return self
 
     # 比较运算符
     @magic_meth_chained("{_var} = {_self} < {!r}",export=True)
-    def __lt__(self, other): pass
+    def __lt__(self, other): return self < other
     @magic_meth_chained("{_var} = {_self} <= {!r}",export=True)
-    def __le__(self, other): pass
+    def __le__(self, other): return self <= other
     @magic_meth_chained("{_var} = {_self} == {!r}",export=True)
-    def __eq__(self, other): pass
+    def __eq__(self, other): return self == other
     @magic_meth_chained("{_var} = {_self} != {!r}",export=True)
-    def __ne__(self, other): pass
+    def __ne__(self, other): return self != other
     @magic_meth_chained("{_var} = {_self} > {!r}",export=True)
-    def __gt__(self, other): pass
+    def __gt__(self, other): return self > other
     @magic_meth_chained("{_var} = {_self} >= {!r}",export=True)
-    def __ge__(self, other): pass
+    def __ge__(self, other): return self >= other
 
     # 一元运算符
     @magic_meth_chained("{_var} = -{_self}")
-    def __neg__(self): pass
+    def __neg__(self): return -self
     @magic_meth_chained("{_var} = +{_self}")
-    def __pos__(self): pass
-    @magic_meth_chained("{_var} = abs({_self})")
-    def __abs__(self): pass
+    def __pos__(self): return +self
     @magic_meth_chained("{_var} = ~{_self}")
-    def __invert__(self): pass
+    def __invert__(self): return ~self
+    __abs__ = magic_meth_chained("{_var} = abs({_self})")(abs)
 
     # 容器/迭代器
-    @magic_meth_chained("{_var} = len({_self})",export=True)
-    def __len__(self): pass
+    __len__ = magic_meth_chained("{_var} = len({_self})",export=True)(len)
     @magic_meth_chained("{_var} = {_self}[{!r}]")
-    def __getitem__(self, key): pass
+    def __getitem__(self, key): return self[key]
     @magic_meth_chained("{_self}[{!r}] = {!r}", False)
-    def __setitem__(self, key, value): pass
+    def __setitem__(self, key, value): self[key] = value
     @magic_meth_chained("del {_self}[{!r}]", False)
-    def __delitem__(self, key): pass
-    @magic_meth_chained("{_var} = reversed({_self})",export=True)
-    def __reversed__(self):pass
+    def __delitem__(self, key): del self[key]
     @magic_meth_chained("{_var} = {!r} in {_self}",export=True)
-    def __contains__(self, item):pass
-    @magic_meth_chained("{_var} = iter({_self})",export=True)
-    def __iter__(self):pass
-    @magic_meth_chained("{_var} = next({_self})",export=True)
-    def __next__(self):pass
+    def __contains__(self, item): return item in self
+    __reversed__ = magic_meth_chained("{_var} = reversed({_self})",
+                                      export=True)(reversed)
+    __iter__ = magic_meth_chained("{_var} = iter({_self})",export=True)(iter)
+    __next__ = magic_meth_chained("{_var} = next({_self})",export=True)(next)
 
     # 类型转换
-    @magic_meth_chained("{_var} = int({_self})",export=True)
-    def __int__(self):pass
-    @magic_meth_chained("{_var} = float({_self})",export=True)
-    def __float__(self):pass
-    @magic_meth_chained("{_var} = complex({_self})",export=True)
-    def __complex__(self):pass
-    @magic_meth_chained("{_var} = round({_self}, {!r})",export=True)
-    def __round__(self, ndigits=None):pass
-    @magic_meth_chained("{_var} = bool({_self})",export=True)
-    def __bool__(self): pass
-    @magic_meth_chained("{_var} = hash({_self})",export=True)
-    def __hash__(self): pass
+    __int__ = magic_meth_chained("{_var} = int({_self})",export=True)(int)
+    __float__ = magic_meth_chained("{_var} = float({_self})",export=True)(float)
+    __complex__ = magic_meth_chained("{_var} = complex({_self})",
+                                     export=True)(complex)
+    __round__ = magic_meth_chained("{_var} = round({_self}, {!r})",
+                                   export=True)(round)
+    __bool__ = magic_meth_chained("{_var} = bool({_self})",export=True)(bool)
+    __hash__ = magic_meth_chained("{_var} = hash({_self})",export=True)(hash)
 
     # 上下文管理
-    #@magic_meth_chained("with {_self}:",False,1)
     @magic_meth_chained(default_fmt=True)
-    def __enter__(self): pass
-    #@magic_meth_chained("",False,-1)
+    def __enter__(self): return self.__enter__()
     @magic_meth_chained(default_fmt=True,export=True)
-    def __exit__(self, exc_type, exc_value, traceback): pass
+    def __exit__(self, exc_type, exc_value, traceback): 
+        return self.__exit__(exc_type, exc_value, traceback)
 
     # 其他
-    @magic_meth_chained(default_fmt=True,export=True)
+    @magic_meth_chained(default_fmt=True,export=True,no_exec=False)
     def __await__(self):pass
-    @magic_meth_chained(default_fmt=True,export=True)
+    @magic_meth_chained(default_fmt=True,export=True,no_exec=False)
     def __aiter__(self):pass
     @magic_meth_chained(default_fmt=True,export=True)
-    def __fspath__(self):pass
+    def __fspath__(self):return self.__fspath__()
+
+def proxyCls(T=_EmptyTarget, chain=EMPTY_OBJ, fromvar=None):
+    # 泛型，proxyCls(T)生成类型信息为T的继承自ProxiedObj的类
+    if T is EMPTY_OBJ:
+        return ProxiedObj
+
+    class ProxyCls(ProxiedObj): # 创建同时从ProxiedObj与T继承的类
+        # pylint: disable=unused-private-member
+        __proto = T # 自身使用的原型
+        def __new__(cls,*args,**kw):
+            _chain = args[0] if args else kw.get("chain")
+            if not _isinstance(_chain,ObjChain) and chain is not EMPTY_OBJ:
+                var = chain.new_var(T.__name__)
+                if fromvar is not None:
+                    cls_ = chain.add_existing_obj(T,var,f"{var} = {fromvar}.__class__",
+                                                 [fromvar])
+                else:
+                    cls_ = chain.add_existing_obj(T,var,
+                        f"# class {var}: {shortrepr(cls,repr_func=basic_repr)}")
+                if len(args) == 3 and _isinstance(T,type):
+                    args=(args[0],tuple(unproxy_obj(cls) for cls in args[1]),args[2])
+
+                if kw:return cls_(*args,**kw)
+                return cls_(*args) # 返回ProxyCls
+            else:
+                return ProxiedObj.__new__(cls,*args,**kw)
+
+    return ProxyCls
+
 
 _isinstance = isinstance
+_getattr = getattr
 from pyobject.objproxy.builtin_hook import hook_builtins # pylint: disable=ungrouped-imports
 hook_builtins() # hook内置函数
 
 def proxy_demo():
-    chain = ObjChain(export_attrs=["__array_struct__"])
+    chain = ObjChain(export_attrs=["__array_struct__"],
+                     export_trivial_obj=True)
     try:
         np = chain.new_object("import numpy as np","np")
         plt = chain.new_object("import matplotlib.pyplot as plt","plt",

{pyobject-1.2.9.2 → pyobject-1.3.0}/pyobject/objproxy/builtin_hook.py

@@ -1,7 +1,7 @@
 # 内置函数和部分标准库函数的hook
 import sys,builtins,_collections_abc,inspect
 import collections.abc as collections_abc
-from pyobject.objproxy import ProxiedObj,accept_raw_obj
+from pyobject.objproxy import ProxiedObj
 
 _range = type(range(0)) #range
 def range(*args):
@@ -65,11 +65,9 @@ def callable(obj):
     if _isinstance(obj, ProxiedObj):
         obj = obj._ProxiedObj__target_obj
     return _callable(obj)
-def getattr(*args,**kw):
+def getattr(*args):
     if _isinstance(args[1],ProxiedObj):
         args = (args[0], args[1]._ProxiedObj__target_obj, *args[2:])
-    if "name" in kw and _isinstance(kw["name"],ProxiedObj):
-        kw["name"] = kw["name"]._ProxiedObj__target_obj
     return _getattr(*args)
 
 _pre_check_methods = _collections_abc._check_methods
@@ -138,19 +136,3 @@ def hook_builtins():
     collections_abc._check_methods = _check_methods
     inspect.signature = signature
     inspect.getattr_static = getattr_static
-
-# 内置类型的修改（备用）
-class CustomStr(builtins.str):
-    __init__ = accept_raw_obj(builtins.str,lambda args:args[1:],
-                              process_ret=lambda ret:None)
-    __new__ = accept_raw_obj(builtins.str,lambda args:args[1:])
-
-class CustomInt(builtins.int):
-    __init__ = accept_raw_obj(builtins.int,lambda args:args[1:],
-                              process_ret=lambda ret:None)
-    __new__ = accept_raw_obj(builtins.int,lambda args:args[1:])
-
-class CustomBytes(builtins.bytes):
-    __init__ = accept_raw_obj(builtins.bytes,lambda args:args[1:],
-                              process_ret=lambda ret:None)
-    __new__ = accept_raw_obj(builtins.bytes,lambda args:args[1:])

{pyobject-1.2.9.2 → pyobject-1.3.0}/pyobject/tests/test_objproxy.py

@@ -8,7 +8,7 @@ except ImportError:
     sys.path.append(path) # 加入当前pyobject库所在的目录
     from pyobject import ObjChain, ProxiedObj
 
-def current_func_name(level = 0):
+def current_func_name(level = 0): # 获取当前函数名，便于调试输出
     frame = sys._getframe()
     for i in range(level + 1):
         if frame is None:return None
@@ -87,6 +87,26 @@ class TestObjChain(unittest.TestCase):
         class Inherited(cls):pass
         Inherited().meth()
         self.print_code(chain, print_optimized = True)
+    def test_aug_assign(self):
+        class Cls:
+            def __iadd__(self, inc):return inc
+            def __isub__(self, dec):return self
+
+        chain = ObjChain()
+        obj = chain.add_existing_obj(Cls(),"obj")
+        var1=obj; var1+=1
+        self.assertEqual(var1, 1)
+        self.print_code(chain, print_optimized = True)
+    def test_setattr(self):
+        class Cls:
+            def __init__(self):
+                self.attr = 42
+
+        chain = ObjChain()
+        obj = chain.add_existing_obj(Cls(),"obj")
+        obj.attr = 1
+        self.assertEqual(obj.attr, 1)
+        self.print_code(chain)
     def test_export(self): # 测试export_funcs和export_attrs
         class Cls:
             def __init__(self):

{pyobject-1.2.9.2 → pyobject-1.3.0/pyobject.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyobject
-Version: 1.2.9.2
+Version: 1.3.0
 Summary: A multifunctional all-in-one utility tool for managing internal Python objects, compatible with nearly all Python 3 versions. 一个多功能合一的提供操作Python对象底层工具的Python包, 支持几乎所有Python 3版本。 
 Home-page: https://github.com/qfcy/pyobject
 Author: qfcy
@@ -394,11 +394,12 @@ Python内部的字节码对象\ ``CodeType``\ ，如\ ``func.__code__``\ ，是
 lst调用多次==运算符(``__eq__``)相比，
 本函数直接比较对象的指针，提高了效率。
 
-**``pyobject``\ 当前版本**: 1.2.9.2
+**``pyobject``\ 当前版本**: 1.3.0
 
 更新日志:
 ---------
 
+| 2025-6-6(v1.3.0):性能优化，提升了pyobject.objproxy模块的性能。
 | 2025-4-30(v1.2.9):改进和增强了子模块pyobject.objproxy，重命名子模块pyobject.code_为pyobject.code。
 | 2025-3-31(v1.2.8):将pyobject.super_proxy重命名为pyobject.objproxy，并正式发布；修改了pyobject.pyobj_extension模块。
 | 2025-3-6(v1.2.7):为pyobject.browser新增了\ ``dir()``\ 中不存在的类属性（如\ ``__flags__``,
@@ -886,11 +887,13 @@ Python call “obj in lst” that invokes the “==” operator (``__eq__``)
 multiple times, this function directly compares the pointers to improve
 efficiency.
 
-**Current Version of ``pyobject``**: 1.2.9.2
+**Current Version of ``pyobject``**: 1.3.0
 
 Change Log
 ----------
 
+| 2025-6-6(v1.3.0): Optimized the performance of the pyobject.objproxy
+  module.
 | 2025-4-30(v1.2.9): Improved and enhanced the sub-module
   ``pyobject.objproxy``, and renamed the sub-module ``pyobject.code_``
   to ``pyobject.code``.

{pyobject-1.2.9.2 → pyobject-1.3.0}/pyobject.egg-info/SOURCES.txt

@@ -35,7 +35,6 @@ pyobject/images/string.gif
 pyobject/images/tuple.gif
 pyobject/objproxy/__init__.py
 pyobject/objproxy/builtin_hook.py
-pyobject/objproxy/dynobj.py
 pyobject/objproxy/optimize.py
 pyobject/objproxy/utils.py
 pyobject/other/browser_chs_locale.py

pyobject-1.2.9.2/pyobject/objproxy/dynobj.py

@@ -1,190 +0,0 @@
-# 实现简单的不可变的链式求值对象（备用，也是后续ProxiedObj的原型）
-import functools
-try:from timer_tool import timer # pip install timer-tool
-except ImportError:timer=lambda func:func
-from pyobject.objproxy.utils import format_func_call
-
-ENABLE_CACHE = False
-
-def using_namespace(obj,scope,except_=[],internal=False):
-    for name in dir(obj):
-        if not internal and name.startswith("_"):continue
-        if name in except_:continue
-        scope[name]=getattr(obj,name)
-
-def unuse_namespace(obj,scope,except_=[],internal=False):
-    # 参数应和之前调用using_namespace的一致
-    for name in dir(obj):
-        if not internal and name.startswith("_"):continue
-        if name in except_:continue
-        del scope[name]
-
-def define_enum(names,local,start=0):
-    # names: 字符串列表，或者以","和\n分割的字符串
-    if isinstance(names,str):
-        ignored=str.maketrans("","","\n ")
-        names=names.translate(ignored).split(",")
-    for i,name in enumerate(names,start):
-        local[name]=i
-
-class Symbol:
-    define_enum(
-"""ADD, SUB, MUL, DIV, MOD, POW, FLOOR_DIV,
-AND, OR, XOR, NOT,
-LT, LE, EQ, NE, GT, GE,
-LSHIFT, RSHIFT,
-BIT_AND, BIT_OR, BIT_XOR, BIT_NOT,
-ASSIGN,NEG,POS,
-PLUS_ASSIGN, MINUS_ASSIGN, MUL_ASSIGN, DIV_ASSIGN, MOD_ASSIGN, POW_ASSIGN, FLOOR_DIV_ASSIGN,
-LSHIFT_ASSIGN, RSHIFT_ASSIGN, AND_ASSIGN, OR_ASSIGN, XOR_ASSIGN, HIGHEST""",
-        locals()
-    )
-
-    priority = [
-        # 优先级最低：赋值运算符
-        (ASSIGN, PLUS_ASSIGN, MINUS_ASSIGN, MUL_ASSIGN, DIV_ASSIGN, MOD_ASSIGN, POW_ASSIGN,
-         FLOOR_DIV_ASSIGN, LSHIFT_ASSIGN, RSHIFT_ASSIGN, AND_ASSIGN, OR_ASSIGN, XOR_ASSIGN),
-        # 逻辑运算符
-        (OR, AND),
-        # 比较运算符
-        (LT, LE, EQ, NE, GT, GE),
-        # 位运算符
-        (BIT_OR,),
-        (BIT_XOR,),
-        (BIT_AND,),
-        # 位移运算符
-        (LSHIFT, RSHIFT),
-        # 算术运算符
-        (ADD, SUB),
-        (MUL, DIV, MOD, FLOOR_DIV),
-        # 幂运算符
-        (POW,),
-        # 一元运算符
-        (NOT, BIT_NOT, NEG, POS),
-        # 最高优先级的占位符
-        (HIGHEST,),
-    ]
-
-PRIORITY={}
-for level in range(len(Symbol.priority)):
-    for symbol in Symbol.priority[level]:
-        PRIORITY[symbol]=level
-
-using_namespace(Symbol,globals(),["priority"])
-
-def ck(obj,symbol):
-    # 如对于x + (y * z)，outer_priority为"+"，inner_priority为"*"
-    outer_priority=PRIORITY[symbol]
-    inner_priority=PRIORITY[getattr(obj,"_DynObj__last_symbol",HIGHEST)]
-    fmt="({!r})" if outer_priority > inner_priority else "{!r}"
-    return fmt.format(obj)
-
-def magic_meth(meth): # 用于无法获知具体表达式的魔法方法调用（备用函数）
-    @functools.wraps(meth)
-    def override(self,*args,**kw):
-        return DynObj(f"{ck(self, HIGHEST)}.{meth.__name__}") # 优先级使用默认的HIGHEST
-    return override
-
-# 能包装表达式链式求值的对象（不可变）
-class DynObj:
-    _cache = {}
-    if ENABLE_CACHE:
-        def __new__(cls, code, symbol=HIGHEST):
-            if code in cls._cache:
-                return cls._cache[code]
-            instance = super().__new__(cls)
-            cls._cache[code] = instance
-            return instance
-
-    def __init__(self,code,symbol=HIGHEST):
-        self.__code=code # __code仅在__str__和__repr__使用
-        self.__last_symbol=symbol # pylint: disable=unused-private-member
-    def __call__(self,*args,**kw):
-        new_code="{}({})".format(self, format_func_call(args,kw))
-        return DynObj(new_code)
-    def __getattr__(self,name):
-        new_code="{}.{}".format(self,name)
-        return DynObj(new_code)
-    def __str__(self):
-        return self.__code
-    def __repr__(self):
-        return self.__code
-
-    # 算术运算符
-    def __add__(self, other): return DynObj(f"{ck(self, ADD)} + {ck(other,ADD)}",ADD)
-    def __sub__(self, other): return DynObj(f"{ck(self, SUB)} - {ck(other,SUB)}",SUB)
-    def __mul__(self, other): return DynObj(f"{ck(self, MUL)} * {ck(other,MUL)}",MUL)
-    def __truediv__(self, other):
-        return DynObj(f"{ck(self, DIV)} / {ck(other, DIV)}", DIV)
-    def __floordiv__(self, other):
-        return DynObj(f"{ck(self, FLOOR_DIV)} // {ck(other, FLOOR_DIV)}", FLOOR_DIV)
-    def __mod__(self, other): return DynObj(f"{ck(self, MOD)} % {ck(other, MOD)}", MOD)
-    def __pow__(self, other): return DynObj(f"{ck(self, POW)} ** {ck(other, POW)}", POW)
-    def __lshift__(self, other):
-        return DynObj(f"{ck(self, LSHIFT)} << {ck(other, LSHIFT)}", LSHIFT)
-    def __rshift__(self, other):
-        return DynObj(f"{ck(self, RSHIFT)} >> {ck(other, RSHIFT)}", RSHIFT)
-    def __and__(self, other): return DynObj(f"{ck(self, BIT_AND)} & {ck(other, BIT_AND)}", BIT_AND)
-    def __xor__(self, other): return DynObj(f"{ck(self, BIT_XOR)} ^ {ck(other, BIT_XOR)}", BIT_XOR)
-    def __or__(self, other): return DynObj(f"{ck(self, BIT_OR)} | {ck(other, BIT_OR)}", BIT_OR)
-
-    # 反向算术运算符
-    def __radd__(self, other): return DynObj(f"{ck(other, ADD)} + {ck(self, ADD)}", ADD)
-    def __rsub__(self, other): return DynObj(f"{ck(other, SUB)} - {ck(self, SUB)}", SUB)
-    def __rmul__(self, other): return DynObj(f"{ck(other, MUL)} * {ck(self, MUL)}", MUL)
-    def __rtruediv__(self, other):
-        return DynObj(f"{ck(other, DIV)} / {ck(self, DIV)}", DIV)
-    def __rfloordiv__(self, other):
-        return DynObj(f"{ck(other, FLOOR_DIV)} // {ck(self, FLOOR_DIV)}", FLOOR_DIV)
-    def __rmod__(self, other): return DynObj(f"{ck(other, MOD)} % {ck(self, MOD)}", MOD)
-    def __rpow__(self, other): return DynObj(f"{ck(other, POW)} ** {ck(self, POW)}", POW)
-    def __rlshift__(self, other):
-        return DynObj(f"{ck(other, LSHIFT)} << {ck(self, LSHIFT)}", LSHIFT)
-    def __rrshift__(self, other):
-        return DynObj(f"{ck(other, RSHIFT)} >> {ck(self, RSHIFT)}", RSHIFT)
-    def __rand__(self, other): return DynObj(f"{ck(other, BIT_AND)} & {ck(self, BIT_AND)}", BIT_AND)
-    def __rxor__(self, other): return DynObj(f"{ck(other, BIT_XOR)} ^ {ck(self, BIT_XOR)}", BIT_XOR)
-    def __ror__(self, other): return DynObj(f"{ck(other, BIT_OR)} | {ck(self, BIT_OR)}", BIT_OR)
-
-    # 比较运算符
-    def __lt__(self, other): return DynObj(f"{ck(self, LT)} < {ck(other, LT)}", LT)
-    def __le__(self, other): return DynObj(f"{ck(self, LE)} <= {ck(other, LE)}", LE)
-    def __eq__(self, other): return DynObj(f"{ck(self, EQ)} == {ck(other, EQ)}", EQ)
-    def __ne__(self, other): return DynObj(f"{ck(self, NE)} != {ck(other, NE)}", NE)
-    def __gt__(self, other): return DynObj(f"{ck(self, GT)} > {ck(other, GT)}", GT)
-    def __ge__(self, other): return DynObj(f"{ck(self, GE)} >= {ck(other, GE)}", GE)
-
-    # 一元运算符
-    def __neg__(self): return DynObj(f"-{ck(self, NEG)}", NEG)
-    def __pos__(self): return DynObj(f"+{ck(self, POS)}", POS)
-    def __abs__(self): return DynObj(f"abs({self})")
-    def __invert__(self): return DynObj(f"~{ck(self, BIT_NOT)}", BIT_NOT)
-
-    # 容器协议
-    #def __len__(self): return DynObj(f"len({self})")
-    def __getitem__(self, key): return DynObj(f"{self}[{key!r}]")
-    #def __setitem__(self, key, value): return DynObj(f"{self}[{key!r}] = {value!r}")
-    #def __delitem__(self, key): return DynObj(f"del {self}[{key!r}]")
-    #def __contains__(self, item):pass
-
-    # 类型转换 (待实现)
-    #def __int__(self):pass
-    #def __float__(self):pass
-    #def __complex__(self):pass
-    #def __round__(self, ndigits=None):pass
-
-def test():
-    _1=DynObj("1");_2=DynObj("2")
-    print(-(_1+_2)*_1)
-
-@timer
-def test_perf():
-    def recursion(x=None,recurse=10):
-        if recurse<=0:return x
-        return recursion(-(x+x)*x/x//x,recurse-1)
-
-    x=DynObj("x")
-    obj=recursion(x,10)
-    print(recursion(x,1),":",len(repr(obj)))
-
-if __name__ == "__main__":test_perf()