retracesoftware-proxy 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

retracesoftware/config.json

@@ -164,6 +164,9 @@
     "sys": {
       "with_state": {
         "disabled": ["excepthook"]
+      },
+      "with_state_recursive0": {
+        "disabled": ["settrace", "setprofile"]
       }
     },
     
@@ -293,6 +296,10 @@
         "_path_normpath"
       ],
 
+      "with_state_recursive0": {
+        "disabled": ["register_at_fork"]
+      },
+
       "wrappers": {
         "fork_exec": "retracesoftware.install.edgecases.fork_exec",
         "posix_spawn": "retracesoftware.install.edgecases.posix_spawn"

retracesoftware/install/install.py

@@ -58,7 +58,7 @@ class MethodDescriptor:
         self.cls = descriptor.__objclass__
         self.name = descriptor.name
 
-def once(*args): return functional.memoize_one_arg(functional.compose(*args))
+def once(*args): return functional.memoize_one_arg(functional.sequence(*args))
 
 any = functional.firstof
 
@@ -121,7 +121,7 @@ def replaying_proxy_factory(thread_state, is_immutable_type, tracer, next, bind,
             on_call = tracer('proxy.ext.call'),
             on_result = tracer('proxy.ext.result'),
             on_error = tracer('proxy.ext.error'),
-            function = functional.compose(functional.always(next), create_stubs))
+            function = functional.sequence(functional.always(next), create_stubs))
 
     return ProxyFactory(thread_state = thread_state,
                         is_immutable_type = is_immutable_type,
@@ -131,30 +131,6 @@ def replaying_proxy_factory(thread_state, is_immutable_type, tracer, next, bind,
                         wrap_int_call = wrap_int_call,
                         wrap_ext_call = wrap_ext_call)
 
-def latest_from_pattern(pattern: str) -> str | None:
-    """
-    Given a strftime-style filename pattern (e.g. "recordings/%Y%m%d_%H%M%S_%f"),
-    return the path to the most recent matching file, or None if no files exist.
-    """
-    # Turn strftime placeholders into '*' for globbing
-    # (very simple replacement: %... -> *)
-    glob_pattern = re.sub(r"%[a-zA-Z]", "*", pattern)
-
-    # Find all matching files
-    candidates = glob.glob(glob_pattern)
-    if not candidates:
-        return None
-
-    # Derive the datetime format from the pattern (basename only)
-    base_pattern = os.path.basename(pattern)
-
-    def parse_time(path: str):
-        name = os.path.basename(path)
-        return datetime.strptime(name, base_pattern)
-
-    # Find the latest by parsed timestamp
-    latest = max(candidates, key=parse_time)
-    return latest
 
 # class Reader:
 

retracesoftware/install/patcher.py

@@ -24,7 +24,7 @@ from retracesoftware.install.config import load_config
 
 from functools import wraps
 
-import retracesoftware_functional as functional
+import retracesoftware.functional as functional
 import retracesoftware_utils as utils
 
 from retracesoftware.install import edgecases
@@ -158,13 +158,14 @@ def wrap_method_descriptors(wrapper, prefix, base):
 class Patcher:
 
     def __init__(self, thread_state, config, system, 
-                 immutable_types, 
+                 immutable_types,
                  on_function_proxy = None, 
                  debug_level = 0,
                  post_commit = None):
         
         # validate(config)
-        utils.set_thread_id(0)
+        # system.set_thread_id(0)
+        # utils.set_thread_id(0)
         self.thread_counter = system.sync(utils.counter(1))
         # self.set_thread_number = set_thread_number
 
@@ -217,6 +218,7 @@ class Patcher:
         for name in spec:
             if name in mod_dict:
                 if isinstance(mod_dict[name], type):
+                    assert isinstance(mod_dict[name], type)
                     self.immutable_types_set.add(mod_dict[name])
                 else:
                     raise Exception(f'Tried to add "{name}" - {mod_dict[name]} which isn\'t a type to immutable')
@@ -264,7 +266,7 @@ class Patcher:
 
             def threadrunner(*args, **kwargs):
                 nonlocal thread_id
-                utils.set_thread_id(thread_id)
+                self.system.set_thread_id(thread_id)
                 
                 with self.thread_state.select('internal'):
                     # if self.tracing:
@@ -304,6 +306,23 @@ class Patcher:
     def sync_types(self, value):
         return wrap_method_descriptors(self.system.sync, "retrace", value)
 
+    @phase
+    def with_state_recursive(self, spec, mod_dict):
+
+        updates = {}
+
+        for state,elems in spec.items():
+
+            def wrap(obj): 
+                return functional.recursive_wrap(
+                    callable, 
+                    lambda f: self.thread_state.wrap(state, f),
+                    obj)
+            
+            updates.update(map_values(wrap, select_keys(elems, mod_dict)))
+        
+        return updates
+
     @phase
     def with_state(self, spec, mod_dict):
 
@@ -321,7 +340,9 @@ class Patcher:
     def patch_extension_exec(self, exec):
         
         def wrapper(module):
-            res = exec(module)
+            with self.thread_state.select('internal'):
+                res = exec(module)
+
             self(module)
             return res
 
@@ -342,7 +363,7 @@ class Patcher:
         assert callable(param)
         
         return functional.if_then_else(
-            test = functional.compose(param, self.path_predicate),
+            test = functional.sequence(param, self.path_predicate),
             then = func, 
             otherwise = self.thread_state.wrap('disabled', func)) 
         
@@ -356,13 +377,14 @@ class Patcher:
             name = parts[0]
             if name in mod_dict:
                 value = mod_dict[name]
-
+                assert not isinstance(value, utils.wrapped_function), f"value for key: {name} is already wrapped"
                 if len(parts) == 1:
                     updates[name] = resolve(wrapper_name)(value)
                 elif len(parts) == 2:
                     member = getattr(value, parts[1], None)
                     if member:
-                        setattr(value, parts[1], resolve(wrapper_name)(member))
+                        new_value = resolve(wrapper_name)(member)
+                        setattr(value, parts[1], new_value)
                 else:
                     raise Exception('TODO')
                 
@@ -434,6 +456,23 @@ def env_truthy(key, default=False):
         return default
     return value.strip().lower() in ("1", "true", "yes", "on")
 
+class ImmutableTypes(set):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def __contains__(self, item):
+        assert isinstance(item, type)
+        
+        if super().__contains__(item):
+            return True
+
+        for elem in self:
+            if issubclass(item, elem):
+                self.add(item)
+                return True
+
+        return False            
+
 def install(mode):
 
     create_system = None
@@ -451,7 +490,7 @@ def install(mode):
 
     thread_state = utils.ThreadState(*states)
 
-    immutable_types = set()
+    immutable_types = ImmutableTypes()
 
     if 'RETRACE_RECORDING_PATH' in os.environ:
         config['recording_path'] = os.environ['RETRACE_RECORDING_PATH']
@@ -463,6 +502,10 @@ def install(mode):
                            immutable_types = immutable_types,
                            config = config)
 
