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

retracesoftware/config.json

@@ -434,6 +434,9 @@
       "proxy_all_except": ["Error"]
     },
 
+    "_weakrefset": {
+      "sync_types": ["WeakSet", "_IterationGuard"]
+    },
     "_collections": {
       "sync_types": [
         "deque"

retracesoftware/install/patcher.py

@@ -15,6 +15,7 @@ import gc
 import os
 import atexit
 import threading
+from types import SimpleNamespace, MethodType
 
 from retracesoftware.install.typeutils import modify
 # from retracesoftware.proxy.immutabletypes import ImmutableTypes
@@ -494,9 +495,7 @@ class Patcher:
     def patch_module_with_name(self, mod_name, module):
         with self.disable:
 
-            if mod_name == 'selectors':
-                print('DWFEWFW!!!!!!!!!')
-
+            assert self.thread_state.value == 'disabled'
 
             self.log('install.module', mod_name)
 
@@ -616,28 +615,59 @@ def install(mode):
 
     importlib.invalidate_caches()
 
-    with thread_state.select('internal'):
+    # with thread_state.select('internal'):
 
-        atexit.register(lambda: at_exit)
-        
-        for key, module in list(sys.modules.items()):
-            if not key.startswith('retracesoftware'):
-                patcher(module)
+    atexit.register(lambda: at_exit)
+    
+    for key, module in list(sys.modules.items()):
+        if not key.startswith('retracesoftware'):
+            patcher(module)
 
-        for library in config.get('preload', []):
+    for library in config.get('preload', []):
+        with thread_state.select('internal'):
             importlib.import_module(library)
 
     importlib.invalidate_caches()
     # # if env_truthy('RETRACE_TRACE_CALLS'):
     # #     trace_calls(system = retracesystem)
 
-    thread_state.value = 'internal'
+    # thread_state.value = 'internal'
 
     # import threading
     # threading.current_thread().retrace = system
 
     threading.current_thread().__retrace__ = system
 
+    def is_entry_frame(frame):
+        return frame.globals.get("__name__", None) == "__main__"
+
+    original = atexit.register
+
+    def atexit_register(function):
+        if thread_state.value == 'internal':
+            return original(thread_state.wrap('internal', function))
+        else:
+            return original(function)
+
+    atexit.register = atexit_register
+
+    def disable_after_main(frame):
+        if is_entry_frame(frame):
+            # utils.intercept_frame_eval(None)
+            thread_state.value = 'internal'
+            
+            def on_return(): 
+                thread_state.value = 'disabled'
+
+            obj = SimpleNamespace()
+            obj.on_return = on_return
+
+            return obj
+        else:
+            return disable_after_main
+
+    utils.intercept_frame_eval(disable_after_main)
+
     # utils.sigtrap(None)
 
     return system

retracesoftware/install/tracer.py

@@ -13,6 +13,38 @@ def format_kwargs(kwargs):
 
     return tuple(result)
 
+class CallTracer:
+
+    ignore = set([('abc', '__subclasscheck__'),
+                  ('threading', '_shutdown'),
+                  ('typing', 'inner')])
+    
+    def __init__(self, writer, thread_state):
+        self.writer = writer
+        self.thread_state = thread_state
+
+    def on_result(self, result):
+        if type(result) in [str]:
+            self.writer(result)
+        else:
+            self.writer(str(type(result)))
+
+    def on_error(self, exc_type, exc_value, exc_traceback):
+        pass
+
+    def __call__(self, frame):
+        if self.thread_state.value == 'internal':
+            with self.thread_state.select('disabled'):
+                func = frame.function
+                        
+                key = (func.__module__, func.__name__)
+
+                if key not in CallTracer.ignore and func.__name__ != '__hash__':
+                    self.writer(f'{func.__module__}.{func.__name__}')
+                    return self
+        else:
+            return lambda *args, **kwargs: self(*args, **kwargs)
+    
 class Tracer:
 
     def __init__(self, config, writer):
@@ -44,65 +76,66 @@ class Tracer:
 
     def trace_calls(self, thread_state):
         if 'tracecalls' in self.config:
-            def on_call(frame):
-                func = frame.function
+            # def on_call(frame):
+
+            #     func = frame.function
                 
-                key = (func.__module__, func.__name__)
+            #     key = (func.__module__, func.__name__)
 
-                ignore = set(('abc', '__subclasscheck__'),
-                             ('threading', '_shutdown'))
+            #     ignore = set([('abc', '__subclasscheck__'),
+            #                   ('threading', '_shutdown')])
 
-                if key in ignore:
-                    print('About to throw!!!')
-                    raise Exception()
+            #     if key in ignore:
+            #         print('About to throw!!!')
+            #         raise Exception()
 
-                objtype = None
+            #     objtype = None
 
-                if 'self' in frame.locals:
-                    this = frame.locals['self']
-                    objtype = type(this)
+            #     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__}')
+            #     # 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__)
+            #     qualname = (func.__module__, objtype, func.__name__)
 
-                self.writer(f'{func.__module__}.{func.__name__}')
+            #     self.writer(f'{func.__module__}.{func.__name__}')
 
-                # if func.__name__ == '_path_stat':
-                #     utils.sigtrap('_path_stat start')
+            #     # if func.__name__ == '_path_stat':
+            #     #     utils.sigtrap('_path_stat start')
 
-                return qualname
+            #     return qualname
 
-            def on_result(qualname, res):
-                mod, obj, func = 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 obj:
+            #     #     print(f'Returning!!!!: {mod}.{obj}.{func}')
+            #     # else:
+            #     #     print(f'Returning!!!!: {mod}.{func}')
 
-                # if func == '_path_stat':
-                #     utils.sigtrap('_path_stat res')
+            #     # if func == '_path_stat':
+            #     #     utils.sigtrap('_path_stat res')
 
-                if func != '__hash__':
-                    ignore = set(('typing', 'inner'))
+            #     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)))
+            #         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__}')
+            
+            callback = CallTracer(writer = self.writer, thread_state = thread_state)
+            utils.intercept_frame_eval(callback)
+                                       
     def serialize(self, obj):
         try:
             if obj is None: return None

retracesoftware/install/typeutils.py

@@ -35,6 +35,25 @@ class WithoutFlags:
     def __exit__(self, *args):
         utils.set_type_flags(self.cls, self.saved)
 
+class WithFlags:
+
+    def __init__(self, cls  , *flags):
+        self.cls = cls
+        self.flags = flags
+
+    def __enter__(self):
+        self.saved = utils.type_flags(self.cls)
+        flags = self.saved
+
+        for flag in self.flags:
+            flags |= utils.TypeFlags[flag]
+
+        utils.set_type_flags(self.cls, flags)
+        return self.cls
+
+    def __exit__(self, *args):
+        utils.set_type_flags(self.cls, self.saved)
+
 def add_flag(cls : type, flag):
     if isinstance(flag, str):
         flag = utils.TypeFlags[flag]
@@ -45,6 +64,7 @@ def add_flag(cls : type, flag):
 def modify(cls):
     return WithoutFlags(cls, "Py_TPFLAGS_IMMUTABLETYPE")
 
+
 def type_has_feature(cls, flag):
     if isinstance(flag, str):
         flag = utils.TypeFlags[flag]

retracesoftware/proxy/proxysystem.py

@@ -5,7 +5,7 @@ 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
+from retracesoftware.install.typeutils import modify, WithFlags
 
 import sys
 import gc
@@ -166,8 +166,16 @@ class ProxySystem:
 
     def proxy_function(self, obj):
         return utils.wrapped_function(handler = self.ext_handler, target = obj)
-        
+    
+    def proxy__new__(self, *args, **kwargs):
+        return self.ext_handler(*args, **kwargs)
+
     def patchtype(self, cls):
+        if not utils.is_extendable(cls):
+            with WithFlags(cls, "Py_TPFLAGS_BASETYPE"):
+                assert utils.is_extendable(cls)
+                return self.patchtype(cls)
+
         if cls in self.immutable_types or issubclass(cls, tuple):
             return cls
 
@@ -184,45 +192,18 @@ 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):
-                    setattr(extended, name, wrap_new(value) if name == '__new__' else wrap(value))
+        # slots = {'__module__': cls.__module__, '__slots__': []}
 
-                    # slots[name] = wrap_new(value) if name == '__new__' else wrap(value)
-            extended.__module__ = cls.__module__
+        extended = utils.extend_type(cls)
 
-            return extended
-            # return type(cls.__name__, (cls,), slots)
+        for name, value in superdict(cls).items():
+            if callable(value) and not is_instance_method(value):
+                setattr(extended, name, wrap_new(value) if name == '__new__' else wrap(value))
 
-        elif not utils.is_immutable(cls):
-            def update(name, f):
-                setattr(cls, name, f(getattr(cls, name)))
+                # slots[name] = wrap_new(value) if name == '__new__' else wrap(value)
+        extended.__module__ = cls.__module__
 
-            for name, value in superdict(cls).items():
-                if callable(value) and not is_instance_method(value):
-                    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)
+        return extended
 
     def __call__(self, obj):
         assert not isinstance(obj, BaseException)

