# ignore
from typing import Set, List, Tuple, Any, Callable, Dict, Optional
from typing import Union, Type, Generator, cast

def middle(x, y, z):  # type: ignore
    if y < z:
        if x < y:
            return y
        elif x < z:
            return y
    else:
        if x > y:
            return y
        elif x > z:
            return x
    return z

m = middle(1, 2, 3)
m

2

m = middle(2, 1, 3)
m

1

# ignore
next_inputs(["step", "step", "step", "step", "quit"]);

with Debugger.Debugger():
    middle(2, 1, 3)

Calling middle(x = 2, y = 1, z = 3)

2     if y < z:

3         if x < y:

5         elif x < z:

6             return y

# ignore
middle_deps().backward_slice('<middle() return value>', mode='d')  # type: ignore

# ignore
middle_deps().backward_slice('<middle() return value>', mode='c', depth=1)  # type: ignore

# ignore
middle_deps().backward_slice('<middle() return value>', mode='c')  # type: ignore

# ignore
middle_deps()

# <= y (1); <- <test> (5)

# ignore
middle_deps().code()  # type: ignore

*    1 def middle(x, y, z):  # type: ignore
*    2     if y < z:  # <= z (1), y (1)
*    3         if x < y:  # <= x (1), y (1); <- <test> (2)
     4             return y
*    5         elif x < z:  # <= z (1), x (1); <- <test> (3)
*    6             return y  # <= y (1); <- <test> (5)
     7     else:
     8         if x > y:
     9             return y
    10         elif x > z:
    11             return x
    12

    return z

quiz("Which of the following `middle()` code lines should be fixed?",
    [
        "Line 2: `if y < z:`",
        "Line 3: `if x < y:`",
        "Line 5: `elif x < z:`",
        "Line 6: `return z`",
    ], '(1 ** 0 + 1 ** 1) ** (1 ** 2 + 1 ** 3)')

print_content(inspect.getsource(remove_html_markup), '.py')

def remove_html_markup(s):  # type: ignore
    tag = False
    quote = False
    out = ""

    for c in s:
        assert tag or not quote

        if c == '<' and not quote:
            tag = True
        elif c == '>' and not quote:
            tag = False
        elif (c == '"' or c == "'") and tag:
            quote = not quote
        elif not tag:
            out = out + c

    return out

remove_html_markup('<foo>bar</foo>')

'bar'

# ignore
def remove_html_markup_deps() -> Dependencies:
    return Dependencies({('s', (remove_html_markup, 136)): set(), ('tag', (remove_html_markup, 137)): set(), ('quote', (remove_html_markup, 138)): set(), ('out', (remove_html_markup, 139)): set(), ('c', (remove_html_markup, 141)): {('s', (remove_html_markup, 136))}, ('<test>', (remove_html_markup, 144)): {('quote', (remove_html_markup, 138)), ('c', (remove_html_markup, 141))}, ('tag', (remove_html_markup, 145)): set(), ('<test>', (remove_html_markup, 146)): {('quote', (remove_html_markup, 138)), ('c', (remove_html_markup, 141))}, ('<test>', (remove_html_markup, 148)): {('c', (remove_html_markup, 141))}, ('<test>', (remove_html_markup, 150)): {('tag', (remove_html_markup, 147)), ('tag', (remove_html_markup, 145))}, ('tag', (remove_html_markup, 147)): set(), ('out', (remove_html_markup, 151)): {('out', (remove_html_markup, 151)), ('c', (remove_html_markup, 141)), ('out', (remove_html_markup, 139))}, ('<remove_html_markup() return value>', (remove_html_markup, 153)): {('<test>', (remove_html_markup, 146)), ('out', (remove_html_markup, 151))}}, {('s', (remove_html_markup, 136)): set(), ('tag', (remove_html_markup, 137)): set(), ('quote', (remove_html_markup, 138)): set(), ('out', (remove_html_markup, 139)): set(), ('c', (remove_html_markup, 141)): set(), ('<test>', (remove_html_markup, 144)): set(), ('tag', (remove_html_markup, 145)): {('<test>', (remove_html_markup, 144))}, ('<test>', (remove_html_markup, 146)): {('<test>', (remove_html_markup, 144))}, ('<test>', (remove_html_markup, 148)): {('<test>', (remove_html_markup, 146))}, ('<test>', (remove_html_markup, 150)): {('<test>', (remove_html_markup, 148))}, ('tag', (remove_html_markup, 147)): {('<test>', (remove_html_markup, 146))}, ('out', (remove_html_markup, 151)): {('<test>', (remove_html_markup, 150))}, ('<remove_html_markup() return value>', (remove_html_markup, 153)): set()})

# ignore
remove_html_markup_deps().graph()

quiz("Why does the first line `tag = False` not influence anything?",
    [
        "Because the input contains only tags",
        "Because `tag` is set to True with the first character",
        "Because `tag` is not read by any variable",
        "Because the input contains no tags",
    ], '(1 << 1 + 1 >> 1)')

# ignore
tag_deps = Dependencies({('tag', (remove_html_markup, 145)): set(), ('<test>', (remove_html_markup, 144)): {('quote', (remove_html_markup, 138)), ('c', (remove_html_markup, 141))}, ('quote', (remove_html_markup, 138)): set(), ('c', (remove_html_markup, 141)): {('s', (remove_html_markup, 136))}, ('s', (remove_html_markup, 136)): set()}, {('tag', (remove_html_markup, 145)): {('<test>', (remove_html_markup, 144))}, ('<test>', (remove_html_markup, 144)): set(), ('quote', (remove_html_markup, 138)): set(), ('c', (remove_html_markup, 141)): set(), ('s', (remove_html_markup, 136)): set()})
tag_deps

