L3viathan

Proof-of-concept: character-based coverage tool

As of 3.11, code objects have a new co_positions() method that yields tuples of the form (lineno_start, lineno_end, char_start, char_end) for each bytecode instruction. Combined with setting f_trace_opcodes to True on a frame, trace functions can theoretically track coverage on a character level.

There are a bunch of issues though, shown in part in the code:

• Some instructions correctly cover a wide range of code: JUMP_* instructions from branching code basically seems to span the entire length of the jump, i.e. from the if to the end of the indented block. MAKE_FUNCTION covers the entire function definition. These issues seem to be easy to resolve on first glance, because you can just ignore the corresponding opcodes.

L3viathan

import sys

class Effect:
    def __enter__(self):
        self.local_handlers = sys._getframe().f_back.f_locals.setdefault("_effect_handlers", [])
        self.local_handlers.append(self)

    def __exit__(self, *args):
        self.local_handlers.pop()

L3viathan

def overload(fn, overloads={}, nope=object()):
    def wrapper(*args, **kwargs):
        for sig, func in overloads.get(fn.__qualname__, []):
            try:
                bound = sig.bind(*args, **kwargs)
            except TypeError:
                continue
            for name, value in bound.arguments.items():
                if not isinstance(value, func.__annotations__[name]):
                    break

L3viathan

import sys
import inspect
from contextlib import contextmanager
from collections import defaultdict


deferred_lines = defaultdict(list)


def defer_trace(frame, event, arg):

L3viathan

set conceallevel=2
syntax match Normal '\v ?(:|-\>) ?[^,):]+' conceal
" this doesn't always work, only with simple types (not stuff with commas in them)
" if you know how to deal with those (virtual text?), tell me please

L3viathan

for type(
    type.__name__,
    (),
    {
        type.__name__: type(
            type.__name__,
            (),
            {
                "__{0}__".format(
                    type({0}).__name__

L3viathan

import fishhook

split_map = {"w": "v"}

@fishhook.hook(str)
def __getitem__(self, something):
    if not isinstance(something, slice):
        return fishhook.orig(self, something)
    start, stop, step = something.start, something.stop, something.step
    split_start = start % 1 == 0.5 if start else False

L3viathan

import os
import sys
import inspect
import signal
from contextlib import contextmanager

def _kill_self(signum, frame):
    os._exit(0)

@contextmanager

L3viathan

class AliasableMeta(type):
    aliases = {}
class Aliasable(metaclass=AliasableMeta): pass

class AliasOfMeta(type):
    def __getattr__(self, value):
        return self(value)

class alias_of(metaclass=AliasOfMeta):
    def __init__(self, other=None):

L3viathan

>>> import mutable_tuples
>>> t = (1, 2, 3)
>>> t[1] = 23
>>> t
(1, 23, 3)