retracesoftware-proxy 0.1.22__py3-none-any.whl → 0.2.1__py3-none-any.whl

retracesoftware/install/replay.py

@@ -5,21 +5,29 @@ from retracesoftware.install import globals
 import os, json, re, glob
 from pathlib import Path
 from datetime import datetime
+from retracesoftware.install.config import env_truthy
 
-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.
-    """
+def recordings(pattern):
     # Turn strftime placeholders into '*' for globbing
     # (very simple replacement: %... -> *)
     glob_pattern = re.sub(r"%[a-zA-Z]", "*", pattern)
 
+    base_pattern = os.path.basename(pattern)
+
     # Find all matching files
-    candidates = glob.glob(glob_pattern)
-    if not candidates:
-        return None
+    for path in glob.glob(glob_pattern):
+        try:
+            name = os.path.basename(path)
+            datetime.strptime(name, base_pattern)
+            yield path
+        except:
+            pass
 
+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.
+    """
     # Derive the datetime format from the pattern (basename only)
     base_pattern = os.path.basename(pattern)
 
@@ -28,11 +36,11 @@ def latest_from_pattern(pattern: str) -> str | None:
         return datetime.strptime(name, base_pattern)
 
     # Find the latest by parsed timestamp
-    latest = max(candidates, key=parse_time)
-    return latest
+    return max(recordings(pattern), key=parse_time)
 
 def replay_system(thread_state, immutable_types, config):
 
+    verbose = env_truthy('RETRACE_VERBOSE', False)
     recording_path = Path(latest_from_pattern(config['recording_path']))
 
     # print(f"replay running against path: {recording_path}")
@@ -51,8 +59,44 @@ def replay_system(thread_state, immutable_types, config):
     with open(recording_path / "mainscript", "r", encoding="utf-8") as f:
         mainscript = f.read()
 
+    call_trace_file = recording_path / "call_trace.txt"
+
+    if call_trace_file.exists():
+        class CallTracer:
+            def __init__(self):
+                self.file = open(call_trace_file, 'r')
+
+            def __call__(self, obj):
+                recording = json.loads(self.file.readline())
+                if obj != recording:
+                    breakpoint()
+
+            def close(self):
+                self.file.close()
+
+            # def on_call(self, function_name):
+            #     recording = self.file.readline()
+            #     if f'call: {function_name}\n' != recording:
+            #         breakpoint()
+
+            #     assert f'call: {function_name}\n' == recording
+
+            # def on_return(self, function_name):
+            #     recording = self.file.readline()
+            #     if f'return: {function_name}\n' != recording:
+            #         breakpoint()
+
+            #     assert f'return: {function_name}\n' == recording
+
+        call_tracer = CallTracer()
+    else:
+        call_tracer = None
+
     return ReplayProxySystem(thread_state = thread_state, 
                                 immutable_types = immutable_types,
                                 tracing_config = tracing_config,
                                 mainscript = mainscript,
-                                path = recording_path / 'trace.bin')
+                                path = recording_path / 'trace.bin',
+                                tracecalls = env_truthy('RETRACE_ALL', False),
+                                verbose = verbose,
+                                magic_markers = env_truthy('RETRACE_MAGIC_MARKERS', False))

retracesoftware/install/tracer.py

@@ -2,9 +2,12 @@ import retracesoftware.functional as functional
 import retracesoftware_utils as utils
 from retracesoftware.proxy.proxytype import Proxy
 
+from retracesoftware.proxy.serializer import serializer
+
 import types
 import os
 import sys
+import functools
 
 def format_kwargs(kwargs):
     result = []
@@ -49,7 +52,8 @@ class Tracer:
 
     def __init__(self, config, writer):
         self.config = config
-        serialize = functional.walker(self.serialize)
+        serialize = serializer
+        # functional.walker(self.serialize)
         self.writer = functional.mapargs(transform = serialize, function = writer)
 
     def systrace(self, frame, event, arg):
@@ -74,101 +78,101 @@ class Tracer:
             print(f'systrace RAISED ERROR!')
             raise
 
-    def trace_calls(self, thread_state):
-        if 'tracecalls' in self.config:
-            # def on_call(frame):
+    # def trace_calls(self, thread_state):
+    #     if 'tracecalls' in self.config:
+    #         # def on_call(frame):
 
-            #     func = frame.function
+    #         #     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)))
+    #         #         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__}')
+    #         # 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)
+    #         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
+    # def serialize(self, obj):
+    #     try:
+    #         if obj is None: return None
 
-            cls = functional.typeof(obj)
+    #         cls = functional.typeof(obj)
 
-            if issubclass(cls, Proxy):
-                return str(cls)
+    #         if issubclass(cls, Proxy):
+    #             return str(cls)
             
-            if issubclass(cls, (int, str)):
-                return obj
+    #         if issubclass(cls, (int, str)):
+    #             return obj
 
-            return str(cls)
+    #         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):
-            # #     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)
+    #         # elif hasattr(obj, '__module__') and hasattr(obj, '__name__'):
+    #         #     return f'{obj.__module__}.{obj.__name__}'
+    #         # # 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)
 
     def log(self, name, message):
         if name in self.config:
@@ -180,17 +184,23 @@ class Tracer:
     # def stacktrace(self):
     #     self.writer('stacktrace', utils.stacktrace())
 
+    def _write_call(self, name, *args, **kwargs):
+        # self.stacktrace()
+        if len(args) > 0:
+            funcname = args[0].__name__
+            # if funcname == '__del__':
+            #     utils.sigtrap('FOO')
+
+            self.writer(name, funcname, args[1:], kwargs)
+        else:
+            utils.sigtrap('FOO')
+            breakpoint()
+
     def __call__(self, name, func = None):
         if name in self.config:
             if name.endswith('.call'):
-                def write_call(*args, **kwargs):
-                    # self.stacktrace()
-                    if len(args) > 0:
-                        self.writer(name, args[0].__name__, args[1:], kwargs)
-                    else:
-                        breakpoint()
-            
-                return functional.firstof(write_call, func) if func else write_call
+                f = functools.partial(self._write_call, name)
+                return functional.firstof(f, func) if func else f
             
             elif name.endswith('.result'):
                 def write_result(obj):