# ignore
tag_deps.code()

   238 def remove_html_markup(s):  # type: ignore
   239     tag = False
   240     quote = False
   241     out = ""
   242 
   243     for c in s:
   244         assert tag or not quote
   245 
   246         if c == '<' and not quote:
   247             tag = True
   248         elif c == '>' and not quote:
   249             tag = False
   250         elif (c == '"' or c == "'") and tag:
   251             quote = not quote
   252         elif not tag:
   253             out = out + c
   254 
   255     return out

quiz("How does the slice of `tag = True` change "
     "for a different value of `s`?",
    [
        "Not at all",
        "If `s` contains a quote, the `quote` slice is included, too",
        "If `s` contains no HTML tag, the slice will be empty"
    ], '[1, 2, 3][1:]')

class MyInt(int):
    def __new__(cls: Type, value: Any, *args: Any, **kwargs: Any) -> Any:
        return super(cls, cls).__new__(cls, value)

    def __repr__(self) -> str:
        return f"{int(self)}"

n: MyInt = MyInt(5)

n, n + 1

(5, 6)

n.origin = "Line 5"  # type: ignore

n.origin  # type: ignore

'Line 5'

_data.get('x', x)  # returns x

class DataTracker(StackInspector):
    """Track data accesses during execution"""

    def __init__(self, log: bool = False) -> None:
        """Constructor. If `log` is set, turn on logging."""
        self.log = log

pi = _data.set('pi', 3.1415)

class DataTracker(DataTracker):
    def set(self, name: str, value: Any, loads: Optional[Set[str]] = None) -> Any:
        """Track setting `name` to `value`."""
        if self.log:
            caller_func, lineno = self.caller_location()
            print(f"{caller_func.__name__}:{lineno}: setting {name}")

        return value

print(_data.get('pi', pi))

class DataTracker(DataTracker):
    def get(self, name: str, value: Any) -> Any:
        """Track getting `value` from `name`."""

        if self.log:
            caller_func, lineno = self.caller_location()
            print(f"{caller_func.__name__}:{lineno}: getting {name}")

        return value

_test_data = DataTracker(log=True)
x = _test_data.set('x', 1)

<module>:2: setting x

_test_data.get('x', x)

<module>:1: getting x

1

middle_tree = ast.parse(inspect.getsource(middle))
show_ast(middle_tree)

DATA_TRACKER = '_data'

def is_internal(id: str) -> bool:
    """Return True if `id` is a built-in function or type"""
    return (id in dir(__builtins__) or id in dir(typing))

assert is_internal('int')
assert is_internal('None')
assert is_internal('Tuple')

class TrackGetTransformer(NodeTransformer):
    def visit_Name(self, node: Name) -> AST:
        self.generic_visit(node)

        if is_internal(node.id):
            # Do not change built-in names and types
            return node

        if node.id == DATA_TRACKER:
            # Do not change own accesses
            return node

        if not isinstance(node.ctx, Load):
            # Only change loads (not stores, not deletions)
            return node

        new_node = make_get_data(node.id)
        ast.copy_location(new_node, node)
        return new_node

# Starting with Python 3.8, these will become Constant.
# from ast import Num, Str, NameConstant
# Use `ast.Num`, `ast.Str`, and `ast.NameConstant` for compatibility

def make_get_data(id: str, method: str = 'get') -> Call:
    return Call(func=Attribute(value=Name(id=DATA_TRACKER, ctx=Load()), 
                               attr=method, ctx=Load()),
                args=[ast.Str(id), Name(id=id, ctx=Load())],
                keywords=[])

show_ast(Module(body=[make_get_data("x")], type_ignores=[]))  # type: ignore

/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/3554319793.py:4: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(id), Name(id=id, ctx=Load())],

print(ast.dump(ast.parse("_data.get('x', x)")))

Module(body=[Expr(value=Call(func=Attribute(value=Name(id='_data', ctx=Load()), attr='get', ctx=Load()), args=[Constant(value='x'), Name(id='x', ctx=Load())], keywords=[]))], type_ignores=[])

TrackGetTransformer().visit(middle_tree);

/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/3554319793.py:4: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(id), Name(id=id, ctx=Load())],

def dump_tree(tree: AST) -> None:
    print_content(ast.unparse(tree), '.py')
    ast.fix_missing_locations(tree)  # Must run this before compiling
    _ = compile(cast(ast.Module, tree), '<dump_tree>', 'exec')

dump_tree(middle_tree)

def middle(x, y, z):
    if _data.get('y', y) < _data.get('z', z):
        if _data.get('x', x) < _data.get('y', y):
            return _data.get('y', y)
        elif _data.get('x', x) < _data.get('z', z):
            return _data.get('y', y)
    elif _data.get('x', x) > _data.get('y', y):
        return _data.get('y', y)
    elif _data.get('x', x) > _data.get('z', z):
        return _data.get('x', x)
    return _data.get('z', z)

with DataTrackerTester(tree, func):
    func(...)

class DataTrackerTester:
    def __init__(self, tree: AST, func: Callable, log: bool = True) -> None:
        """Constructor. Execute the code in `tree` while instrumenting `func`."""
        # We pass the source file of `func` such that we can retrieve it
        # when accessing the location of the new compiled code
        source = cast(str, inspect.getsourcefile(func))
        self.code = compile(cast(ast.Module, tree), source, 'exec')
        self.func = func
        self.log = log

    def make_data_tracker(self) -> Any:
        return DataTracker(log=self.log)

    def __enter__(self) -> Any:
        """Rewrite function"""
        tracker = self.make_data_tracker()
        globals()[DATA_TRACKER] = tracker
        exec(self.code, globals())
        return tracker

    def __exit__(self, exc_type: Type, exc_value: BaseException,
                 traceback: TracebackType) -> Optional[bool]:
        """Restore function"""
        globals()[self.func.__name__] = self.func
        del globals()[DATA_TRACKER]
        return None