retracesoftware/proxy/replay.py

@@ -154,12 +154,20 @@ class ReplayProxySystem(ProxySystem):
 
         return super().proxy_function(func)
 
+    def proxy__new__(self, __new__, *args, **kwargs):
+        func = functional.repeatedly(self.next_result)
+        func.__name__ = '__new__'
+        return super().proxy__new__(func, *args, **kwargs)
+
     def basetype(self, cls):
         return self.stub_factory.create_stubtype(StubRef(cls))
 
     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}')
@@ -222,7 +230,6 @@ class ReplayProxySystem(ProxySystem):
         print(f'on_thread_exit!!!!')
         self.reader.wake_pending()
 
-
     def __init__(self, 
                  thread_state,
                  immutable_types,
@@ -234,7 +241,7 @@ class ReplayProxySystem(ProxySystem):
 
         self.reader = stream.reader(path, 
                                     thread = thread_id,
-                                    timeout_seconds = 5)
+                                    timeout_seconds = 60)
     
         self.bindings = utils.id_dict()
         # self.set_thread_id = utils.set_thread_id

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

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

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

@@ -1,29 +1,29 @@
 retracesoftware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-retracesoftware/config.json,sha256=Nyk1Wt67_BJR-mVLoxk5Qwcf0X4z83vQ80rCBxUP03s,9182
