retracesoftware-proxy 0.1.0__py3-none-any.whl

retracesoftware/proxy/proxytype.py

@@ -0,0 +1,280 @@
+import retracesoftware_utils as utils
+import retracesoftware.functional as functional
+
+import types
+
+class Proxy:
+    __slots__ = []
+
+class Stub(Proxy):
+    __slots__ = []
+
+class DynamicProxy(Proxy):
+    __slots__ = []
+
+class ExtendingProxy(Proxy):
+    __slots__ = []
+
+class InternalProxy:
+    __slots__ = []
+
+def superdict(cls):
+    result = {}
+    for cls in list(reversed(cls.__mro__))[1:]:
+        result.update(cls.__dict__)
+    
+    return result
+
+def is_method_descriptor(obj):
+    return isinstance(obj, types.FunctionType) or \
+           (isinstance(obj, (types.WrapperDescriptorType, types.MethodDescriptorType)) and obj.__objclass__ != object)
+
+def proxy_method_descriptors(cls, handler):
+    for name, target in cls.__dict__.items():
+        if is_method_descriptor(target):
+            proxied = utils.wrapped_function(handler = handler, target = target)
+            setattr(cls, name, proxied)
+
+def methods(cls):
+    for name,value in superdict(cls).items():
+        if is_descriptor(value) and is_method_descriptor(value):
+            yield name
+
+def is_descriptor(obj):
+    return hasattr(obj, '__get__') or hasattr(obj, '__set__') or hasattr(obj, '__delete__')
+
+class Named:
+    def __init__(self, name):
+        self.__name__ = name
+
+class DescriptorStub:
+
+    __slots__ = ['handler', 'name']
+
+    def __init__(self, handler, name):
+        self.handler = handler
+        self.name = name
+
+    def __get__(self, instance, owner):
+        return self.handler(Named('getattr'), self.name)
+
+    def __set__(self, instance, value):
+        return self.handler(Named('setattr'), self.name, value)
+
+    def __delete__(self, instance):
+        return self.handler(Named('delattr'), self.name)
+    
+def stubtype_from_spec(handler, module, name, methods, members):
+
+    spec = {
+        '__module__': module,        
+    }
+
+    for method in methods:
+        spec[method] = utils.wrapped_function(
+            handler = handler, target = Named(method))
+
+    for member in members:
+        spec[member] = DescriptorStub(handler = handler, name = member)
+
+    return type(name, (Stub, DynamicProxy,), spec)
+
+    # stubtype.__new__ = thread_state.dispatch(disabled__new__, internal = stub.__new__, external = stub.__new__)
+    # stub.__retrace_unproxied__ = cls
+
+def dynamic_stubtype(handler, cls):
+
+    assert not issubclass(cls, BaseException)
+
+    blacklist = ['__getattribute__', '__hash__', '__del__', '__init__', '__call__']
+
+    to_proxy = [m for m in methods(cls) if m not in blacklist]
+
+    def wrap(name): return utils.wrapped_function(handler = handler, 
+                                                  target = Named(name))
+    
+    spec = { name: wrap(name) for name in to_proxy }
+
+    spec['__getattr__'] = wrap('__getattr__')
+    spec['__setattr__'] = wrap('__setattr__')
+    
+    if utils.yields_callable_instances(cls):
+        spec['__call__'] = handler
+
+    spec['__retrace_target_class__'] = cls
+    spec['__class__'] = property(functional.repeatedly(cls))
+
+    name = f'retrace.proxied.{cls.__module__}.{cls.__name__}'
+
+    return type(name, (Stub, DynamicProxy), spec)
+
+def dynamic_proxytype(handler, cls):
+
+    assert not issubclass(cls, BaseException)
+
+    blacklist = ['__getattribute__', '__hash__', '__del__', '__init__', '__call__']
+
+    to_proxy = [m for m in methods(cls) if m not in blacklist]
+
+    def wrap(target): return utils.wrapped_function(handler = handler, target = target)
+    
+    spec = { name: wrap(getattr(cls, name)) for name in to_proxy }
+
+    spec['__getattr__'] = wrap(getattr)
+    spec['__setattr__'] = wrap(setattr)
+    
+    if utils.yields_callable_instances(cls):
+        spec['__call__'] = handler
+
+    spec['__retrace_target_class__'] = cls
+
+    target_type = functional.compose(utils.unwrap, functional.typeof)
+    spec['__class__'] = property(target_type)
+
+    name = f'retrace.proxied.{cls.__module__}.{cls.__name__}'
+
+    return type(name, (utils.Wrapped, DynamicProxy), spec)
+
+def dynamic_int_proxytype(handler, cls, bind):
+    proxytype = dynamic_proxytype(handler = handler, cls = cls)
+    proxytype.__new__ = functional.sequence(proxytype.__new__, functional.side_effect(bind))
+    return proxytype
+                                    
+class DescriptorProxy:
+
+    __slots__ = ['handler', 'proxytype', 'name']
+
+    def __init__(self, proxytype, handler, name):
+        self.proxytype = proxytype
+        self.handler = handler
+        self.name = name
+
+    def __get__(self, instance, owner):
+        inst = owner if instance is None else instance
+        getter = functional.partial(getattr, super(self.proxytype, inst))
+        return self.handler(getter, self.name)
+
+    def __set__(self, instance, value):
+        setter = functional.partial(setattr, super(self.proxytype, instance))
+        return self.handler(setter, self.name, value)
+
+    def __delete__(self, instance):
+        deleter = functional.partial(delattr, super(self.proxytype, instance))
+        return self.handler(deleter, self.name)
+
+
+blacklist = ['__getattribute__', '__hash__', '__del__']
+
+# if the type can be patched, thats better, all new instances must be of correct type
+
+def extending_proxytype(cls, thread_state, ext_handler, int_handler, on_subclass_new, is_stub = False):
+
+    assert not issubclass(cls, BaseException)
+
+    def init_subclass(subclass, **kwargs):
+        print(f'In init_subclass: {subclass} {kwargs}')
+        # subclass.__retrace_unproxied__ = create_unproxied_type(subclass)
+
+        proxy_method_descriptors(cls = subclass, handler = int_handler)
+
+        if not issubclass(subclass, InternalProxy):
+            subclass.__new__ = functional.compose(subclass.__new__, functional.side_effect(on_subclass_new))
+            subclass.__bases__ = subclass.__bases__ + (InternalProxy,)
+
+    slots = { "__slots__": (), "__init_subclass__": init_subclass }
+
+    def wrap(target): return utils.wrapped_function(handler = ext_handler, target = target)
+
+    descriptors = []
+
+    for name,value in superdict(cls).items():
+        if name not in blacklist:
+            if is_method_descriptor(value):
+                slots[name] = wrap(getattr(cls, name))
+            elif is_descriptor(value):
+                descriptors.append(name)
+
+    name = f'retrace.extended.{cls.__module__}.{cls.__name__}'
+
+    extended = type(name, (cls, ExtendingProxy), slots)
+
+    for name in descriptors:
+        proxy = DescriptorProxy(handler = ext_handler, name = name, proxytype = extended)
+        setattr(extended, name, proxy)
+
+    # def disabled__new__(subcls, *args, **kwargs):
+    #     print('IN Diabled new!!!')
+        
+    #     instance = cls.__new__(subcls.__retrace_unproxied__, *args, **kwargs)
+    #     instance.__init__(*args, **kwargs)
+    #     return instance
+
+    # __new__ = functional.compose(cls.__new__, functional.side_effect(on_new))
+    if is_stub:
+        def __new__(cls, *args, **kwargs):
+            instance = utils.create_stub_object(cls)
+            # print(instance is None)
+            # utils.sigtrap(None)
+            return instance
+        
+        extended.__new__ = thread_state.dispatch(cls.__new__, internal = __new__, external = __new__)
+    
+    # extended.__retrace_unproxied__ = cls
+
+    return extended
+
+
+def stubtype(cls, result, thread_state, handler):
+    
+    name = f'retrace.stub.{cls.__module__}.{cls.__name__}'
+
+    slots = {}
+
+    def wrap(name):
+        return utils.wrapped_function(
+            handler = handler, 
+            target = StubMethodDescriptor(name = name, result = result))
+
+    for name,value in superdict(cls).items():
+        if name not in blacklist:
+            if is_method_descriptor(value):
+                slots[name] = wrap(name)
+            elif is_descriptor(value):
+                slots[name] = DescriptorStub(handler = handler, name = name)
+
+    def disabled__new__(subcls, *args, **kwargs):
+        instance = cls.__new__(subcls.__retrace_unproxied__, *args, **kwargs)
+        instance.__init__(*args, **kwargs)
+        return instance
+
+    stub = type(name, (Stub,), slots)
+
+    stub.__new__ = thread_state.dispatch(disabled__new__, internal = stub.__new__, external = stub.__new__)
+
+    stub.__retrace_unproxied__ = cls
+
+    return stub
+
+def create_unproxied_type(cls):
+    name = f'{cls.__module__}.{cls.__name__}'
+
+    def unproxy_type(cls):
+        return cls.__retrace_unproxied__ if issubclass(cls, ExtendingProxy) else cls
+
+    return type(name, tuple(map(unproxy_type, cls.__bases__)), dict(cls.__dict__))
+
+def make_extensible(cls, handler, on_new):
+
+    cls.__retrace_unproxied__ = cls.__base__
+
+    def init_subclass(*args, **kwargs):
+        print(f'In init_subclass: {args} {kwargs}')
+        # subclass.__retrace_unproxied__ = create_unproxied_type(subclass)
+
+        # proxy_method_descriptors(cls = subclass, handler = handler)
+
+        # if not issubclass(subclass, InternalProxy):
+        #     cls.__new__ = functional.compose(cls.__new__, functional.side_effect(on_new))
+        #     cls.__bases__ = cls.__bases__ + (InternalProxy,)
+
+    cls.__init_subclass__ = init_subclass