print_content(inspect.getsource(middle), '.py', start_line_number=1)

 1  def middle(x, y, z):  # type: ignore
 2      if y < z:
 3          if x < y:
 4              return y
 5          elif x < z:
 6              return y
 7      else:
 8          if x > y:
 9              return y
10          elif x > z:
11              return x
12      return z

with DataTrackerTester(middle_tree, middle):
    middle(2, 1, 3)

middle:2: getting y
middle:2: getting z
middle:3: getting x
middle:3: getting y
middle:5: getting x
middle:5: getting z
middle:6: getting y

middle(2, 1, 3)

1

if cond:
    body

func(arg1, arg2, ...)

dump_tree(middle_tree)

def middle(x, y, z):
    _data.param('x', x, pos=1)
    _data.param('y', y, pos=2)
    _data.param('z', z, pos=3, last=True)
    if _data.test(_data.get('y', y) < _data.get('z', z)):
        with _data:
            if _data.test(_data.get('x', x) < _data.get('y', y)):
                with _data:
                    return _data.set('<middle() return value>', _data.get('y', y))
            else:
                with _data:
                    if _data.test(_data.get('x', x) < _data.get('z', z)):
                        with _data:
                            return _data.set('<middle() return value>', _data.get('y', y))
    else:
        with _data:
            if _data.test(_data.get('x', x) > _data.get('y', y)):
                with _data:
                    return _data.set('<middle() return value>', _data.get('y', y))
            else:
                with _data:
                    if _data.test(_data.get('x', x) > _data.get('z', z)):
                        with _data:
                            return _data.set('<middle() return value>', _data.get('x', x))
    return _data.set('<middle() return value>', _data.get('z', z))

with DataTrackerTester(middle_tree, middle):
    m = middle(2, 1, 3)
m

middle:12: initializing x #1
middle:12: setting x
middle:12: initializing y #2
middle:12: setting y
middle:12: initializing z #3
middle:12: setting z
middle:2: getting y
middle:2: getting z
middle:2: testing condition
middle:3: entering block
middle:3: getting x
middle:3: getting y
middle:3: testing condition
middle:5: entering block
middle:5: getting x
middle:5: getting z
middle:5: testing condition
middle:6: entering block
middle:6: getting y
middle:6: setting <middle() return value>
middle:6: exiting block
middle:5: exiting block
middle:3: exiting block

1

class DependencyTracker(DataTracker):
    """Track dependencies during execution"""

    def __init__(self, *args: Any, **kwargs: Any) -> None:
        """Constructor. Arguments are passed to DataTracker.__init__()"""
        super().__init__(*args, **kwargs)

        self.origins: Dict[str, Location] = {}  # Where current variables were last set
        self.data_dependencies: Dependency = {}  # As with Dependencies, above
        self.control_dependencies: Dependency = {}

        self.last_read: List[str] = []  # List of last read variables
        self.last_checked_location = (StackInspector.unknown, 1)
        self._ignore_location_change = False

        self.data: List[List[str]] = [[]]  # Data stack
        self.control: List[List[str]] = [[]]  # Control stack

        self.frames: List[Dict[Union[int, str], Any]] = [{}]  # Argument stack
        self.args: Dict[Union[int, str], Any] = {}  # Current args

class DependencyTracker(DependencyTracker):
    def get(self, name: str, value: Any) -> Any:
        """Track a read access for variable `name` with value `value`"""
        self.check_location()
        self.last_read.append(name)
        return super().get(name, value)

    def check_location(self) -> None:
        pass  # More on that below

x = 5
y = 3

_test_data = DependencyTracker(log=True)
_test_data.get('x', x) + _test_data.get('y', y)

<module>:2: getting x
<module>:2: getting y

8

_test_data.last_read

['x', 'y']

x
y
z = a + b

class DependencyTracker(DependencyTracker):
    def clear_read(self) -> None:
        """Clear set of read variables"""
        if self.log:
            direct_caller = inspect.currentframe().f_back.f_code.co_name  # type: ignore
            caller_func, lineno = self.caller_location()
            print(f"{caller_func.__name__}:{lineno}: "
                  f"clearing read variables {self.last_read} "
                  f"(from {direct_caller})")

        self.last_read = []

    def check_location(self) -> None:
        """If we are in a new location, clear set of read variables"""
        location = self.caller_location()
        func, lineno = location
        last_func, last_lineno = self.last_checked_location

        if self.last_checked_location != location:
            if self._ignore_location_change:
                self._ignore_location_change = False
            elif func.__name__.startswith('<'):
                # Entering list comprehension, eval(), exec(), ...
                pass
            elif last_func.__name__.startswith('<'):
                # Exiting list comprehension, eval(), exec(), ...
                pass
            else:
                # Standard case
                self.clear_read()

        self.last_checked_location = location

class DependencyTracker(DependencyTracker):
    def ignore_next_location_change(self) -> None:
        self._ignore_location_change = True

    def ignore_location_change(self) -> None:
        self.last_checked_location = self.caller_location()

_test_data = DependencyTracker()

_test_data.get('x', x) + _test_data.get('y', y)

8

_test_data.last_read

['x', 'y']

a = 42
b = -1
_test_data.get('a', a) + _test_data.get('b', b)

41

_test_data.last_read

['x', 'y', 'a', 'b']

