Merge pull request #12 from eriknw/use_trace

Use trace

Author: eriknw

.travis.yml

@@ -8,15 +8,20 @@ python:
     - 3.7
     - 3.8
     - "3.9-dev"
+    - "pypy3.6-7.1.1"
 
 install:
-    - pip install toolz coverage pytest flake8 black
+    - pip install --upgrade pip
+    - pip install toolz coverage pytest
     - pip install -e .
 
 script:
-    - coverage run --branch -m pytest --doctest-modules
-    - flake8
-    - black innerscope --check --diff
+    - coverage run --branch -m pytest --doctest-modules --method bytecode
+    - coverage run -a --branch -m pytest --doctest-modules --method trace
+    - pytest --doctest-modules --method trace
+    - if [[ $TRAVIS_PYTHON_VERSION != pypy* ]] ; then pip install flake8 black ; fi
+    - if [[ $TRAVIS_PYTHON_VERSION != pypy* ]] ; then flake8 ; fi
+    - if [[ $TRAVIS_PYTHON_VERSION != pypy* ]] ; then black innerscope --check --diff ; fi
 
 after_success:
     - coverage report --show-missing

README.md

@@ -1,6 +1,6 @@
 # Innerscope
 
-[![Python Version](https://img.shields.io/badge/python-3.6%20%7C%203.7%20%7C%203.8%20%7C%203.9-blue)](https://img.shields.io/badge/python-3.6%20%7C%203.7%20%7C%203.8%20%7C%203.9-blue)
+[![Python Version](https://img.shields.io/badge/python-3.6%20%7C%203.7%20%7C%203.8%20%7C%203.9%20%7C%20PyPy-blue)](https://img.shields.io/badge/python-3.6%20%7C%203.7%20%7C%203.8%20%7C%203.9%20%7C%20PyPy-blue)
 [![Version](https://img.shields.io/pypi/v/innerscope.svg)](https://pypi.org/project/innerscope/)
 [![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://github.com/eriknw/innerscope/blob/master/LICENSE)
 [![Build Status](https://travis-ci.org/eriknw/innerscope.svg?branch=master)](https://travis-ci.org/eriknw/innerscope)

conftest.py

@@ -0,0 +1,7 @@
+def pytest_addoption(parser):
+    parser.addoption(
+        "--method",
+        action="store",
+        default="bytecode",
+        help="Select the default method for obtaining the inner scope: bytecode or trace",
+    )

innerscope/cfg.py

@@ -0,0 +1 @@
+default_method = "bytecode"

innerscope/core.py

@@ -2,9 +2,11 @@
 import dis
 import functools
 import inspect
+import sys
 from collections.abc import Mapping
 from types import CodeType, FunctionType
 from tlz import concatv, merge
+from . import cfg
 
 try:
     # Added in Python 3.8
@@ -350,9 +352,24 @@ class ScopedFunction:
     2
     """
 
-    def __init__(self, func, *mappings, use_closures=True, use_globals=True):
+    def __init__(self, func, *mappings, use_closures=True, use_globals=True, method="default"):
         self.use_closures = use_closures
         self.use_globals = use_globals
+        if method == "default":
+            method = cfg.default_method
+            if method == "default":
+                raise ValueError(
+                    'Who would set the default method to "default"?  That\'s just silly!\n'
+                    'Please set ``innerscope.cfg.default_method`` back to "bytecode", '
+                    "and then please continue doing what you're doing, because it's probably "
+                    "something awesome :)"
+                )
+        if method not in {"bytecode", "trace"}:
+            raise ValueError(
+                'method= argument to ScopedFunc must be "bytecode", "trace", or "default".  '
+                f"Got {method!r}.  Using the default method is recommended."
+            )
+        self.method = method
         if isinstance(func, ScopedFunction):
             self.func = func.func
             code = func.func.__code__
@@ -457,12 +474,42 @@ def __call__(self, *args, **kwargs):
         outer_scope["__builtins__"] = builtins
         outer_scope["_innerscope_locals_"] = locals
         outer_scope["_innerscope_secret_"] = secret = object()
+        is_trace = self.method == "trace"
+        if is_trace:
+            code = self.func.__code__
+            prev_trace = sys.gettrace()
+            info = {}
+
+            # coverage uses sys.settrace, so I don't know how to cover this function
+            def trace_func(frame, event, arg):  # pragma: no cover
+                if prev_trace is not None:
+                    prev = prev_trace(frame, event, arg)
+                    sys.settrace(trace_func)
+                else:
+                    prev = None
+                if event != "call" or frame.f_code is not func.__code__:
+                    return prev
+
+                def trace_returns(frame, event, arg):
+                    if event == "return":
+                        info["locals"] = frame.f_locals
+                    if prev is not None:
+                        prev(frame, event, arg)
+
+                frame.f_trace = trace_returns
+                return trace_returns
+
+        else:
+            code = self._code
+
         func = FunctionType(
-            self._code, outer_scope, argdefs=self.func.__defaults__, closure=self._closure
+            code, outer_scope, argdefs=self.func.__defaults__, closure=self._closure
         )
         func.__kwdefaults__ = self.func.__kwdefaults__
         try:
-            results = func(*args, **kwargs)
+            if is_trace:
+                sys.settrace(trace_func)
+            return_value = func(*args, **kwargs)
         except UnboundLocalError as exc:
             message = exc.args and exc.args[0] or ""
             if message.startswith("local variable ") and message.endswith(
@@ -482,18 +529,25 @@ def __call__(self, *args, **kwargs):
                 ) from exc
             else:
                 raise
-        try:
-            return_value, inner_scope, expect_secret = results
-            if secret is expect_secret:
-                del outer_scope["__builtins__"]
-                del outer_scope["_innerscope_locals_"]
-                del outer_scope["_innerscope_secret_"]
-                # closures show up in locals, but we want them only in outer_scope
-                for key in self._code.co_freevars:
-                    del inner_scope[key]
-                return Scope(self, outer_scope, return_value, inner_scope)
-        except Exception:
-            pass
+        finally:
+            if is_trace:
+                sys.settrace(prev_trace)
+        if is_trace:
+            inner_scope = info["locals"]
+        else:
+            try:
+                return_value, inner_scope, expect_secret = return_value
+            except Exception:
+                expect_secret = None
+        if is_trace or secret is expect_secret:
+            del outer_scope["__builtins__"]
+            del outer_scope["_innerscope_locals_"]
+            del outer_scope["_innerscope_secret_"]
+            # closures show up in locals, but we want them only in outer_scope
+            for key in self._code.co_freevars:
+                del inner_scope[key]
+            return Scope(self, outer_scope, return_value, inner_scope)
+
         return_indices = [
             inst.offset for inst in dis.get_instructions(self.func) if inst.opname == "RETURN_VALUE"
         ]
@@ -523,7 +577,10 @@ def __call__(self, *args, **kwargs):
             f"\n\n{return_msg}  The next closest return statement is {next_closest} bytes away."
             "\n\nA cute workaround is to add code such as `if bool(): return`."
             "\n\nIf it's important to you that this limitation is fixed, then please submit "
-            "an issue (or a pull request!) to:\nhttps://github.com/eriknw/innerscope"
+            "an issue (or a pull request!) to:\nhttps://github.com/eriknw/innerscope\n\n"
+            'Another workaround is to use `method="trace"` in ScopedFunction.  This will '
+            "usually work, but it will be slower and may cause havoc if `sys.settrace` is "
+            "used by anything else.  The default method is preferred if possible."
         )
 
     def bind(self, *mappings, **kwargs):
@@ -592,7 +649,7 @@ def _repr_html_(self):
         )
 
 
-def scoped_function(func=None, *mappings, use_closures=True, use_globals=True):
+def scoped_function(func=None, *mappings, use_closures=True, use_globals=True, method="default"):
     """Use to expose the inner scope of a wrapped function after being called.
 
     The wrapped function should have no return statements.  Instead of a return value,
@@ -625,17 +682,32 @@ def scoped_function(func=None, *mappings, use_closures=True, use_globals=True):
 
         def inner_scoped_func(func):
             return ScopedFunction(
-                func, *mappings, use_closures=use_closures, use_globals=use_globals
+                func,
+                *mappings,
+                use_closures=use_closures,
+                use_globals=use_globals,
+                method=method,
             )
 
         return inner_scoped_func
 
     if isinstance(func, Mapping):
         return scoped_function(
-            None, func, *mappings, use_closures=use_closures, use_globals=use_globals
+            None,
+            func,
+            *mappings,
+            use_closures=use_closures,
+            use_globals=use_globals,
+            method=method,
         )
 
-    return ScopedFunction(func, *mappings, use_closures=use_closures, use_globals=use_globals)
+    return ScopedFunction(
+        func,
+        *mappings,
+        use_closures=use_closures,
+        use_globals=use_globals,
+        method=method,
+    )
 
 
 def bindwith(*mappings, **kwargs):

innerscope/tests/conftest.py

@@ -0,0 +1,8 @@
+import pytest
+
+
+def pytest_configure(config):
+    from innerscope import cfg
+
+    cfg.default_method = config.getoption("--method", "bytecode")
+    print(f'Running tests with "{cfg.default_method}" default method')

innerscope/tests/test_core.py

@@ -2,7 +2,7 @@
 import builtins
 import innerscope
 from pytest import raises
-from innerscope import scoped_function
+from innerscope import scoped_function, cfg
 
 global_x = 1
 
@@ -298,8 +298,14 @@ def f1(arg):
         y = x
         return 2
 
-    with raises(ValueError, match="The first return statement is too far away"):
-        f1(True)
+    if cfg.default_method == 'bytecode':
+        with raises(ValueError, match="The first return statement is too far away"):
+            f1(True)
+    if cfg.default_method == 'trace':
+        scope = f1(True)
+        assert scope == {'x': 1, 'arg': True}
+        assert scope.return_value == 1
+
     scope = f1(False)
     assert scope == {'arg': False,  'y': 1, 'x': 1}
     assert scope.return_value == 2
@@ -349,10 +355,18 @@ def f3(arg):
         y = x
         return 4
 
-    with raises(ValueError, match="The first 2 return statements are too far away"):
-        f3(0)
-    with raises(ValueError, match="The first 2 return statements are too far away"):
-        f3(1)
+    if cfg.default_method == 'bytecode':
+        with raises(ValueError, match="The first 2 return statements are too far away"):
+            f3(0)
+        with raises(ValueError, match="The first 2 return statements are too far away"):
+            f3(1)
+    if cfg.default_method == 'trace':
+        scope = f3(0)
+        assert scope == {'arg': 0, 'x': 1}
+        assert scope.return_value == 1
+        scope = f3(1)
+        assert scope == {'arg': 1, 'x': 1}
+        assert scope.return_value == (1, 2, 3)
     scope = f3(2)
     assert scope == {'arg': 2, 'x': 1}
     assert scope.return_value == 3
@@ -470,3 +484,22 @@ def __init__(self):
     scope = scoped_f.bind(a=20, global_x=2)()
     assert scope["A"].x == 3
     assert scope["A"].z == 120
+
+
+def test_bad_method():
+    def f():
+        x = 1
+
+    with raises(ValueError, match="method= argument to ScopedFunc"):
+        scoped_function(f, method="bad_method")
+    old_default = cfg.default_method
+    try:
+        cfg.default_method = "bad_method"
+        with raises(ValueError, match="method= argument to ScopedFunc"):
+            scoped_function(f)
+        cfg.default_method = "default"
+        with raises(ValueError, match="silly"):
+            scoped_function(f)
+    finally:
+        cfg.default_method = old_default
+    assert innerscope.call(f) == {"x": 1}

setup.py

@@ -32,5 +32,6 @@
         "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3 :: Only",
         "Programming Language :: Python :: Implementation :: CPython",
+        "Programming Language :: Python :: Implementation :: PyPy",
     ],
 )