retracesoftware/proxy/record.py

@@ -0,0 +1,133 @@
+import retracesoftware.functional as functional
+import retracesoftware_utils as utils
+
+from retracesoftware.proxy.proxytype import dynamic_proxytype, superdict, is_descriptor, extending_proxytype, dynamic_int_proxytype, make_extensible
+from retracesoftware.proxy.gateway import gateway_pair
+from retracesoftware.proxy.proxysystem import ProxySystem
+
+import sys
+
+class ExtendedProxy:
+    __slots__ = []
+
+class ProxyRef:
+    def __init__(self, module, name):
+        self.module = module
+        self.name = name
+
+    def resolve(self):
+        return getattr(sys.modules[self.module], self.name)
+
+class ProxySpec(ProxyRef):
+    def __init__(self, module, name, methods, members):
+        super().__init__(module, name)
+        self.methods = methods
+        self.members = members
+
+    def __str__(self):
+        return f'ProxySpec(module = {self.module}, name = {self.name}, methods = {self.methods}, members = {self.members})'
+    
+def keys_where_value(pred, dict):
+    for key,value in dict.items():
+        if pred(value): yield key
+
+def resolveable(obj):
+    try:
+        return getattr(sys.modules[obj.__module__], obj.__name__) is obj
+    except:
+        return False
+    
+class ExtProxytype:
+
+    def __init__(self, gateway, extended_types, writer):
+        self.gateway = gateway
+        self.writer = writer
+        self.extended_types = extended_types
+
+    def __call__(self, cls):
+        assert isinstance(cls, type)
+
+        if cls in self.extended_types:
+            return functional.side_effect(lambda obj: utils.set_type(obj, self.extended_types[cls]))
+        else:
+            if resolveable(cls):
+                ref = self.writer.handle(ProxyRef(name = cls.__name__, module = cls.__module__))
+            else:
+                blacklist = ['__getattribute__']
+                descriptors = {k: v for k,v in superdict(cls).items() if k not in blacklist and is_descriptor(v) }
+
+                methods = [k for k, v in descriptors.items() if utils.is_method_descriptor(v)]
+                members = [k for k, v in descriptors.items() if not utils.is_method_descriptor(v)]
+
+                ref = self.writer.handle(ProxySpec(name = cls.__name__, 
+                                                module = cls.__module__,
+                                                methods = methods,
+                                                members = members))
+            
+            proxytype = dynamic_proxytype(handler = self.gateway, cls = cls)
+
+            self.writer.type_serializer[proxytype] = functional.constantly(ref)
+            return proxytype
+        
+
+# when 
+class RecordProxySystem(ProxySystem):
+    
+    def __init__(self, thread_state, immutable_types, tracer, writer):
+        super().__init__(thread_state = thread_state)
+
+        self.immutable_types = immutable_types
+
+        self.extended_types = {}
+        self.writer = writer
+        self.bind = writer.placeholder
+
+        # on_ext_result = writer.handle('RESULT')
+        on_ext_result = functional.if_then_else(
+            functional.isinstanceof(str), writer.handle('RESULT'), writer)
+
+        def int_proxytype(gateway):
+            return lambda cls: dynamic_int_proxytype(handler = gateway, cls = cls, bind = self.bind)
+        
+        def ext_proxytype(gateway):
+            return ExtProxytype(gateway = gateway, writer = writer, extended_types = self.extended_types)
+    
+        error = writer.handle('ERROR')
+
+        def write_error(cls, val, traceback):
+            error(cls, val)
+
+        self.ext_handler, self.int_handler = gateway_pair(
+            thread_state,
+            tracer,
+            immutable_types = immutable_types,
+            int_proxytype = int_proxytype,
+            ext_proxytype = ext_proxytype,
+            on_int_call = writer.handle('CALL'),
+            on_ext_result = functional.side_effect(on_ext_result),
+            on_ext_error = write_error)
+
+    def extend_type(self, base):
+
+        if base in self.extended_types:
+            return self.extended_types[base]
+
+        # self.tracer.log('proxy.ext.new.extended', f'{base.__module__}.{base.__name__}')
+
+        extended = extending_proxytype(
+            cls = base,
+            thread_state = self.thread_state, 
+            ext_handler = self.ext_handler,
+            int_handler = self.int_handler,
+            on_subclass_new = self.bind,
+            is_stub = False)
+        
+        ref = self.writer.handle(ProxyRef(name = base.__name__, module = base.__module__,))
+        self.writer.type_serializer[extended] = functional.constantly(ref)
+        
+        # make_extensible(cls = extended, handler = self.int_handler, on_new = self.writer.placeholder)
+
+        self.immutable_types.add(extended)
+        self.extended_types[base] = extended 
+
+        return extended