class DependencyTracker(DependencyTracker):
    TEST = '<test>'  # Name of pseudo-variables for testing conditions

    def set(self, name: str, value: Any, loads: Optional[Set[str]] = None) -> Any:
        """Add a dependency for `name` = `value`"""

        def add_dependencies(dependencies: Set[Node], 
                             vars_read: List[str], tp: str) -> None:
            """Add origins of `vars_read` to `dependencies`."""
            for var_read in vars_read:
                if var_read in self.origins:
                    if var_read == self.TEST and tp == "data":
                        # Can't have data dependencies on conditions
                        continue

                    origin = self.origins[var_read]
                    dependencies.add((var_read, origin))

                    if self.log:
                        origin_func, origin_lineno = origin
                        caller_func, lineno = self.caller_location()
                        print(f"{caller_func.__name__}:{lineno}: "
                              f"new {tp} dependency: "
                              f"{name} <= {var_read} "
                              f"({origin_func.__name__}:{origin_lineno})")

        self.check_location()
        ret = super().set(name, value)
        location = self.caller_location()

        add_dependencies(self.data_dependencies.setdefault
                         ((name, location), set()),
                         self.last_read, tp="data")
        add_dependencies(self.control_dependencies.setdefault
                         ((name, location), set()),
                         cast(List[str], itertools.chain.from_iterable(self.control)),
                         tp="control")

        self.origins[name] = location

        # Reset read info for next line
        self.last_read = [name]

        # Next line is a new location
        self._ignore_location_change = False

        return ret

    def dependencies(self) -> Dependencies:
        """Return dependencies"""
        return Dependencies(self.data_dependencies,
                            self.control_dependencies)

_test_data = DependencyTracker()
x = _test_data.set('x', 1)
y = _test_data.set('y', _test_data.get('x', x))
z = _test_data.set('z', _test_data.get('x', x) + _test_data.get('y', y))

_test_data.origins

{'x': (<function __main__.<module>()>, 2),
 'y': (<function __main__.<module>()>, 3),
 'z': (<function __main__.<module>()>, 4)}

_test_data.data_dependencies

{('x', (<function __main__.<module>()>, 2)): set(),
 ('y',
  (<function __main__.<module>()>, 3)): {('x',
   (<function __main__.<module>()>, 2))},
 ('z',
  (<function __main__.<module>()>, 4)): {('x',
   (<function __main__.<module>()>, 2)), ('y',
   (<function __main__.<module>()>, 3))}}

# ignore
_test_data.dependencies().graph()

with Slicer(func_1, func_2, ...) as slicer:
    func(...)

class Instrumenter(StackInspector):
    """Instrument functions for dynamic tracking"""

    def __init__(self, *items_to_instrument: Callable,
                 globals: Optional[Dict[str, Any]] = None,
                 log: Union[bool, int] = False) -> None:
        """
        Create an instrumenter.
        `items_to_instrument` is a list of items to instrument.
        `globals` is a namespace to use (default: caller's globals())
        """

        self.log = log
        self.items_to_instrument: List[Callable] = list(items_to_instrument)
        self.instrumented_items: Set[Any] = set()

        if globals is None:
            globals = self.caller_globals()
        self.globals = globals

    def __enter__(self) -> Any:
        """Instrument sources"""
        items = self.items_to_instrument
        if not items:
            items = self.default_items_to_instrument()

        for item in items:
            self.instrument(item)

        return self

    def default_items_to_instrument(self) -> List[Callable]:
        return []

    def instrument(self, item: Any) -> Any:
        """Instrument `item`. To be overloaded in subclasses."""
        if self.log:
            print("Instrumenting", item)
        self.instrumented_items.add(item)
        return item

class Instrumenter(Instrumenter):
    def __exit__(self, exc_type: Type, exc_value: BaseException,
                 traceback: TracebackType) -> Optional[bool]:
        """Restore sources"""
        self.restore()
        return None

    def restore(self) -> None:
        for item in self.instrumented_items:
            self.globals[item.__name__] = item

with Instrumenter(middle, log=True) as ins:
    pass

Instrumenting <function middle at 0x11d0c1080>

class Slicer(Instrumenter):
    """Track dependencies in an execution"""

    def __init__(self, *items_to_instrument: Any,
                 dependency_tracker: Optional[DependencyTracker] = None,
                 globals: Optional[Dict[str, Any]] = None,
                 log: Union[bool, int] = False):
        """Create a slicer.
        `items_to_instrument` are Python functions or modules with source code.
        `dependency_tracker` is the tracker to be used (default: DependencyTracker).
        `globals` is the namespace to be used(default: caller's `globals()`)
        `log`=True or `log` > 0 turns on logging
        """
        super().__init__(*items_to_instrument, globals=globals, log=log)

        if dependency_tracker is None:
            dependency_tracker = DependencyTracker(log=(log > 1))
        self.dependency_tracker = dependency_tracker

        self.saved_dependencies = None

    def default_items_to_instrument(self) -> List[Callable]:
        raise ValueError("Need one or more items to instrument")

class Slicer(Slicer):
    def parse(self, item: Any) -> AST:
        """Parse `item`, returning its AST"""
        source_lines, lineno = inspect.getsourcelines(item)
        source = "".join(source_lines)

        if self.log >= 2:
            print_content(source, '.py', start_line_number=lineno)
            print()
            print()

        tree = ast.parse(source)
        ast.increment_lineno(tree, lineno - 1)
        return tree

