retracesoftware-proxy 0.1.16__py3-none-any.whl → 0.1.18__py3-none-any.whl

retracesoftware/config.json

@@ -12,6 +12,7 @@
   "tracing_levels": {
     "none": [],
     "all": [
+      "tracecalls",
       "proxy.ext.disabled.call",
       "proxy.int.disabled.call",
       "proxy.wrapping.new",
@@ -157,8 +158,10 @@
 
   "modules": {
     "_frozen_importlib_external": {
-      "with_state": {
-        "disabled": ["_path_stat"]
+      "comment": {
+        "with_state": {
+          "disabled": ["_path_stat"]
+        }
       }
     },
     "_imp": {
@@ -246,16 +249,12 @@
     "builtins": {
       "patch_hash": ["object"],
 
-      "with_state": {
-        "disabled": ["__import__"]
-      },
-
       "comment": {
-        "replace": {
-          "set": "retracesoftware_utils.set",
-          "frozenset": "retracesoftware_utils.frozenset"
+        "with_state": {
+          "disabled": ["__import__"]
         }
       },
+
       "immutable_types": [
         "BaseException",
         "memoryview",
@@ -308,7 +307,9 @@
       ]
     },
     "io": {
-      "proxy": ["open_code", "open"],
+      "comment": {
+        "proxy": ["open_code", "open"]
+      },
       "path_predicates": {
         "open_code": "path",
         "open": "file"

retracesoftware/install/patcher.py

@@ -90,6 +90,9 @@ def resolve(path):
 #             for prop in properties:
 #                 self.system.add_sync(getattr(inst, prop))
 
+def replace(replacements, coll):
+    return map(lambda x: replacements.get(x, x), coll)
+
 def container_replace(container, old, new):
     if isinstance(container, dict):
         if old in container:
@@ -333,9 +336,10 @@ class Patcher:
     @patch
     def patch_exec(self, exec):
 
-        def exec_wrapper2(source, *args,**kwargs):
+        def exec_wrapper2(source, globals = None, locals = None):
             if isinstance(source, types.CodeType) and source.co_name == '<module>':
-                self(inspect.getmodule(source))
+                module = sys.modules[globals['__name__']]
+                self(module)
         
         def first(x): return x[0]
             
@@ -475,7 +479,10 @@ class Patcher:
 
                 if phase_updates:
                     self.log('install.module.phase.results', list(phase_updates.keys()))
-                    updates |= phase_updates
+                    for name,value in phase_updates.items():
+                        if value is not None:
+                            updates[name] = value
+                    # updates |= phase_updates
                 
         return updates
 
@@ -486,7 +493,10 @@ class Patcher:
 
     def patch_module_with_name(self, mod_name, module):
         with self.disable:
-            print(f'Patching: {module}')
+
+            if mod_name == 'selectors':
+                print('DWFEWFW!!!!!!!!!')
+
 
             self.log('install.module', mod_name)
 
@@ -504,6 +514,10 @@ class Patcher:
                 for ref in gc.get_referrers(value):
                     if ref is not originals:
                         container_replace(container = ref, old = value, new = updates[name])
+                if isinstance(updates[name], type) and isinstance(value, type) and issubclass(updates[name], value):
+                    for subclass in value.__subclasses__():
+                        if subclass not in updates.values():
+                            subclass.__bases__ = tuple(replace({value: updates[name]}, subclass.__bases__))
 
             module.__retrace__ = originals
 
@@ -511,13 +525,9 @@ class Patcher:
                 self.post_commit(mod_name, updates)
 
     def __call__(self, module):
-
-        print(f'patcher called with: {module} {self.thread_state.value}')
-
+        
         if not hasattr(module, '__retrace__'):
 
-            print(f'patcher called with: {module} 1')
-
             configs = list(self.configs(module))
 
             if len(configs) > 0:
@@ -604,6 +614,8 @@ def install(mode):
 
     # print(f'MODULES: {list(sys.modules.keys())}')
 
+    importlib.invalidate_caches()
+
     with thread_state.select('internal'):
 
         atexit.register(lambda: at_exit)
@@ -615,6 +627,7 @@ def install(mode):
         for library in config.get('preload', []):
             importlib.import_module(library)
 
+    importlib.invalidate_caches()
     # # if env_truthy('RETRACE_TRACE_CALLS'):
     # #     trace_calls(system = retracesystem)
 

retracesoftware/install/tracer.py

@@ -4,6 +4,7 @@ from retracesoftware.proxy.proxytype import Proxy
 
 import types
 import os
+import sys
 
 def format_kwargs(kwargs):
     result = []
@@ -41,6 +42,67 @@ class Tracer:
             print(f'systrace RAISED ERROR!')
             raise
 
+    def trace_calls(self, thread_state):
+        if 'tracecalls' in self.config:
+            def on_call(frame):
+                func = frame.function
+                
+                key = (func.__module__, func.__name__)
+
+                ignore = set(('abc', '__subclasscheck__'),
+                             ('threading', '_shutdown'))
+
+                if key in ignore:
+                    print('About to throw!!!')
+                    raise Exception()
+
+                objtype = None
+
+                if 'self' in frame.locals:
+                    this = frame.locals['self']
+                    objtype = type(this)
+
+                # if objtype:
+                #     print(f'Called!!!!: {func.__module__}.{objtype.__name__}.{func.__name__}')
+                # else:
+                #     print(f'Called!!!!: {func.__module__}.{func.__name__}')
+
+                qualname = (func.__module__, objtype, func.__name__)
+
+                self.writer(f'{func.__module__}.{func.__name__}')
+
+                # if func.__name__ == '_path_stat':
+                #     utils.sigtrap('_path_stat start')
+
+                return qualname
+
+            def on_result(qualname, res):
+                mod, obj, func = qualname
+
+                # if obj:
+                #     print(f'Returning!!!!: {mod}.{obj}.{func}')
+                # else:
+                #     print(f'Returning!!!!: {mod}.{func}')
+
+                # if func == '_path_stat':
+                #     utils.sigtrap('_path_stat res')
+
+                if func != '__hash__':
+                    ignore = set(('typing', 'inner'))
+
+                    if qualname not in ignore:
+                        if type(res) in [str, int]:
+                            self.writer(res)
+                        else:
+                            self.writer(str(type(res)))
+
+            def on_call_disabled(frame):
+                func = frame.function
+                print(f'disabled: {func.__module__}.{func.__name__}')
+                
+            utils.intercept_frame_eval(on_call = thread_state.dispatch(utils.noop, internal = thread_state.wrap('disabled', on_call)),
+                                       on_result = thread_state.dispatch(utils.noop, internal = thread_state.wrap('disabled', on_result)))
+
     def serialize(self, obj):
         try:
             if obj is None: return None
@@ -82,14 +144,14 @@ class Tracer:
     def checkpoint(self, obj):
         self.writer(obj)
 
-    def stacktrace(self):
-        self.writer('stacktrace', utils.stacktrace())
+    # def stacktrace(self):
+    #     self.writer('stacktrace', utils.stacktrace())
 
     def __call__(self, name, func = None):
         if name in self.config:
             if name.endswith('.call'):
                 def write_call(*args, **kwargs):
-                    self.stacktrace()
+                    # self.stacktrace()
                     if len(args) > 0:
                         self.writer(name, args[0].__name__, args[1:], kwargs)
                     else:
@@ -126,11 +188,11 @@ class Tracer:
 
                 return wrapper
             
-            elif name.endswith('.stack'):
-                def write_event(*args, **kwargs):
-                    self.writer(name, utils.stacktrace())
+            # elif name.endswith('.stack'):
+            #     def write_event(*args, **kwargs):
+            #         self.writer(name, utils.stacktrace())
 
-                return functional.firstof(write_event, func) if func else write_event
+            #     return functional.firstof(write_event, func) if func else write_event
 
 
         return func

retracesoftware/proxy/proxysystem.py

@@ -5,6 +5,8 @@ from retracesoftware.proxy.gateway import adapter_pair
 from types import SimpleNamespace
 from retracesoftware.proxy.proxytype import *
 from retracesoftware.proxy.stubfactory import Stub
+from retracesoftware.install.typeutils import modify
+
 import sys
 import gc
 
@@ -115,6 +117,8 @@ class ProxySystem:
             func = self.thread_state.dispatch(lambda *args: None, internal = func)
             sys.settrace(func)
 
+        tracer.trace_calls(thread_state)
+
     def new_child_path(self, path):
         return path.parent / f'fork-{self.fork_counter}' / path.name
 
@@ -152,7 +156,8 @@ class ProxySystem:
             breakpoint()
 
         proxytype = dynamic_proxytype(handler = self.ext_dispatch, cls = cls)
-        
+        proxytype.__retrace_source__ = 'external'
+
         if self.on_proxytype: self.on_proxytype(proxytype)
         
         return proxytype
@@ -163,13 +168,10 @@ class ProxySystem:
         return utils.wrapped_function(handler = self.ext_handler, target = obj)
         
     def patchtype(self, cls):
-        print(f'Proxying type: {cls}')
-
         if cls in self.immutable_types or issubclass(cls, tuple):
             return cls
 
         def wrap(func):
-            print(f'Wrapping: {cls.__name__}.{func.__name__}')
             return self.thread_state.dispatch(func, internal = self.proxy_function(func))
 
         def wrap_new(func):
@@ -182,14 +184,29 @@ class ProxySystem:
             
             return self.thread_state.dispatch(func, internal = new)
 
+        # with modify(cls):
+        #     def update(name, f):
+        #         setattr(cls, name, f(getattr(cls, name)))
+
+        #     for name, value in superdict(cls).items():
+        #         if callable(value) and not is_instance_method(value):
+        #             update(name, wrap_new if name == '__new__' else wrap)
+        
+        # return cls
         if utils.is_extendable(cls):
             slots = {'__module__': cls.__module__, '__slots__': []}
 
+            extended = utils.extend_type(cls)
+
             for name, value in superdict(cls).items():
                 if callable(value) and not is_instance_method(value):
-                    slots[name] = wrap_new(value) if name == '__new__' else wrap(value)
+                    setattr(extended, name, wrap_new(value) if name == '__new__' else wrap(value))
+
+                    # slots[name] = wrap_new(value) if name == '__new__' else wrap(value)
+            extended.__module__ = cls.__module__
 
-            return type(cls.__name__, (cls,), slots)
+            return extended
+            # return type(cls.__name__, (cls,), slots)
 
         elif not utils.is_immutable(cls):
             def update(name, f):
@@ -197,7 +214,13 @@ class ProxySystem:
 
             for name, value in superdict(cls).items():
                 if callable(value) and not is_instance_method(value):
-                    update(name, wrap_new if name == '__new__' else wrap)
+                    if name == '__new__':
+                        handler = self.thread_state.dispatch(functional.apply, internal = self.ext_handler)
+
+                        utils.intercept__new__(type = cls, handler = handler)
+                    else:
+                        update(name, wrap)                        
+                    # update(name, wrap_new if name == '__new__' else wrap)
         else:
             return wrap(cls)
 
@@ -220,6 +243,8 @@ class ProxySystem:
             return classmethod(func)
         else:
             proxytype = dynamic_proxytype(handler = self.ext_dispatch, cls = type(obj))
+            proxytype.__retrace_source__ = 'external'
+
             if self.on_proxytype: self.on_proxytype(proxytype)
 
             return utils.create_wrapped(proxytype, obj)

retracesoftware/proxy/proxytype.py

@@ -3,14 +3,11 @@ import retracesoftware.functional as functional
 
 import types
 
-from retracesoftware.proxy.stubfactory import StubMethodDescriptor
+from retracesoftware.proxy.stubfactory import StubMethodDescriptor, Stub
 
 class Proxy:
     __slots__ = []
 
-class Stub(Proxy):
-    __slots__ = []
-
 class DynamicProxy(Proxy):
     __slots__ = []
 
@@ -241,8 +238,14 @@ def dynamic_proxytype(handler, cls):
 
     spec['__retrace_target_class__'] = cls
 
-    target_type = functional.sequence(utils.unwrap, functional.typeof)
-    spec['__class__'] = property(target_type)
+    # target_type = functional.sequence(utils.unwrap, functional.typeof)
+
+    target_type = cls.__retrace_target_type__ if issubclass(cls, Stub) else cls
+    # functional.repeatedly(resolved)
+
+    # spec['__class__'] = property(target_type)
+    spec['__class__'] = property(functional.constantly(target_type))
+
     spec['__name__'] = cls.__name__
     spec['__module__'] = cls.__module__
     # name = f'retrace.proxied.{cls.__module__}.{cls.__name__}'
@@ -288,6 +291,7 @@ def instantiable_dynamic_proxytype(handler, cls, thread_state, create_stub = Fal
 def dynamic_int_proxytype(handler, cls, bind):
     proxytype = dynamic_proxytype(handler = handler, cls = cls)
     proxytype.__new__ = functional.sequence(proxytype.__new__, functional.side_effect(bind))
+    proxytype.__retrace_source__ = 'internal'
     return proxytype
                                     
 

retracesoftware/proxy/replay.py

@@ -160,9 +160,6 @@ class ReplayProxySystem(ProxySystem):
     def readnext(self):
         with self.thread_state.select('disabled'):
             try:
-                # obj = self.messages()
-                # print(f'read {obj}')
-                # return obj
                 return self.messages()
             except Exception as error:
                 # print(f'Error reading stream: {error}')
@@ -194,7 +191,7 @@ class ReplayProxySystem(ProxySystem):
             os._exit(1)
             raise Exception(f'Expected: {required} but got: {obj}')
         
-        self.last_matching_stack = utils.stacktrace()
+        # self.last_matching_stack = utils.stacktrace()
 
     def trace_writer(self, name, *args):
         with self.thread_state.select('disabled'):
@@ -205,6 +202,8 @@ class ReplayProxySystem(ProxySystem):
             self.read_required(name)
 
             if name == 'stacktrace':
+                print('FOOO!!!')
+                os._exit(1)
                 record = self.readnext()
                 if args[0] == record:
                     self.last_matching_stack = args[0]
@@ -272,7 +271,7 @@ class ReplayProxySystem(ProxySystem):
         self.reader.type_deserializer[StubRef] = self.stub_factory
         self.reader.type_deserializer[GlobalRef] = lambda ref: ref()
                 
-        read_sync = functional.lazy(self.read_required, 'SYNC')
+        read_sync = functional.lazy(thread_state.wrap('disabled', self.read_required), 'SYNC')
 
         self.sync = lambda function: utils.observer(on_call = read_sync, function = function)
 

retracesoftware/proxy/stubfactory.py

@@ -152,12 +152,16 @@ class StubFactory:
 
         if isinstance(resolved, type):
             slots['__class__'] = property(functional.repeatedly(resolved))
+        # else:
+        #     utils.sigtrap(f'{spec.module}.{spec.name}')
 
         stubtype = type(spec.name, (Stub, ), slots)
 
         for method in spec.methods:
             slots[method].__objclass__ = stubtype
 
+        stubtype.__retrace_target_type__ = resolved
+
         return stubtype
 
     def __call__(self, spec):

{retracesoftware_proxy-0.1.16.dist-info → retracesoftware_proxy-0.1.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: retracesoftware_proxy
-Version: 0.1.16
+Version: 0.1.18
 License: Apache-2.0
 Requires-Dist: retracesoftware_utils
 Requires-Dist: retracesoftware_functional

{retracesoftware_proxy-0.1.16.dist-info → retracesoftware_proxy-0.1.18.dist-info}/RECORD

@@ -1,29 +1,29 @@
 retracesoftware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-retracesoftware/config.json,sha256=kV7FMjIQodixCx35I-3JIivOgRd_BzGJgpx_2naw-K4,9229
+retracesoftware/config.json,sha256=Nyk1Wt67_BJR-mVLoxk5Qwcf0X4z83vQ80rCBxUP03s,9182
 retracesoftware/config.yaml,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 retracesoftware/install/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 retracesoftware/install/config.py,sha256=EzE5ifQF2lo--hu2njI4T0FJ-zlnWDJV6i7x0DMkVTw,1364
 retracesoftware/install/edgecases.py,sha256=NR3lyvad9sRsyeDv_Ya8V4xMgPsMPOi9rMcnFOJGOEA,6330
 retracesoftware/install/globals.py,sha256=F8XvIoZQQ10gSRalk30dvdKllxlwxkaggYY6FogLDxY,510
 retracesoftware/install/install.py,sha256=HCD_ji8XCr96b5fNzNdL_8qcEp0Jf05Em7T6GA6u8HU,4969
-retracesoftware/install/patcher.py,sha256=b_VSG7EG1hhFh1VsAV2dHDRCiABpnEXvX_o5bsQXCDA,20268
+retracesoftware/install/patcher.py,sha256=hLOowGOKKcMTtCxQthvdC-4Cx4PCNPuBzgHy-UOBbpE,20906
 retracesoftware/install/predicate.py,sha256=tX7NQc0rGkyyHYO3mduYHcJHbw1wczT53m_Dpkzo6do,2679
 retracesoftware/install/record.py,sha256=R2GOIA_WAggrNmVwZJh9r1xp-GVu43iKq-ykQ1VKEHE,3408
 retracesoftware/install/references.py,sha256=A-G651IDOfuo00MkbAdpbIQh_15ChvJ7uAVTSmE6zd4,1721
 retracesoftware/install/replay.py,sha256=VUiHvQK3mgAJEGmtE2TFs9kXzxdWtsjibEcGkhZVCVE,1830
-retracesoftware/install/tracer.py,sha256=cHEjiVxIp2iVTJEWndwSbMuiXVyGJQxJYZSGrfpSbCw,5723
+retracesoftware/install/tracer.py,sha256=Z1HTI74iczOjVI7sLOg8iEJ_-kMMUzC4ju_UMDyLipw,8009
 retracesoftware/install/typeutils.py,sha256=_a1PuwdCsYjG1Nkd77V-flqYtwbD4RkJVKn6Z-xABL4,1813
 retracesoftware/proxy/__init__.py,sha256=ntIyqKhBRkKEkcW_oOPodikh-mxYl8OXRnSaj-9-Xwc,178
 retracesoftware/proxy/gateway.py,sha256=xESohWXkiNm4ZutU0RgWUwxjxcBWRQ4rQyxIGQXv_F4,1590
 retracesoftware/proxy/globalref.py,sha256=yXtJsOeBHN9xoEgJWA3MJco-jD2SQUef_fDatA4A6rg,803
 retracesoftware/proxy/proxyfactory.py,sha256=qhOqDfMJnLDNkQs26JqDB431MwjjRhGQi8xupJ45asg,12272
-retracesoftware/proxy/proxysystem.py,sha256=8PTljvtxb0PEqYElaGREAfEgR5EpqDhutpttFox6vWg,7858
-retracesoftware/proxy/proxytype.py,sha256=hP-1vJmWBa9KgZFB3CnZy0UbC4u8Wr2e76lGI0JM2SA,12992
+retracesoftware/proxy/proxysystem.py,sha256=APigIjw6S7pQHTya2YWhXwsObHDcejCWfra3OMyiLvk,8859
+retracesoftware/proxy/proxytype.py,sha256=83y5rQRSts-5rLZu_k3tT90mwX2M-Ny6RZ91l-LTJ6k,13199
 retracesoftware/proxy/record.py,sha256=47vhAYIUrR2bWo-rQ9xU_Xyg3kNrA5Lqq4-8Cxg4-zg,5463
-retracesoftware/proxy/replay.py,sha256=RWfmTrbeLFCSvV26ow1iwitf1wWt6XfypMcKIxYXZEg,9669
-retracesoftware/proxy/stubfactory.py,sha256=37UX1r8HCAbASTwPdz8QKCrg72NQmM5PsiCho7N2nzg,5129
+retracesoftware/proxy/replay.py,sha256=bU657DOuvC4m2oWgTHbsQQPtruQzbvMXCKSyp6if9kI,9655
+retracesoftware/proxy/stubfactory.py,sha256=eHlbzWR1LoQVkIRX1HoLPPQSOpYhOO_5R_p3buD4o7s,5256
 retracesoftware/proxy/thread.py,sha256=T1ME6DHB8O0xVnX3Rt1lMl7oCJ2Y0aoFT91D76yNICk,3073
-retracesoftware_proxy-0.1.16.dist-info/METADATA,sha256=zTBolyYWW1whamxpNcJQR32CR3rP4XWQM2zmEoZuAWE,203
-retracesoftware_proxy-0.1.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-retracesoftware_proxy-0.1.16.dist-info/top_level.txt,sha256=hYHsR6txLidmqvjBMITpIHvmJJbmoCAgr76-IpZPRz8,16
-retracesoftware_proxy-0.1.16.dist-info/RECORD,,
+retracesoftware_proxy-0.1.18.dist-info/METADATA,sha256=RMIcM6zELH7mx-kFXHOCxtAu55602_u0NgJOUSJVwzc,203
+retracesoftware_proxy-0.1.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+retracesoftware_proxy-0.1.18.dist-info/top_level.txt,sha256=hYHsR6txLidmqvjBMITpIHvmJJbmoCAgr76-IpZPRz8,16
+retracesoftware_proxy-0.1.18.dist-info/RECORD,,