retracesoftware/proxy/replay.py

@@ -0,0 +1,110 @@
+import retracesoftware.functional as functional
+import retracesoftware_utils as utils
+
+from retracesoftware.proxy.proxytype import dynamic_proxytype, dynamic_int_proxytype, extending_proxytype, make_extensible, dynamic_stubtype, stubtype_from_spec, Stub
+from retracesoftware.proxy.gateway import gateway_pair
+
+from retracesoftware.proxy.record import ProxyRef, ProxySpec
+from retracesoftware.proxy.proxysystem import ProxySystem
+
+import os
+
+# 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
+# do it from C and immutable types can be patched too
+# patch the tp_new pointer?
+
+class ReplayProxySystem(ProxySystem):
+    
+    def stubtype(self, cls):
+        return dynamic_proxytype(handler = self.ext_handler, cls = cls)
+
+    def stubtype_from_spec(self, spec):
+        print (f'FOOO!!! {spec}')
+        return stubtype_from_spec(
+            handler = self.ext_handler,
+            module = spec.module, 
+            name = spec.name,
+            methods = spec.methods,
+            members = spec.members)
+
+    @utils.striptraceback
+    def next_result(self):
+        while True:
+            next = self.reader()
+
+            if next == 'CALL':
+                func = self.reader()
+                args = self.reader()
+                kwargs = self.reader()
+
+                try:
+                    func(*args, **kwargs)
+                except:
+                    pass
+
+            elif next == 'RESULT':
+                return self.reader()
+            elif next == 'ERROR':
+                err_type = self.reader()
+                err_value = self.reader()
+                utils.raise_exception(err_type, err_value)
+            else:
+                assert not isinstance(next, str)
+                return next
+
+    def __init__(self, thread_state, immutable_types, tracer, reader):
+        # self.writer = writer
+        super().__init__(thread_state = thread_state)
+        self.immutable_types = immutable_types
+        self.reader = reader
+        self.bind = self.reader.supply
+
+        add_stubtype = functional.side_effect(immutable_types.add)
+
+        reader.type_deserializer[ProxyRef] = functional.sequence(lambda ref: ref.resolve(), self.stubtype, add_stubtype)
+        reader.type_deserializer[ProxySpec] = functional.sequence(self.stubtype_from_spec, add_stubtype)
+
+        # on_ext_result = functional.if_then_else(
+        #     functional.is_instanceof(str), writer.handle('RESULT'), writer)
+
+        def int_proxytype(gateway):
+            return lambda cls: dynamic_int_proxytype(handler = gateway, cls = cls, bind = self.bind)
+
+        def is_stub_type(obj):
+            return functional.typeof(obj) is type and issubclass(obj, Stub)
+
+        create_stubs = functional.walker(functional.when(is_stub_type, lambda cls: cls()))
+
+        ext_apply = functional.repeatedly(functional.sequence(self.next_result, create_stubs))
+                
+        self.ext_handler, self.int_handler = gateway_pair(
+            thread_state,
+            tracer,
+            immutable_types = immutable_types,
+            ext_apply = ext_apply,
+            int_proxytype = int_proxytype,
+            ext_proxytype = functional.identity)
+
+    def extend_type(self, base):
+        
+        # ok, how to provide __getattr__ style access, 
+
+        extended = extending_proxytype(
+            cls = base,
+            thread_state = self.thread_state, 
+            int_handler = self.int_handler,
+            ext_handler = self.ext_handler,
+            on_subclass_new = self.bind,
+            is_stub = True)
+
+        self.immutable_types.add(extended)
+        # proxytype = extending_proxytype(base)
+
+        # make_extensible(cls = extended, 
+        #                 int_handler = self.int_handler, 
+        #                 ext_handler = self.ext_handler,
+        #                 on_new = self.reader.supply)
+
+        return extended