class Slicer(Slicer):
    def transformers(self) -> List[NodeTransformer]:
        """List of transformers to apply. To be extended in subclasses."""
        return [
            TrackCallTransformer(),
            TrackSetTransformer(),
            TrackGetTransformer(),
            TrackControlTransformer(),
            TrackReturnTransformer(),
            TrackParamsTransformer()
        ]

    def transform(self, tree: AST) -> AST:
        """Apply transformers on `tree`. May be extended in subclasses."""
        # Apply transformers
        for transformer in self.transformers():
            if self.log >= 3:
                print(transformer.__class__.__name__ + ':')

            transformer.visit(tree)
            ast.fix_missing_locations(tree)
            if self.log >= 3:
                print_content(ast.unparse(tree), '.py')
                print()
                print()

        if 0 < self.log < 3:
            print_content(ast.unparse(tree), '.py')
            print()
            print()

        return tree

class Slicer(Slicer):
    def execute(self, tree: AST, item: Any) -> None:
        """Compile and execute `tree`. May be extended in subclasses."""

        # We pass the source file of `item` such that we can retrieve it
        # when accessing the location of the new compiled code
        source = cast(str, inspect.getsourcefile(item))
        code = compile(cast(ast.Module, tree), source, 'exec')

        # Enable dependency tracker
        self.globals[DATA_TRACKER] = self.dependency_tracker

        # Execute the code, resulting in a redefinition of item
        exec(code, self.globals)

class Slicer(Slicer):
    def instrument(self, item: Any) -> Any:
        """Instrument `item`, transforming its source code, and re-defining it."""
        if is_internal(item.__name__):
            return item  # Do not instrument `print()` and the like

        if inspect.isbuiltin(item):
            return item  # No source code

        item = super().instrument(item)
        tree = self.parse(item)
        tree = self.transform(tree)
        self.execute(tree, item)

        new_item = self.globals[item.__name__]
        return new_item

class Slicer(Slicer):
    def restore(self) -> None:
        """Restore original code."""
        if DATA_TRACKER in self.globals:
            self.saved_dependencies = self.globals[DATA_TRACKER]
            del self.globals[DATA_TRACKER]

        super().restore()

class Slicer(Slicer):
    def dependencies(self) -> Dependencies:
        """Return collected dependencies."""
        if self.saved_dependencies is None:
            return Dependencies({}, {})
        return self.saved_dependencies.dependencies()

    def code(self, *args: Any, **kwargs: Any) -> None:
        """Show code of instrumented items, annotated with dependencies."""
        first = True
        for item in self.instrumented_items:
            if not first:
                print()
            self.dependencies().code(item, *args, **kwargs)  # type: ignore
            first = False

    def graph(self, *args: Any, **kwargs: Any) -> Digraph:
        """Show dependency graph."""
        return self.dependencies().graph(*args, **kwargs)  # type: ignore

    def _repr_mimebundle_(self, include: Any = None, exclude: Any = None) -> Any:
        """If the object is output in Jupyter, render dependencies as a SVG graph"""
        return self.graph()._repr_mimebundle_(include, exclude)

with Slicer(middle) as slicer:
    m = middle(2, 1, 3)
m

/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/3554319793.py:4: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(id), Name(id=id, ctx=Load())],
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/2454789564.py:22: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(id), value],
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:12: DeprecationWarning: ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead
  keywords=[keyword(arg='pos', value=ast.Num(n + 1))]
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:25: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(child.arg),
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:19: DeprecationWarning: ast.NameConstant is deprecated and will be removed in Python 3.14; use ast.Constant instead
  value=ast.NameConstant(value=True)))

1

print(slicer.dependencies())

middle():
    <test> (2) <= y (12), z (12)
    <test> (3) <= y (12), x (12); <- <test> (2)
    <test> (5) <= z (12), x (12); <- <test> (3)
    <middle() return value> (6) <= y (12); <- <test> (5)

slicer.code()

     1 def middle(x, y, z):  # type: ignore
*    2     if y < z:  # <= y (12), z (12)
*    3         if x < y:  # <= y (12), x (12); <- <test> (2)
     4

            return y
*    5         elif x < z:  # <= z (12), x (12); <- <test> (3)
*    6             return y  # <= y (12); <- <test> (5)
     7     else:
     8

        if x > y:
     9             return y
    10         elif x > z:
    11             return x
*   12     return z

slicer

print(repr(slicer.dependencies()))

Dependencies(
    data={
        ('x', (middle, 12)): set(),
        ('y', (middle, 12)): set(),
        ('z', (middle, 12)): set(),
        ('<test>', (middle, 2)): {('y', (middle, 12)), ('z', (middle, 12))},
        ('<test>', (middle, 3)): {('y', (middle, 12)), ('x', (middle, 12))},
        ('<test>', (middle, 5)): {('z', (middle, 12)), ('x', (middle, 12))},
        ('<middle() return value>', (middle, 6)): {('y', (middle, 12))}},
 control={
        ('x', (middle, 12)): set(),
        ('y', (middle, 12)): set(),
        ('z', (middle, 12)): set(),
        ('<test>', (middle, 2)): set(),
        ('<test>', (middle, 3)): {('<test>', (middle, 2))},
        ('<test>', (middle, 5)): {('<test>', (middle, 3))},
        ('<middle() return value>', (middle, 6)): {('<test>', (middle, 5))}})

print_content(inspect.getsource(square_root), '.py')

def square_root(x):  # type: ignore
    assert x >= 0  # precondition

    approx = None
    guess = x / 2
    while approx != guess:
        approx = guess
        guess = (approx + x / approx) / 2

    assert math.isclose(approx * approx, x)
    return approx

with Slicer(square_root, log=True) as root_slicer:
    y = square_root(2.0)