+retracesoftware/config.json,sha256=iy5d3441PtihMT2QH-ikTYdzlf8zfIcSyvtpsJK5tUQ,9261
 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=hLOowGOKKcMTtCxQthvdC-4Cx4PCNPuBzgHy-UOBbpE,20906
+retracesoftware/install/patcher.py,sha256=Xzal6y9WZjLv5269PujaZx9ZCKb2Mbo5EBTI9qRA_Pk,21777
 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=Z1HTI74iczOjVI7sLOg8iEJ_-kMMUzC4ju_UMDyLipw,8009
-retracesoftware/install/typeutils.py,sha256=_a1PuwdCsYjG1Nkd77V-flqYtwbD4RkJVKn6Z-xABL4,1813
+retracesoftware/install/tracer.py,sha256=MiaTPlUwcRbgL4CTNhvC4Y5mUhkb--Y7_icTPhscSmY,9014
+retracesoftware/install/typeutils.py,sha256=-oFzgUfq_nHeOkj3YKZiMLlMzQhCedg3qymLiEJNkVE,2253
 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=APigIjw6S7pQHTya2YWhXwsObHDcejCWfra3OMyiLvk,8859
+retracesoftware/proxy/proxysystem.py,sha256=IicoTW06_axjJQqDVqZ8Pg3GeNUq1JsZc_fG58hCSK4,7968
 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=bU657DOuvC4m2oWgTHbsQQPtruQzbvMXCKSyp6if9kI,9655
+retracesoftware/proxy/replay.py,sha256=h5PKxG4KCgZP09zyp28fW3mE-RFX6HCmEMKPYL_kzcM,9967
 retracesoftware/proxy/stubfactory.py,sha256=eHlbzWR1LoQVkIRX1HoLPPQSOpYhOO_5R_p3buD4o7s,5256
 retracesoftware/proxy/thread.py,sha256=T1ME6DHB8O0xVnX3Rt1lMl7oCJ2Y0aoFT91D76yNICk,3073
-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,,
+retracesoftware_proxy-0.1.19.dist-info/METADATA,sha256=NOPa-An94KcKOSi2HUGmv-dmZBlijYQogJMEJRJpeqs,203
+retracesoftware_proxy-0.1.19.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+retracesoftware_proxy-0.1.19.dist-info/top_level.txt,sha256=hYHsR6txLidmqvjBMITpIHvmJJbmoCAgr76-IpZPRz8,16
+retracesoftware_proxy-0.1.19.dist-info/RECORD,,