retracesoftware-proxy 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

retracesoftware/config.json

@@ -68,7 +68,6 @@
   ],
 
   "preload": [
-    
   ],
 
   "predicates": {

retracesoftware/install/patcher.py

@@ -436,6 +436,9 @@ class Patcher:
 
     def __call__(self, module):
 
+        # if module.__name__ == 'locale':
+        #     utils.sigtrap(None)
+
         if not hasattr(module, '__retrace__'):
             configs = list(self.configs(module))
 
@@ -484,6 +487,10 @@ def install(mode):
     else:
         raise Exception(f'mode: {mode} unsupported')
     
+    importlib.import_module('locale')
+    importlib.import_module('calendar')
+    importlib.import_module('_strptime')
+
     config = load_config('config.json')
 
     states = [x for x in config['states'] if isinstance(x, str)]
@@ -514,12 +521,15 @@ def install(mode):
 
     def at_exit(): thread_state.value = 'disabled'
 
+    # print(f'MODULES: {list(sys.modules.keys())}')
+
     with thread_state.select('internal'):
 
         atexit.register(lambda: at_exit)
         
-        for module in sys.modules.values():
-            patcher(module)
+        for key, module in sys.modules.items():
+            if not key.startswith('retracesoftware'):
+                patcher(module)
 
         for library in config.get('preload', []):
             importlib.import_module(library)

retracesoftware/install/tracer.py

@@ -56,10 +56,14 @@ class Tracer:
         if name in self.config:
             self.writer(name, message)
          
+    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.writer(name, args[0].__name__, args[1:], kwargs)
             
                 return functional.firstof(write_call, func) if func else write_call

retracesoftware/proxy/proxysystem.py

@@ -55,6 +55,9 @@ class ProxySystem:
     def on_ext_error(self, err_type, err_value, err_traceback):
         pass
 
+    # def stacktrace(self):
+    #     self.tracer.stacktrace()
+
     def __init__(self, thread_state, immutable_types, tracer):
         
         self.thread_state = thread_state
@@ -78,7 +81,7 @@ class ProxySystem:
             on_result = tracer('proxy.int.result'),
             on_error = tracer('proxy.int.error'),
         )