Instrumenting <function square_root at 0x11d6c9bc0>
def square_root(x):
    _data.param('x', x, pos=1, last=True)
    assert _data.set('<assertion>', _data.get('x', x) >= 0, loads=(_data.get('x', x),))
    approx = _data.set('approx', None)
    guess = _data.set('guess', _data.get('x', x) / 2)
    while _data.test(_data.get('approx', approx) != _data.get('guess', guess)):
        with _data:
            approx = _data.set('approx', _data.get('guess', guess))
            guess = _data.set('guess', (_data.get('approx', approx) + _data.get('x', x) / _data.get('approx', approx)) / 2)
    assert _data.set('<assertion>', _data.ret(_data.call(_data.get('math', math).isclose)(_data.arg(_data.get('approx', approx) * _data.get('approx', approx), pos=1), _data.arg(_data.get('x', x), pos=2))), loads=(_data, _data.get('math', math), _data.get('x', x), _data.get('approx', approx)))
    return _data.set('<square_root() return value>', _data.get('approx', approx))

/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/2498757139.py:9: DeprecationWarning: ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead
  keywords.append(keyword(arg='pos', value=ast.Num(pos)))
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/2454789564.py:22: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(id), value],
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/3554319793.py:4: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(id), Name(id=id, ctx=Load())],
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:12: DeprecationWarning: ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead
  keywords=[keyword(arg='pos', value=ast.Num(n + 1))]
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:19: DeprecationWarning: ast.NameConstant is deprecated and will be removed in Python 3.14; use ast.Constant instead
  value=ast.NameConstant(value=True)))
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:25: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(child.arg),

root_slicer

root_slicer.code()

    54 def square_root(x):  # type: ignore
*   55     assert x >= 0  # precondition  # <= x (64)
    56 
*   57     approx = None
*   58     guess = x / 2  # <= x (64)
*   59     while approx != guess:  # <= guess (61), guess (58), approx (60), approx (57)
*   60         approx = guess  # <= guess (61), guess (58); <- <test> (59)
*   61         guess = (approx + x / approx) / 2  # <= approx (60), x (64); <- <test> (59)
    62 
*   63     assert math.isclose(approx * approx, x)  # <= approx (60), x (64)
*   64     return approx  # <= approx (60)

quiz("Why don't `assert` statements induce control dependencies?",
     [
         "We have no special handling of `raise` statements",
         "We have no special handling of exceptions",
         "Assertions are not supposed to act as controlling mechanisms",
         "All of the above",
     ], '(1 * 1 << 1 * 1 << 1 * 1)')

# print(repr(root_slicer))

with Slicer(remove_html_markup) as rhm_slicer:
    s = remove_html_markup("<foo>bar</foo>")

/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/2454789564.py:22: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(id), value],
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/3554319793.py:4: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(id), Name(id=id, ctx=Load())],
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:12: DeprecationWarning: ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead
  keywords=[keyword(arg='pos', value=ast.Num(n + 1))]
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:19: DeprecationWarning: ast.NameConstant is deprecated and will be removed in Python 3.14; use ast.Constant instead
  value=ast.NameConstant(value=True)))
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:25: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(child.arg),

rhm_slicer

# print(repr(rhm_slicer.dependencies()))

rhm_slicer.code()

   238 def remove_html_markup(s):  # type: ignore
*  239     tag = False
*  240     quote = False
*  241     out = ""
   242 
*  243     for c in s:  # <= s (255)
*  244         assert tag or not quote  # <= tag (239), quote (240), tag (247), tag (249)
   245 
*  246         if c == '<' and not quote:  # <= quote (240), c (243)
*  247             tag = True  # <- <test> (246)
*  248         elif c == '>' and not quote:  # <= quote (240), c (243); <- <test> (246)
*  249             tag = False  # <- <test> (248)
*  250         elif (c == '"' or c == "'") and tag:  # <= c (243); <- <test> (248)
   251             quote = not quote
*  252         elif not tag:  # <= tag (247), tag (249); <- <test> (250)
*  253             out = out + c  # <= c (243), out (241), out (253); <- <test> (252)
   254

*  255     return out  # <= out (253)

_, start_remove_html_markup = inspect.getsourcelines(remove_html_markup)
start_remove_html_markup

238

slicing_criterion = ('tag', (remove_html_markup,
                             start_remove_html_markup + 9))
tag_deps = rhm_slicer.dependencies().backward_slice(slicing_criterion)  # type: ignore
tag_deps

# repr(tag_deps)

def add_to(n, m):  # type: ignore
    n += m
    return n

def mul_with(x, y):  # type: ignore
    x *= y
    return x

def test_math() -> None:
    return mul_with(1, add_to(2, 3))

with Slicer(add_to, mul_with, test_math) as math_slicer:
    test_math()

/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/2454789564.py:22: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(id), value],
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/3554319793.py:4: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(id), Name(id=id, ctx=Load())],
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:12: DeprecationWarning: ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead
  keywords=[keyword(arg='pos', value=ast.Num(n + 1))]
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:25: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(child.arg),
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:19: DeprecationWarning: ast.NameConstant is deprecated and will be removed in Python 3.14; use ast.Constant instead
  value=ast.NameConstant(value=True)))
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/2498757139.py:9: DeprecationWarning: ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead
  keywords.append(keyword(arg='pos', value=ast.Num(pos)))

math_slicer

