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

retracesoftware/install/patcher.py

@@ -340,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
 
@@ -454,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
@@ -471,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']

retracesoftware/install/record.py

@@ -42,6 +42,13 @@ def tracing_level(config):
 #     level = os.environ.get('RETRACE_DEBUG', config['default_tracing_level'])
 #     return config['tracing_levels'].get(level, {})
 
+def merge_config(base, override):
+    if isinstance(base, dict) and isinstance(override, dict):
+        ...
+    else:
+        return override
+
+
 def record_system(thread_state, immutable_types, config):
 
     recording_path = create_recording_path(config['recording_path'])

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)

retracesoftware/proxy/gateway.py

@@ -9,9 +9,9 @@ from retracesoftware.proxy.proxytype import ExtendingProxy
 #                                      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):
@@ -31,17 +31,7 @@ def adapter(proxy_input,
 
     return function
 
-# def callbacks():
-#     return {
-#         'proxy': None
-#         'proxytype': None,
-#         'on_call': None,
-#         'on_result': None,
-#         'on_error': None,
-#         'apply': functional.apply,
-#     }
-
-def adapter_pair1(int, ext):
+def adapter_pair(int, ext):
     return (
         adapter(
             function = ext.apply,
@@ -57,102 +47,3 @@ def adapter_pair1(int, ext):
             on_call = int.on_call,
             on_result = int.on_result,
             on_error = int.on_error))
-
-# def adapter_pair(proxy_int, 
-#                  proxy_ext,
-#                  int_apply,
-#                  ext_apply,
-#                  tracer, 
-#                  on_int_call,
-#                  on_ext_result,
-#                  on_ext_error):
-#     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)),
-#         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):
-#     def set_type(cls, obj):
-#         obj.__class__ = cls
-#         return obj
-
-#     def can_set_type(cls, obj): return issubclass(cls, ExtendingProxy)
-
-#     create = functional.if_then_else(can_set_type, set_type, utils.create_wrapped)
-    
-#     return functional.spread(
-#         create,
-#         functional.sequence(functional.typeof, proxytype),
-#         None)
-
-    #     functional.sequence(functional.typeof, proxytype)
-    #     lambda obj: functional.partial(utils.create_wrapped(proxytype(type(obj)))
-    # return lambda obj: utils.create_wrapped(proxytype(type(obj)), obj)
-    # return functional.selfapply(functional.sequence(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,
-#                  wrap_int_to_ext = functional.identity,
-#                  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 proxyfactory(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 = proxyfactory(int_proxytype),
-#         proxy_ext = proxyfactory(ext_proxytype),
-#         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 = wrap_int_to_ext(tracer('proxy.int_to_ext.stack', int_to_ext)))
-#     # thread_state.set_dispatch(int_to_ext_dispatch, external = functional.apply, internal = wrap_int_to_ext(int_to_ext))
-#     # thread_state.set_dispatch(ext_to_int_dispatch, internal = functional.apply, external = tracer('proxy.ext_to_int.wrap', ext_to_int))
-    
-#     def gateway(name, internal = functional.apply, external = functional.apply):
-#         default = tracer(name, unproxy_execute)
-#         return thread_state.dispatch(default, internal = internal, external = external)
-    
-#     return (gateway('proxy.int.disabled.event',
-#                     internal = wrap_int_to_ext(int_to_ext)),
-#             gateway('proxy.ext.disabled.event',
-#                     external = tracer('proxy.ext_to_int.wrap', ext_to_int)))
-