-
+        
         ext_spec = SimpleNamespace(
             apply = thread_state.wrap('external', functional.apply),
             proxy = proxyfactory(thread_state.wrap('disabled', self.dynamic_ext_proxytype)),
@@ -92,9 +95,9 @@ class ProxySystem:
         def gateway(name, internal = functional.apply, external = functional.apply):
             default = tracer(name, unproxy_execute)
             return thread_state.dispatch(default, internal = internal, external = external)
-    
-        self.ext_handler =  self.wrap_int_to_ext(int2ext)
-        self.int_handler =  self.wrap_ext_to_int(ext2int)
+
+        self.ext_handler = self.wrap_int_to_ext(int2ext)
+        self.int_handler = self.wrap_ext_to_int(ext2int)
 
         self.ext_dispatch = gateway('proxy.int.disabled.event', internal = self.ext_handler)
         self.int_dispatch = gateway('proxy.ext.disabled.event', external = self.int_handler)
@@ -145,17 +148,21 @@ class ProxySystem:
         if utils.is_extendable(cls):
             return self.extend_type(cls)
         else:    
-            return instantiable_dynamic_proxytype(
-                    handler = self.ext_dispatch, 
-                    cls = cls,
-                    thread_state = self.thread_state,
-                    create_stub = self.create_stub())
-
+            return self.proxy_function(cls)
+        
+            # return instantiable_dynamic_proxytype(
+            #         handler = self.ext_dispatch, 
+            #         cls = cls,
+            #         thread_state = self.thread_state,
+            #         create_stub = self.create_stub())
+
+    def basetype(self, cls):
+        return cls
+    
     def extend_type(self, cls):
-
         extended = extending_proxytype(
             cls = cls,
-            base = Stub if self.create_stub() else cls,
+            base = self.basetype(cls),
             thread_state = self.thread_state, 
             ext_handler = self.ext_dispatch,
             int_handler = self.int_dispatch,
@@ -168,7 +175,7 @@ class ProxySystem:
     def function_target(self, obj): return obj
 
     def proxy_function(self, obj):
-        return utils.wrapped_function(handler = self.ext_handler,  target = obj)
+        return utils.wrapped_function(handler = self.ext_handler, target = obj)
         
     def __call__(self, obj):
         assert not isinstance(obj, BaseException)

retracesoftware/proxy/proxytype.py

@@ -228,16 +228,17 @@ def dynamic_proxytype(handler, cls):
 
     target_type = functional.sequence(utils.unwrap, functional.typeof)
     spec['__class__'] = property(target_type)
-    
-    name = f'retrace.proxied.{cls.__module__}.{cls.__name__}'
+    spec['__name__'] = cls.__name__
+    spec['__module__'] = cls.__module__
+    # name = f'retrace.proxied.{cls.__module__}.{cls.__name__}'
 
-    return type(name, (utils.Wrapped, DynamicProxy), spec)
+    return type(cls.__name__, (utils.Wrapped, DynamicProxy), spec)
 
 def dynamic_from_extended(cls):
     
     base = cls.__base__
 
-    name = f'retrace.proxied.{base.__module__}.{base.__name__}'
+    name = f'retrace.proxied1.{base.__module__}.{base.__name__}'
 
     spec = dict(cls.__dict__)
 
@@ -313,6 +314,11 @@ def create_unproxied_type(cls):
 
     bases = tuple(map(unproxy_type, cls.__bases__))
     slots = dict(cls.__dict__)
+
+    if '__slots__' in slots:
+        for slot in slots['__slots__']:
+            slots.pop(slot)
+
     # del slots['__init_subclass__']
     return type(cls.__name__, tuple(bases), slots)
 
@@ -323,7 +329,7 @@ def extending_proxytype(cls, base, thread_state, ext_handler, int_handler, on_su
     assert not issubclass(cls, ExtendingProxy)
 
     def init_subclass(subclass, **kwargs):
-        print(f'In init_subclass: {subclass} {kwargs}')
+        # print(f'In init_subclass: {subclass} {subclass.__mro__} {kwargs}')
         unproxied = create_unproxied_type(subclass)
         subclass.__retrace_unproxied__ = unproxied
 
@@ -347,7 +353,7 @@ def extending_proxytype(cls, base, thread_state, ext_handler, int_handler, on_su
     for name,value in superdict(cls).items():
         if name not in blacklist:
             if is_method_descriptor(value):
-                slots[name] = wrap(getattr(cls, name))
+                slots[name] = wrap(getattr(base, name))
             elif is_descriptor(value):
                 descriptors.append(name)
 
@@ -362,6 +368,8 @@ def extending_proxytype(cls, base, thread_state, ext_handler, int_handler, on_su
     def unproxied__new__(subclass, *args, **kwargs):
         return subclass.__retrace_unproxied__(*args, **kwargs)
       
+    assert callable(base.__new__)
+
     extended.__new__ = thread_state.dispatch(unproxied__new__, internal = base.__new__)
 
     assert not issubclass(extended.__retrace_unproxied__, ExtendingProxy)

retracesoftware/proxy/record.py

@@ -116,10 +116,13 @@ class RecordProxySystem(ProxySystem):
         
         self.on_int_call = functional.mapargs(transform = serialize, function = self.writer.handle('CALL'))
         
-        self.on_ext_result = functional.if_then_else(
-                                functional.isinstanceof(str), 
-                                self.writer.handle('RESULT'), 
-                                functional.sequence(serialize, self.writer))
+        # self.on_ext_result = functional.if_then_else(
+        #                         functional.isinstanceof(str), 
+        #                         self.writer.handle('RESULT'), 
+        #                         functional.sequence(serialize, self.writer))
+
+        self.on_ext_result = functional.sequence(serialize, 
+                                                 self.writer.handle('RESULT'))
         
         self.on_ext_error = write_error
 
@@ -131,23 +134,25 @@ class RecordProxySystem(ProxySystem):
         
         proxytype = super().dynamic_ext_proxytype(cls)
 
-        blacklist = ['__class__', '__dict__', '__module__', '__doc__']
+        ref = self.writer.handle(StubRef(proxytype))
+
+        # blacklist = ['__class__', '__dict__', '__module__', '__doc__']
 
-        methods = []
-        members = []
+        # methods = []
+        # members = []
 
-        for key,value in proxytype.__dict__.items():
-            if key not in blacklist:
-                if utils.is_method_descriptor(value):
-                    methods.append(key)
-                elif not key.startswith("__retrace"):
-                    members.append(key)
+        # for key,value in proxytype.__dict__.items():
+        #     if key not in blacklist:
+        #         if utils.is_method_descriptor(value):
+        #             methods.append(key)
+        #         elif not key.startswith("__retrace"):
+        #             members.append(key)
 
-        ref = self.writer.handle(StubRef(
-            name = cls.__name__,
-            module = cls.__module__,
-            methods = methods,
-            members = members))
+        # ref = self.writer.handle(StubRef(
+        #     name = cls.__name__,
+        #     module = cls.__module__,
+        #     methods = methods,
+        #     members = members))
         
         # list(proxytype.__dict__.keys())
 

retracesoftware/proxy/replay.py

@@ -13,6 +13,9 @@ from retracesoftware.proxy.stubfactory import StubFactory, StubFunction
 import os
 import weakref
 import traceback
+import pprint
+from itertools import count, islice
+
 # we can have a dummy method descriptor, its has a __name__ and when called, returns the next element
 
 # for types, we can patch the __new__ method
@@ -22,12 +25,63 @@ import traceback
 class ReplayError(RetraceError):
     pass
 
+def count_matching(*lists):
+    count = 0
+    for slice in zip(*lists):
+        if len(set(slice)) == 1:
+            count += 1
+        else:
+            break
+
+    return count
+
+def on_stack_mismatch(last_matching, record, replay):
+    # print('Common:')
+    # for index, common, replay, record in zip(count(), last_matching_stack, args[0], record):
+    #     if common == replay == record:
+    #         print(common)
+    if last_matching:
+        matching = count_matching(reversed(last_matching),
+                                reversed(record),
+                                reversed(replay))
+
+        print('Common stacktrace:')
+        for line in reversed(list(islice(reversed(last_matching), matching))):
+            print(line)
+        
+        print('last matching stacktrace:')
+        for line in islice(last_matching, 0, len(last_matching) - matching):
+            print(line)
+
+        print('Replay stacktrace:')
+        for line in islice(replay, 0, len(replay) - matching):
+            print(line)
+
+        print('Record stacktrace:')
+        for line in islice(record, 0, len(record) - matching):
+            print(line)
+    else:
+        matching = count_matching(reversed(record), reversed(replay))
+
+        print('Common stacktrace:')
+        for line in reversed(list(islice(reversed(record), matching))):
+            print(line)
+        
+        print('Replay stacktrace:')
+        for line in islice(replay, 0, len(replay) - matching):
+            print(line)
+
+        print('Record stacktrace:')
+        for line in islice(record, 0, len(record) - matching):
+            print(line)
+
+
 class ReplayProxySystem(ProxySystem):
     
-    def stubtype(self, cls):
-        assert not issubclass(cls, Proxy)
+    # def stubtype(self, cls):
+    #     assert not issubclass(cls, Proxy)
 
-        return dynamic_proxytype(handler = self.ext_handler, cls = cls)
+    #     return dynamic_proxytype(handler = self.ext_handler, cls = cls)
 
     def create_stub(self): return True
 
@@ -57,6 +111,7 @@ class ReplayProxySystem(ProxySystem):
 
             elif next == 'RESULT':
                 return self.messages()
+            
             elif next == 'ERROR':
                 err_type = self.messages()
                 err_value = self.messages()
@@ -94,6 +149,9 @@ class ReplayProxySystem(ProxySystem):
 
         return super().proxy_function(func)
 
+    def basetype(self, cls):
+        return self.stub_factory.create_stubtype(StubRef(cls))
+
     def __init__(self, 
                  thread_state,
                  immutable_types,
@@ -135,11 +193,20 @@ class ReplayProxySystem(ProxySystem):
         # debug = debug_level(config)
 
         # int_refs = {}
-            
+        last_matching_stack = None
+
         def read_required(required):
             obj = readnext()
             if obj != required:
-                print(f'Replay: {required} Record: {obj}')
+                if last_matching_stack:
+                    for line in last_matching_stack:
+                        print(line)
+
+                print('---------------------------------')
+                print(f'Replay: {required}')
+                print('---------------------------------')
+                print(f'Record: {obj}')
+                print('---------------------------------')
                 for i in range(5):
                     print(readnext())
 
@@ -149,13 +216,24 @@ class ReplayProxySystem(ProxySystem):
 
         def trace_writer(name, *args):
             with thread_state.select('disabled'):
-                print(f'Trace: {name} {args}')
-                
                 read_required('TRACE')
                 read_required(name)
 
-                for arg in args:
-                    read_required(arg)
+                if name == 'stacktrace':
+                    record = readnext()
+                    if args[0] == record:
+                        nonlocal last_matching_stack
+                        last_matching_stack = args[0]
+                    else:
+                        on_stack_mismatch(
+                            last_matching= last_matching_stack,
+                            record = record,
+                            replay = args[0])                        
+                        os._exit(1)
+                else:
+                    print(f'Trace: {name} {args}')
+                    for arg in args:
+                        read_required(arg)
 
         # self.tracer = Tracer(tracing_config, writer = trace_writer)
         # self.immutable_types = immutable_types

retracesoftware/proxy/stubfactory.py

@@ -13,12 +13,30 @@ class ExtendedRef:
         self.module = module
 
 class StubRef:
-    def __init__(self, module, name, methods, members):
-        self.name = name
-        self.module = module
+    def __init__(self, cls):
+        blacklist = ['__class__', '__dict__', '__module__', '__doc__', '__new__']
+
+        methods = []
+        members = []
+
+        for key,value in cls.__dict__.items():
+            if key not in blacklist:
+                if utils.is_method_descriptor(value):
+                    methods.append(key)
+                elif not key.startswith("__retrace"):
+                    members.append(key)
+
+        self.name = cls.__name__ 
+        self.module = cls.__module__
         self.methods = methods
         self.members = members
 
+    # def __init__(self, module, name, methods, members):
+    #     self.name = name
+    #     self.module = module
+    #     self.methods = methods
+    #     self.members = members
+
     def __str__(self):
         return f'StubRef(module = {self.module}, name = {self.name}, methods = {self.methods}, members = {self.members})'
 
@@ -108,6 +126,7 @@ class StubFactory:
         slots = {
             '__module__': spec.module,
             '__qualname__': spec.name,
+            '__name__': spec.name,
         }
 
         for method in spec.methods:
@@ -130,11 +149,8 @@ class StubFactory:
         return stubtype
 
     def __call__(self, spec):
-        print(f'In stubFactory.__call__ {spec}')
         if spec not in self.cache:
             self.cache[spec] = self.create_stubtype(spec)
         
         stubtype = self.cache[spec]
-        stub = stubtype.__new__(stubtype)
-        print(f'In stubFactory created new')
-        return stub
+        return stubtype.__new__(stubtype)

{retracesoftware_proxy-0.1.5.dist-info → retracesoftware_proxy-0.1.7.dist-info}/METADATA

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

{retracesoftware_proxy-0.1.5.dist-info → retracesoftware_proxy-0.1.7.dist-info}/RECORD

@@ -1,27 +1,27 @@
 retracesoftware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-retracesoftware/config.json,sha256=zhi3DZKG0pIT3Mh2EUXlzQai-U6YrknueOjMJLwNKxY,8281
+retracesoftware/config.json,sha256=fzfxZF6ES2NuPO9u9fNX8xMZ5rKZStxAHovsVTSJYzs,8276
 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=zSDmaVmgwTteF-ysMjHFbum793mt93J0gVHDOnYg2uM,17286
+retracesoftware/install/patcher.py,sha256=5tRC8XmJW0_loqX1Nqad1rkG--LlX46YwgbbMTbgASc,17598
 retracesoftware/install/predicate.py,sha256=tX7NQc0rGkyyHYO3mduYHcJHbw1wczT53m_Dpkzo6do,2679
 retracesoftware/install/record.py,sha256=tseF_jV4k4HLPTgBPJdjcahl4EQqagoiisMAdGNC52Q,3257
 retracesoftware/install/references.py,sha256=A-G651IDOfuo00MkbAdpbIQh_15ChvJ7uAVTSmE6zd4,1721
 retracesoftware/install/replay.py,sha256=VUiHvQK3mgAJEGmtE2TFs9kXzxdWtsjibEcGkhZVCVE,1830
-retracesoftware/install/tracer.py,sha256=NFilwwtopDrEXjh4ZLkwyIgvPvzApQYC6BA78B11WTQ,4675
+retracesoftware/install/tracer.py,sha256=Oqh8BhZVQVo1COfSGkFCipZGPB2Dv1b4DK3xBvloRew,4796
 retracesoftware/install/typeutils.py,sha256=_a1PuwdCsYjG1Nkd77V-flqYtwbD4RkJVKn6Z-xABL4,1813
 retracesoftware/proxy/__init__.py,sha256=ZlDZIuUmKFsE9Tvfd2EKGabTepqv8nrbr5pQhCM3IKc,193
 retracesoftware/proxy/gateway.py,sha256=xESohWXkiNm4ZutU0RgWUwxjxcBWRQ4rQyxIGQXv_F4,1590
 retracesoftware/proxy/proxyfactory.py,sha256=qhOqDfMJnLDNkQs26JqDB431MwjjRhGQi8xupJ45asg,12272
-retracesoftware/proxy/proxysystem.py,sha256=eUYinugkA2EZgTkxcXcdDntQmK5HCQp5oOwRzfhosx4,6698
-retracesoftware/proxy/proxytype.py,sha256=gHO9KAqpiIY6slxPrSoj6VdGEUpqNapBLnLOgtmJ8u8,12250
-retracesoftware/proxy/record.py,sha256=YEwfqldpb1MQGi6EngPxdbmjbCIjbz9EQCZuXubLSy4,7503
-retracesoftware/proxy/replay.py,sha256=4DxEuBlQSA6e-vB401JVfJV9Dgfesf5qbuBQBD-ApkA,7847
-retracesoftware/proxy/stubfactory.py,sha256=6dvDnbClDY1tDLIDvPYOPxuCIGsg3TYa1qf2SqrmAvg,4114
+retracesoftware/proxy/proxysystem.py,sha256=W2v0Tj0tJeAt_bg9LljQm2iwWpjNIbqUTQ92WK22TF8,6861
+retracesoftware/proxy/proxytype.py,sha256=mcg3hBG0auYXv7Dez8SwrrG5dNlDl7nH_mdQUd9Iaj4,12488
+retracesoftware/proxy/record.py,sha256=ZsJV0o-Qy874VFObtsfkSF8u9gvyUSee0UPpf9Jq6Es,7734
+retracesoftware/proxy/replay.py,sha256=RVsezEZcy4bFdPQAAztfEHz6adm8t5lBDMhpnNAqeok,10510
+retracesoftware/proxy/stubfactory.py,sha256=UnRDQHgWv2xTYaMPZPXvsa7WBh10CyItc_hsQdtOhcM,4607
 retracesoftware/proxy/thread.py,sha256=-SvnyVbANkmX2lLRpOvFtkpdpAoF6DhnnYdOOs7Q8vo,1379
-retracesoftware_proxy-0.1.5.dist-info/METADATA,sha256=UL8e1rrEM72d6HuQTTnlHOeN5un_y3tCHwwiDP-v1K4,202
-retracesoftware_proxy-0.1.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-retracesoftware_proxy-0.1.5.dist-info/top_level.txt,sha256=hYHsR6txLidmqvjBMITpIHvmJJbmoCAgr76-IpZPRz8,16
-retracesoftware_proxy-0.1.5.dist-info/RECORD,,
+retracesoftware_proxy-0.1.7.dist-info/METADATA,sha256=Ug25Z8ULRbcvl7o9RQgSjcQzKC8HDqJhLQ3Z69wLHZc,202
+retracesoftware_proxy-0.1.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+retracesoftware_proxy-0.1.7.dist-info/top_level.txt,sha256=hYHsR6txLidmqvjBMITpIHvmJJbmoCAgr76-IpZPRz8,16
+retracesoftware_proxy-0.1.7.dist-info/RECORD,,