/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/3262393251.py:21: UserWarning: Warning: y (mul_with:3) depends on <add_to() return value> (add_to:3), but 'return x' does not seem to have a call
  warnings.warn(f"Warning: {self.format_var(var)} "

math_slicer.code()

     1 def test_math() -> None:
*    2     return mul_with(1, add_to(2, 3))  # <= <mul_with() return value> (mul_with:3)

     1 def add_to(n, m):  # type: ignore
*    2     n += m  # <= n (3), m (3)
*    3     return n  # <= n (2)

     1 def mul_with(x, y):  # type: ignore
*    2     x *= y  # <= y (3), x (3)
*    3     return x  # <= <add_to() return value> (add_to:3), x (2)

/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/3262393251.py:21: UserWarning: Warning: y (mul_with:3) depends on <add_to() return value> (add_to:3), but 'return x' does not seem to have a call
  warnings.warn(f"Warning: {self.format_var(var)} "

def fun_1(x: int) -> int:
    return x

def fun_2(x: int) -> int:
    return fun_1(x)

with Slicer(log=True) as slicer:
    fun_2(10)

Instrumenting <function fun_2 at 0x11d322840>
def fun_2(x: int) -> int:
    _data.param('x', x, pos=1, last=True)
    return _data.set('<fun_2() return value>', _data.ret(_data.call(_data.get('fun_1', fun_1))(_data.arg(_data.get('x', x), pos=1))))

Instrumenting <function fun_1 at 0x11d322160>
def fun_1(x: int) -> int:
    _data.param('x', x, pos=1, last=True)
    return _data.set('<fun_1() return value>', _data.get('x', x))

/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/2498757139.py:9: DeprecationWarning: ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead
  keywords.append(keyword(arg='pos', value=ast.Num(pos)))
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/3554319793.py:4: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(id), Name(id=id, ctx=Load())],
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/2454789564.py:22: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(id), value],
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:12: DeprecationWarning: ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead
  keywords=[keyword(arg='pos', value=ast.Num(n + 1))]
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:19: DeprecationWarning: ast.NameConstant is deprecated and will be removed in Python 3.14; use ast.Constant instead
  value=ast.NameConstant(value=True)))
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:25: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(child.arg),

slicer

SECRET_HASH_DIGEST = '59f2da35bcc39525b87932b4cc1f3d68'

def password_checker() -> bool:
    """Request a password. Return True if correct."""
    secret_password = input("Enter secret password: ")
    password_digest = hashlib.md5(secret_password.encode('utf-8')).hexdigest()

    if password_digest == SECRET_HASH_DIGEST:
        return True
    else:
        return False

# ignore
next_inputs(['secret123'])

['secret123']

with Slicer() as slicer:
    valid_pwd = password_checker()

/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/2498757139.py:9: DeprecationWarning: ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead
  keywords.append(keyword(arg='pos', value=ast.Num(pos)))
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/2454789564.py:22: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(id), value],
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/3554319793.py:4: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(id), Name(id=id, ctx=Load())],

slicer

# ignore
secret_answers = [
    'automated',
    'debugging',
    'is',
    'fun'
]

quiz("What is the secret password, actually?", 
     [f"`{repr(s)}`" for s in secret_answers],
     min([i + 1 for i, ans in enumerate(secret_answers) 
          if hashlib.md5(ans.encode('utf-8')).hexdigest() == 
              SECRET_HASH_DIGEST])
    )

# ignore
_, start_square_root = inspect.getsourcelines(square_root)

# ignore
print_content(inspect.getsource(square_root), '.py',
              start_line_number=start_square_root)

54  def square_root(x):  # type: ignore
55      assert x >= 0  # precondition
56  
57      approx = None
58      guess = x / 2
59      while approx != guess:
60          approx = guess
61          guess = (approx + x / approx) / 2
62  
63      assert math.isclose(approx * approx, x)
64      return approx

def square_root_unchecked(x):  # type: ignore
    assert True  # <-- new "precondition"

    approx = None
    guess = x / 2
    while approx != guess:
        approx = guess
        guess = (approx + x / approx) / 2

    assert True  # <-- new "postcondition"
    return approx

postcondition_lineno = start_square_root + 9
postcondition_lineno

63

with Slicer() as slicer:
    y = square_root(4)

slicer.dependencies().backward_slice((square_root, postcondition_lineno))

/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/2498757139.py:9: DeprecationWarning: ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead
  keywords.append(keyword(arg='pos', value=ast.Num(pos)))
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/2454789564.py:22: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(id), value],
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/3554319793.py:4: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(id), Name(id=id, ctx=Load())],
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:12: DeprecationWarning: ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead
  keywords=[keyword(arg='pos', value=ast.Num(n + 1))]
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:19: DeprecationWarning: ast.NameConstant is deprecated and will be removed in Python 3.14; use ast.Constant instead
  value=ast.NameConstant(value=True)))
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:25: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(child.arg),

with Slicer() as slicer:
    y = square_root_unchecked(4)

slicer.dependencies().backward_slice((square_root, postcondition_lineno))

/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/2454789564.py:22: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(id), value],
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/3554319793.py:4: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(id), Name(id=id, ctx=Load())],
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:12: DeprecationWarning: ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead
  keywords=[keyword(arg='pos', value=ast.Num(n + 1))]
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:19: DeprecationWarning: ast.NameConstant is deprecated and will be removed in Python 3.14; use ast.Constant instead
  value=ast.NameConstant(value=True)))
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:25: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(child.arg),

with Slicer() as slicer:
    <Some call to func()>

with Slicer(func, func_1, func_2) as slicer:
    <Some call to func()>

def demo(x: int) -> int:
    z = x
    while x <= z <= 64:
        z *= 2
    return z

with Slicer() as slicer:
    demo(10)

/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/2454789564.py:22: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(id), value],
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/3554319793.py:4: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(id), Name(id=id, ctx=Load())],
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:12: DeprecationWarning: ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead
  keywords=[keyword(arg='pos', value=ast.Num(n + 1))]
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:19: DeprecationWarning: ast.NameConstant is deprecated and will be removed in Python 3.14; use ast.Constant instead
  value=ast.NameConstant(value=True)))
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:25: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(child.arg),