+    os.register_at_fork(before = system.before_fork, 
+                        after_in_parent = system.after_fork_in_parent,
+                        after_in_child = system.after_fork_in_child)
+    
     patcher = Patcher(thread_state = thread_state,
                       config = config,
                       system = system,

retracesoftware/install/record.py

@@ -13,6 +13,10 @@ from datetime import datetime
 import json
 from pathlib import Path
 
+class ThreadSwitch:
+    def __init__(self, id):
+        self.id = id
+
 def write_files(recording_path):
     with open(recording_path / 'env', 'w') as f:
         json.dump(dict(os.environ), f, indent=2)
@@ -38,9 +42,12 @@ def tracing_level(config):
 #     level = os.environ.get('RETRACE_DEBUG', config['default_tracing_level'])
 #     return config['tracing_levels'].get(level, {})
 
-def thread_aware_writer(writer):
-    on_thread_switch = functional.sequence(utils.thread_id(), writer.handle('THREAD_SWITCH'))
-    return utils.threadawareproxy(on_thread_switch = on_thread_switch, target = writer)
+def merge_config(base, override):
+    if isinstance(base, dict) and isinstance(override, dict):
+        ...
+    else:
+        return override
+
 
 def record_system(thread_state, immutable_types, config):
 
@@ -57,7 +64,7 @@ def record_system(thread_state, immutable_types, config):
     with open(recording_path / 'tracing_config.json', 'w') as f:
         json.dump(tracing_config, f, indent=2)
 
-    writer = thread_aware_writer(stream.writer(path = recording_path / 'trace.bin'))
+    # writer = stream.writer(path = recording_path / 'trace.bin')
     
     # os.register_at_fork(
     #     # before = self.thread_state.wrap('disabled', self.before_fork),
@@ -86,43 +93,11 @@ def record_system(thread_state, immutable_types, config):
     #         self.gc_end()
     # gc.callbacks.append(self.gc_hook)
 
-    w = writer.handle('TRACE')
-    def trace_writer(*args):
-        print(f'Trace: {args}')
-        w(*args)
-
     # print(f'Tracing config: {tracing_config(config)}')
 
-    tracer = Tracer(tracing_config, writer = trace_writer)
     # tracer = Tracer(config = tracing_config(config), writer = writer.handle('TRACE'))
 
-    factory = RecordProxySystem(thread_state = thread_state,
-                                immutable_types = immutable_types, 
-                                tracer = tracer,
-                                writer = writer)
-    
-    # factory.proxy_type = compose(factory.proxy_type, side_effect(...))
-
-    def on_patched(module_name, updates):
-        ...
-        # for name, value in updates.items():
-        #     if isinstance(value, type) and \
-        #        issubclass(value, ExtendingProxy) and \
-        #        not issubclass(value, InternalProxy):
-            
-        #         ref = writer.handle(ExtendingProxySpec(module = module_name, name = name))
-        #         try:
-        #             writer.add_type_serializer(cls = value, serializer = functional.constantly(ref))
-        #         except:
-        #             pass
-
-    factory.on_patched = on_patched
-
-    factory.sync = lambda function: functional.observer(on_call = functional.always(writer.handle('SYNC')), function = function)
-
-    # factory.set_thread_number = writer.thread_number
-    factory.tracer = tracer
-
-    factory.log = functional.partial(writer, 'LOG')
-
-    return factory
+    return RecordProxySystem(thread_state = thread_state,
+                             immutable_types = immutable_types, 
+                             tracing_config = tracing_config,
+                             path = recording_path / 'trace.bin')

retracesoftware/install/replay.py

@@ -1,12 +1,8 @@
 from retracesoftware.proxy import *
 
-import retracesoftware.functional as functional
-import retracesoftware_utils as utils
-import retracesoftware.stream as stream
-from retracesoftware.install.tracer import Tracer
 from retracesoftware.install import globals
 
-import os, json, re, glob, weakref
+import os, json, re, glob
 from pathlib import Path
 from datetime import datetime
 
@@ -35,15 +31,6 @@ def latest_from_pattern(pattern: str) -> str | None:
     latest = max(candidates, key=parse_time)
     return latest
 
-
-
-def thread_aware_reader(reader):
-    def on_thread_switch():
-        ...
-
-    return utils.threadawareproxy(on_thread_switch = on_thread_switch, target = reader)
-
-
 def replay_system(thread_state, immutable_types, config):
 
     recording_path = Path(latest_from_pattern(config['recording_path']))
@@ -61,91 +48,7 @@ def replay_system(thread_state, immutable_types, config):
     with open(recording_path / "tracing_config.json", "r", encoding="utf-8") as f:
         tracing_config = json.load(f)
 
-    handler = None
-
-    # def create_stub_type(proxyspec):
-    #     if isinstance(proxyspec, ExtendingProxySpec):
-    #         mod = sys.modules[proxyspec.module]
-    #         resolved = getattr(mod, proxyspec.name) 
-    #         assert issubclass(resolved, ExtendingProxy)
-
-    #         return resolved
-    #         # unproxied = resolved.__base__            
-    #         # print(f'base: {unproxied} has_generic_new: {utils.has_generic_new(unproxied)}')
-    #         # print(f'base: {unproxied} has_generic_alloc: {utils.has_generic_alloc(unproxied)}')
-    #         # utils.create_stub_object(resolved)
-    #         # os._exit(1)
-    #         # return resolved
-
-    #     elif isinstance(proxyspec, WrappingProxySpec):            
-    #         nonlocal handler
-    #         return proxyspec.create_type(handler)
-    #     else:
-    #         print(f'In create_stub_type!!!! {proxyspec}')
-    #         os._exit(1)
-
-    # deserializer = functional.compose(pickle.loads, functional.when_instanceof(ProxySpec, create_stub_type))
-
-    reader = thread_aware_reader(stream.reader(path = recording_path / 'trace.bin'))
-
-    # reader = utils.threadawareproxy(on_thread_switch = ..., target = reader)
-
-    def readnext():
-        return reader()
-        # print(f'read: {obj}')
-        # return obj
-
-    lookup = weakref.WeakKeyDictionary()
-    
-    # debug = debug_level(config)
-
-    # int_refs = {}
-        
-    def checkpoint(replay):
-        ...
-
-    def read_required(required):
-        obj = readnext()
-        if obj != required:
-            print(f'Expected: {required} but got: {obj}')
-            for i in range(5):
-                readnext()
-
-            utils.sigtrap(None)
-            os._exit(1)
-            raise Exception(f'Expected: {required} but got: {obj}')
-
-    def trace_writer(name, *args):
-        print(f'Trace: {name} {args}')
-        
-        read_required('TRACE')
-        read_required(name)
-
-        for arg in args:
-            read_required(arg)
-
-    tracer = Tracer(tracing_config, writer = trace_writer)
-
-    factory = ReplayProxySystem(thread_state = thread_state, 
+    return ReplayProxySystem(thread_state = thread_state, 
                                 immutable_types = immutable_types,
-                                tracer = tracer,
-                                reader = reader)
-    
-    # factory = replaying_proxy_factory(thread_state = thread_state, 
-    #                                   is_immutable_type = is_immutable_type,
-    #                                   tracer = tracer,
-    #                                   bind = reader.supply,
-    #                                   next = next_result, 
-    #                                   checkpoint = checkpoint)
-    
-    factory.tracer = tracer
-
-    def read_sync(): read_required('SYNC')
-
-    factory.sync = lambda function: functional.observer(on_call = functional.always(read_sync), function = function)
-
-    # factory.set_thread_number = writer.thread_number
-
-    factory.log = lambda message: checkpoint({'type': 'log_message', 'message': message})
-
-    return factory
+                                tracing_config = tracing_config,
+                                path = recording_path / 'trace.bin')

retracesoftware/install/tracer.py

@@ -24,28 +24,30 @@ class Tracer:
 
             cls = functional.typeof(obj)
 
+            if issubclass(cls, Proxy):
+                return str(cls)
+            
             if issubclass(cls, (int, str)):
                 return obj
 
-            else:
-                return 'FOO!!!!'
+            return str(cls)
             
-            if issubclass(cls, Proxy):
-                return f'<Proxy>'
+            # if issubclass(cls, Proxy):
+            #     return f'<Proxy>'
 
-            if issubclass(cls, types.TracebackType):
-                return '<traceback>'
+            # if issubclass(cls, types.TracebackType):
+            #     return '<traceback>'
             
-            elif issubclass(cls, utils.wrapped_function):
-                return utils.unwrap(obj).__name__
+            # elif issubclass(cls, utils.wrapped_function):
+            #     return utils.unwrap(obj).__name__
             
-            elif hasattr(obj, '__module__') and hasattr(obj, '__name__'):
-                return f'{obj.__module__}.{obj.__name__}'
-            # elif isinstance(obj, type):
+            # elif hasattr(obj, '__module__') and hasattr(obj, '__name__'):
             #     return f'{obj.__module__}.{obj.__name__}'
-            else:
-                return '<other>'
-                # return f'instance type: {str(self.serialize(type(obj)))}'
+            # # elif isinstance(obj, type):
+            # #     return f'{obj.__module__}.{obj.__name__}'
+            # else:
+            #     return '<other>'
+            #     # return f'instance type: {str(self.serialize(type(obj)))}'
         except:
             print("ERROR in tracer serialize!!!!")
             os._exit(1)
@@ -120,7 +122,7 @@ class Tracer:
         writer = functional.partial(self.writer, name)
             
         if name in self.config:
-            return functional.compose(func, functional.side_effect(writer))
+            return functional.sequence(func, functional.side_effect(writer))
         else:
             return func
 
@@ -139,6 +141,6 @@ class Tracer:
 
     def event_after(self, name, func):
         if name in self.config:
-            return functional.compose(func, functional.side_effect(self.event(name)))
+            return functional.sequence(func, functional.side_effect(self.event(name)))
         else:
             return func

retracesoftware/proxy/__init__.py

@@ -1,3 +1,3 @@
 from retracesoftware.proxy.record import RecordProxySystem
 from retracesoftware.proxy.replay import ReplayProxySystem
-
+from retracesoftware.proxy.thread import set_thread_id, per_thread_messages

retracesoftware/proxy/gateway.py

@@ -1,100 +1,49 @@
 import retracesoftware.functional as functional
 import retracesoftware_utils as utils
 
+from retracesoftware.proxy.proxytype import ExtendingProxy
+
 # from retracesoftware.proxy.proxytype import ExtendingProxy
 
-unproxy_execute = functional.mapargs(starting = 1, 
-                                     transform = functional.walker(utils.try_unwrap), 
-                                     function = functional.apply)
+# unproxy_execute = functional.mapargs(starting = 1, 
+#                                      transform = functional.walker(utils.try_unwrap), 
+#                                      function = functional.apply)
 
-def adapter(proxy_input,
+def adapter(function,
+            proxy_input,
             proxy_output,
-            function,
             on_call = None,
             on_result = None,
             on_error = None):
 
     # function = functional.apply
 
-    if on_call: function = functional.observer(on_call = on_call, function = function)
+    if on_call: function = utils.observer(on_call = on_call, function = function)
+
+    #functional.observer(on_call = on_call, function = function)
 
     function = functional.mapargs(starting = 1, transform = proxy_input, function = function)
 
-    function = functional.compose(function, proxy_output)
+    function = functional.sequence(function, proxy_output)
 
     if on_result or on_error:
-        function = functional.observer(on_result = on_result, on_error = on_error, function = function)
+        function = utils.observer(on_result = on_result, on_error = on_error, function = function)
 
     return function
 
-def adapter_pair(proxy_int, 
-                 proxy_ext,
-                 int_apply,
-                 ext_apply,
-                 tracer, 
-                 on_int_call,
-                 on_ext_result,
-                 on_ext_error):
+def adapter_pair(int, ext):
     return (
         adapter(
-            function = ext_apply,
-            proxy_input = proxy_int,
-            proxy_output = proxy_ext,
-            on_call = tracer('proxy.ext.call'),
-            on_result = on_ext_result,
-            on_error = on_ext_error),
-            # on_result = tracer('proxy.ext.result', on_ext_result),
-            # on_error = tracer('proxy.ext.error', on_ext_error)),
+            function = ext.apply,
+            proxy_input = int.proxy,
+            proxy_output = ext.proxy,
+            on_call = ext.on_call,
+            on_result = ext.on_result,
+            on_error = ext.on_error),
         adapter(
-            function = int_apply,
-            proxy_input = proxy_ext,
-            proxy_output = proxy_int,
-            on_call = tracer('proxy.int.call', on_int_call),
-            on_result = tracer('proxy.int.result'),
-            on_error = tracer('proxy.int.error')))
-    
-def proxy(proxytype):
-    return functional.selfapply(functional.compose(functional.typeof, proxytype))
-
-def maybe_proxy(proxytype):
-    return functional.if_then_else(
-            functional.isinstanceof(utils.Wrapped),
-            utils.unwrap,
-            proxy(functional.memoize_one_arg(proxytype)))
-
-def gateway_pair(thread_state,
-                 tracer,
-                 immutable_types,
-                 int_proxytype,
-                 ext_proxytype,
-                 int_apply = functional.apply,
-                 ext_apply = functional.apply,
-                 on_int_call = None,
-                 on_ext_result = None,
-                 on_ext_error = None):
-
-    def is_immutable_type(cls):
-        return issubclass(cls, tuple(immutable_types))
-
-    is_immutable = functional.sequence(functional.typeof, functional.memoize_one_arg(is_immutable_type))
-
-    def create_proxier(proxytype):
-        return functional.walker(functional.when_not(is_immutable, maybe_proxy(proxytype)))
-    
-    int_to_ext_dispatch = thread_state.dispatch(tracer('proxy.int.disabled.event', unproxy_execute))
-    ext_to_int_dispatch = thread_state.dispatch(tracer('proxy.ext.disabled.event', unproxy_execute))
-
-    int_to_ext, ext_to_int = adapter_pair(
-        proxy_int = create_proxier(int_proxytype(ext_to_int_dispatch)),
-        proxy_ext = create_proxier(ext_proxytype(int_to_ext_dispatch)),
-        int_apply = thread_state.wrap(desired_state = 'internal', function = int_apply),
-        ext_apply = thread_state.wrap(desired_state = 'external', function = ext_apply),
-        tracer = tracer,
-        on_int_call = on_int_call,
-        on_ext_result = on_ext_result,
-        on_ext_error = on_ext_error)
-
-    thread_state.set_dispatch(int_to_ext_dispatch, external = functional.apply, internal = tracer('proxy.int_to_ext.stack', int_to_ext))
-    thread_state.set_dispatch(ext_to_int_dispatch, internal = functional.apply, external = tracer('proxy.ext_to_int.wrap', ext_to_int))
-    
-    return (int_to_ext_dispatch, ext_to_int_dispatch)
+            function = int.apply,
+            proxy_input = ext.proxy,
+            proxy_output = int.proxy,
+            on_call = int.on_call,
+            on_result = int.on_result,
+            on_error = int.on_error))