retracesoftware/proxy/thread.py

@@ -0,0 +1,11 @@
+import retracesoftware.functional as functional
+import retracesoftware_utils as utils
+
+class ThreadSwitch:
+    def __init__(self, thread_id):
+        self.thread_id = thread_id
+
+
+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)

retracesoftware_proxy-0.1.0.dist-info/METADATA

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: retracesoftware_proxy
+Version: 0.1.0
+Summary: Proxy layer for retracesoftware runtime
+License: Apache-2.0
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: retracesoftware_utils
+Requires-Dist: retracesoftware_functional
+Requires-Dist: retracesoftware_stream
+
+# proxy

retracesoftware_proxy-0.1.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+retracesoftware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+retracesoftware/config.json,sha256=aedf9CXxOBkcQk3BJVrh0GuBkIAjBGBRlrTXdoRJ-MY,8108
+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=VNtivSf6A9wtLzIkZKJQ7thPkYTdjtTmxaIkPUOwLhg,5942
+retracesoftware/install/patcher.py,sha256=5DGzVaNM53Z_KWz-wWQxlr1WqeWuuxKoVZyN5tNGuTw,15866
+retracesoftware/install/predicate.py,sha256=tX7NQc0rGkyyHYO3mduYHcJHbw1wczT53m_Dpkzo6do,2679
+retracesoftware/install/record.py,sha256=mJyz8ZFnrveDCvrUHksTXaFZbBX10yqH6UBV1QH5EwA,4370
+retracesoftware/install/references.py,sha256=0nUY_9BkeFz2imcw97rcJNq2jqISCB8dysBbCrh1eCo,1623
+retracesoftware/install/replay.py,sha256=ox43e8k_uvn9w6vf6rt8f3KwaXcBVx2GbvWaLZpwqR4,4952
+retracesoftware/install/tracer.py,sha256=dFhXKkmvGLF-_WzQvZXxNO1Ftj6crH1SM6pGBU4cqMY,4586
+retracesoftware/install/typeutils.py,sha256=_a1PuwdCsYjG1Nkd77V-flqYtwbD4RkJVKn6Z-xABL4,1813
+retracesoftware/proxy/__init__.py,sha256=NaGsqoj4X3NpHfTAmRIfsXM16R6AGE99ciQeknj3sXc,119
+retracesoftware/proxy/gateway.py,sha256=JtSwwllXiUykpNdojbK7okyYadRnILGgpRCHxAQijZs,3911
+retracesoftware/proxy/proxyfactory.py,sha256=2PgC0NtDbRmhmU--caTiQDsaF8s1h9tavQxvPIow_bM,11912
+retracesoftware/proxy/proxysystem.py,sha256=kDdtea-vCcsqdwSwmgGBBvVrIRl6Gwb89Wgx6VSIwgQ,759
+retracesoftware/proxy/proxytype.py,sha256=P78aL3_aemG8p3NKmP4YfAcwC8IDr7LIq5-dkV4n0Ec,9038
+retracesoftware/proxy/record.py,sha256=yI8CH0oOyrAyvjy9JsawgkQh9jYTlg9sQ_CcejrFKO4,4772
+retracesoftware/proxy/replay.py,sha256=usbb2OTX6uJG_zialqHk9en0mxD2xEhjPajMZDjZnkQ,3940
+retracesoftware/proxy/thread.py,sha256=9_6gWiRbir77f9kelpvXaTWviRfZo0ACkKPdGNbrq2Q,394
+retracesoftware_proxy-0.1.0.dist-info/METADATA,sha256=c24hdDKP-miIrX6mM1yVyXCQeu0ozLP4N0ebtqiGccw,324
+retracesoftware_proxy-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+retracesoftware_proxy-0.1.0.dist-info/top_level.txt,sha256=hYHsR6txLidmqvjBMITpIHvmJJbmoCAgr76-IpZPRz8,16
+retracesoftware_proxy-0.1.0.dist-info/RECORD,,

retracesoftware_proxy-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

retracesoftware_proxy-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+retracesoftware