slicer

slicer.code()

     1 def demo(x: int) -> int:
*    2     z = x  # <= x (5)
*    3     while x <= z <= 64:  # <= x (5), z (2), z (4)
*    4         z *= 2  # <= z (2), z (4); <- <test> (3)
*    5     return z  # <= z (4)

slicer.dependencies().all_vars()

{('<demo() return value>', (<function __main__.demo(x: int) -> int>, 5)),
 ('<test>', (<function __main__.demo(x: int) -> int>, 3)),
 ('x', (<function __main__.demo(x: int) -> int>, 5)),
 ('z', (<function __main__.demo(x: int) -> int>, 2)),
 ('z', (<function __main__.demo(x: int) -> int>, 4))}

_, start_demo = inspect.getsourcelines(demo)
start_demo

1

slicer.dependencies().backward_slice(('z', (demo, start_demo + 1))).graph()  # type: ignore

# ignore
from ClassDiagram import display_class_hierarchy, class_tree

# ignore
assert class_tree(Slicer)[0][0] == Slicer

# ignore
display_class_hierarchy([Slicer, DependencyTracker, 
                         StackInspector, Dependencies],
                        abstract_classes=[
                            StackInspector,
                            Instrumenter
                        ],
                        public_methods=[
                            StackInspector.caller_frame,
                            StackInspector.caller_function,
                            StackInspector.caller_globals,
                            StackInspector.caller_locals,
                            StackInspector.caller_location,
                            StackInspector.search_frame,
                            StackInspector.search_func,
                            Instrumenter.__init__,
                            Instrumenter.__enter__,
                            Instrumenter.__exit__,
                            Instrumenter.instrument,
                            Slicer.__init__,
                            Slicer.code,
                            Slicer.dependencies,
                            Slicer.graph,
                            Slicer._repr_mimebundle_,
                            DataTracker.__init__,
                            DataTracker.__enter__,
                            DataTracker.__exit__,
                            DataTracker.arg,
                            DataTracker.augment,
                            DataTracker.call,
                            DataTracker.get,
                            DataTracker.param,
                            DataTracker.ret,
                            DataTracker.set,
                            DataTracker.test,
                            DataTracker.__repr__,
                            DependencyTracker.__init__,
                            DependencyTracker.__enter__,
                            DependencyTracker.__exit__,
                            DependencyTracker.arg,
                            # DependencyTracker.augment,
                            DependencyTracker.call,
                            DependencyTracker.get,
                            DependencyTracker.param,
                            DependencyTracker.ret,
                            DependencyTracker.set,
                            DependencyTracker.test,
                            DependencyTracker.__repr__,
                            Dependencies.__init__,
                            Dependencies.__repr__,
                            Dependencies.__str__,
                            Dependencies._repr_mimebundle_,
                            Dependencies.code,
                            Dependencies.graph,
                            Dependencies.backward_slice,
                            Dependencies.all_functions,
                            Dependencies.all_vars,
                        ],
                        project='debuggingbook')

def assert_flow(target: Any, source: List[Any]) -> bool:
    """
    Raise an `AssertionError` if the dependencies of `target`
    are not equal to `source`.
    """
    ...
    return True

def demo4() -> int:
    x = 25
    y = 26
    assert_flow(y, [x])  # ensures that `y` depends on `x` only
    return y

with Slicer() as slicer:
    demo4()

/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/2498757139.py:9: DeprecationWarning: ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead
  keywords.append(keyword(arg='pos', value=ast.Num(pos)))
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/2454789564.py:22: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(id), value],
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/3554319793.py:4: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(id), Name(id=id, ctx=Load())],
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:12: DeprecationWarning: ast.Num is deprecated and will be removed in Python 3.14; use ast.Constant instead
  keywords=[keyword(arg='pos', value=ast.Num(n + 1))]
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:25: DeprecationWarning: ast.Str is deprecated and will be removed in Python 3.14; use ast.Constant instead
  args=[ast.Str(child.arg),
/var/folders/n2/xd9445p97rb3xh7m1dfx8_4h0006ts/T/ipykernel_94980/882995308.py:19: DeprecationWarning: ast.NameConstant is deprecated and will be removed in Python 3.14; use ast.Constant instead
  value=ast.NameConstant(value=True)))

Tracking Failure Origins¶

Dependencies¶

Data Dependencies¶

Control Dependencies¶

Dependency Graphs¶

Showing Dependencies with Code¶

Quiz

Slices¶

Quiz

Quiz

Tracking Techniques¶

Wrapping Data Objects¶

Wrapping Data Accesses¶

A Data Tracker¶

Instrumenting Source Code¶

Tracking Variable Accesses¶

Tracking Dependencies¶

Data Dependencies¶

Reading Variables¶

Checking Locations¶

Setting Variables¶

Slicing Code¶

An Instrumenter Base Class¶

The Slicer Class¶

Diagnostics¶

More Examples¶

Square Root¶

Quiz

Removing HTML Markup¶

Calls and Augmented Assign¶

Dynamic Instrumentation¶

More Applications¶

Verifying Information Flows¶

Quiz

Assessing Test Quality¶

Use in Statistical Debugging¶

Synopsis¶

Things that do not Work¶

Lessons Learned¶

Next Steps¶

Background¶

Exercises¶

Exercise 1: Control Slices¶

Exercise 2: Incremental Exploration¶

Exercise 3: Forward Slicing¶

Exercise 4: Code with Forward Dependencies¶

Exercise 5: Flow Assertions¶

Exercise 6: Checked Coverage¶