Support matcher types?

[qdewaghe]

Hello,

I think it would be interesting to have a way to turn a matcher type into a inline-snapshot enabled object.
The simplest example of a matcher type I can think of:

def get_data():
    return 1

def test_evenness():
    assert Matcher(is_even=True).matches(get_data())

---

Some notes/considerations:

• Some of these matchers abuse __eq__, others implements a method like matches in the above example
• Matchers could potentially be re-used in several asserts
• A matcher could have several representations that lead to a match. I guess it would be up to the implementer of the matcher to choose whether it makes sense to provide a "fix".
• A matcher could be replaced by another, eg: dirty-equals' IsNegative could be turned into IsPositive.

wdyt?

[15r10nk]

Matcher which (ab)use __eq__ work already. You only have do declare them as unmanaged.

Matcher which use methods like matches are not so easy to integrate. The main requirement is that the code should also work when you remove the snapshot() call. The matcher should therefor overload __eq__.

Do you have a special library in mind which should be supported by inline-snapshot?

[15r10nk]

Ok, I implemented your IsStr example with the current branch (the syntax has changed a bit):

from inline_snapshot import customize
from inline_snapshot import Builder
from inline_snapshot import snapshot

from dirty_equals import IsStr


@customize
def quadrat_handler(value, builder: Builder):
    if value == IsStr(regex="[a-z]"):
        return builder.create_call(IsStr, [], {"regex": "[a-z]"})


def test():
    assert snapshot(IsStr(regex="[a-z]")) == "a"
    assert snapshot("abc") == "abc"
    assert snapshot("5") == "5"

You can try to implement your use cases with this branch and give me feedback if you want.
I created a customize-stable branch which you can use for your tests.

pip install git+https://github.com/15r10nk/inline-snapshot.git@customize-stable

The creation of new values works but the update of existing code is still buggy.

I would not recommend you to use this in production jet, but you could help me to verify the current design if you want.

[qdewaghe]

I played with the customize branch today and it's great.

I think there is a bit of an assumption baked-in right now that both the lhs and rhs are of the same type which wouldn't be the case with matchers. Maybe we could have both values exposed?

@customize
def quadrat_handler(lhs_value, rhs_value, builder: Builder): ...

I wouldn't want to put a matcher in the snapshot instead of the actual value if there wasn't a matcher in the first place.

Slightly out of topic for this thread but I'm wondering if @customize could give the user more control on the generated code. I find that multiline strings are a bit annoying tbh.

from inline_snapshot import snapshot
import textwrap

class T:
    def __init__(self, multi):
        self.multi = textwrap.dedent(multi).strip()

    def __eq__(self, other):
        return self.multi == other 
    
def test_other_test():

    assert snapshot(T(
        """
        line1
        line
        """)) == "line1\nline2"

Here, I know that the argument gets dedented and stripped, so it would be cool if @customize would allow me to keep the formatting somehow on top of not losing T().

I know that multiline strings are a bit tricky because formatters don't help :/

[qdewaghe]

Kinda managed to hack it together:

from inline_snapshot import customize
from inline_snapshot import Builder
from inline_snapshot import snapshot


class T:
    def __init__(self, s):
        self.s = s

    def __eq__(self, other):
        return self.s == other


@customize
def quadrat_handler(generic_value, value, builder: Builder):
    if (
        generic_value
        and hasattr(generic_value, "_old_value")
        and hasattr(generic_value._old_value, "_function")
        and generic_value._old_value._function.value is T
    ):
        return builder.create_call(None, T, value)


def test_snapshot():
    assert snapshot("a") == "b"
    assert snapshot(T("a")) == "b"

I just passed around the value, I also had to break in Builder._get_handler() when a "custom_function" returns something to make it work.

[15r10nk]

I wouldn't want to put a matcher in the snapshot instead of the actual value if there wasn't a matcher in the first place.

good point. maybe you also want to preserve arguments of your existing Matcher.

I know that multiline strings are a bit tricky because formatters don't help :/

https://github.com/15r10nk/format-dedent might help 😃
You are not the first with this problems, but it is also not an easy problem to fix. Almost everyone prefers a slightly different style. And yes it is written by AI, because I wanted to try it.

I also plan to move the string logic into a customize hook. This will allow the user to override it with its preferred style builder.create_value(s,'""" the generated string """').

I think there is a bit of an assumption baked-in right now that both the lhs and rhs are of the same type which wouldn't be the case with matchers. Maybe we could have both values exposed?

I think that I will make the customize interface a bit more flexible, because it could be useful to provide more information in the future. Maybe something like this:

@customize
def quadrat_handler(value, snapshot_value, snapshot_location, builder: Builder): ...

pluggy allows you to define functions with only the arguments you need, which allows the library to add more in the future without breaking the API. Something similar would be also be useful here. This would allow you to write code like this:

@customize
def quadrat_handler(value, snapshot_value, snapshot_location, builder: Builder):
    # I need a lot of context
    pass

@customize
def other_handler(value, builder: Builder):
    # I need no context   
    pass

Thank you for your feedback.

[qdewaghe]

I found another way of doing what I wanted without modifying the customize branch:

from inline_snapshot import customize
from inline_snapshot import Builder
from inline_snapshot import snapshot

import sys, random


def is_called_recursively():
    current_frame = sys._getframe(1)
    target_code = current_frame.f_code
    check_frame = current_frame.f_back
    while check_frame:
        if check_frame.f_code is target_code:
            return True
        check_frame = check_frame.f_back

    return False


class CaseInsensitiveStr:
    def __init__(self, s):
        self.s = s.lower()

    def __eq__(self, other):
        if isinstance(other, CaseInsensitiveStr):
            return self.s == other.s.lower()
        else:
            return self.s == other.lower()

    def spongebob_case_fix(self, s):
        return "".join(
            c.upper() if random.choice([True, False]) else c.lower() for c in s
        )


@customize
def quadrat_handler(value, builder: Builder):
    if is_called_recursively():
        return

    for var_name, var_value in builder._snapshot_context.frame.locals.items():
        if (
            "@py_assert" in var_name
            and var_value
            and isinstance(var_value, CaseInsensitiveStr)
        ):
            return builder.create_call(
                CaseInsensitiveStr, [var_value.spongebob_case_fix(value)]
            )


def test_snapshot():
    assert snapshot(CaseInsensitiveStr("")) == "Patrick, your genius is showing"

Truly outdid myself with that example. I believe it should work fine because all the inactive @py_assert variables are set to None. Having to stop the recursion is a bit unintuitive tho

[qdewaghe]

Another use case I found for #329:

from inline_snapshot import snapshot
from pathlib import Path, PosixPath


def test_path():
    assert Path() == snapshot(PosixPath(".")) 
    assert PosixPath() == snapshot(PosixPath("."))

[15r10nk]

it is already part of the PR ;-), but it generates only Path and PurePath to be compatible with multiple platforms.

inline-snapshot/src/inline_snapshot/plugin/_default_plugin.py

Lines 77 to 83 in ce67f53

	@customize
	def path_handler(self, value, builder: Builder):
	if isinstance(value, Path):
	return builder.create_call(Path, [value.as_posix()])
	if isinstance(value, PurePath):
	return builder.create_call(PurePath, [value.as_posix()])

[qdewaghe]

I played a bit more with the customize branch at work this week and a few things I noticed:

Didn't have much luck with

[project.entry-points.inline-snapshot]
my_plugin = "mymodule.InlineSnapshotSomethingPlugin"

But this was working fine:

[project.entry-points.inline-snapshot]
my_plugin = "mymodule"

I think you might have changed the code since then.

I guess that because these aren't pytest plugins we can't count on -p no:my_plugin and other related options to work

I ran into trouble trying to use create_call on a function that looks up at stack to try to find the test... Because of course the test itself isn't part of the stack at the teardown phase.

I guess this is the reason why there isn't a builder.create_external_file. I think as soon as there is some contextual things such as __file__ that won't quite work.

At some point I got it wrong and I returned something equivalent to

builder.create_list([{...}, {...}])

when I meant

builder.create_list([builder.create_dict({...}), builder.create_dict({...})])

The UsageError assertion in _get_handler caught the issue but I didn't find the error message quite helpful (maybe a skill issue on my part)

[15r10nk]

1. yes, I think I will have to rework this. I used a separate plugin manager because I plan to support unittests too, but this leads to other problems in the pytest context.

2. you did builder.create_call(function) and function always needs to find the test_* function in the trace when it is called, correct? I will look into it, because I think that this should already work. I'm not aware that I call the function in the tear down phase.

3. builder.create_list([{...}, {...}]) this should just work. The customize hook is called again when the result or parts of the result are no custom objects. I will also look into it maybe there is still some bug.

Thank you very much for testing it out, this early feedback is really valuable to me.

[15r10nk]

pytest enforces a pytest_* prefix for hooks when I want to use the pytest plugin manager. This makes no sense when I want to provide unittest support and keep it in general independent of pytest.
It would require that you call my hooks pytest_customize or something like this.
I think it is better to stay independent here.

But I have found some problems with the existing implementation which I will fix.
I think it will also be useful to be able to use normal functions in your conftest.py

@customize
def my_handler(value):
    ...

[qdewaghe]

Yeah, I suppose that it is possible to register an inline-snapshot plugin dynamically through a pytest plugin anyhow, if that's really needed.

I can confirm that the class is currently required in conftest.py whereas it must be removed in a plugin.

I can't reproduce 2. anymore, maybe the bug was on my end but here's an example for 3.

from inline_snapshot.plugin import Builder
from inline_snapshot.plugin import customize


class DataHolder:

    def __init__(self, data: list[dict[str, str]]):
        self.data = data

    def __eq__(self, other):
        if isinstance(other, DataHolder):
            return other.data == self.data

        if isinstance(other, list):
            return self.data == other

        return NotImplemented

    def __repr__(self) -> str:
        return f"{self.data!r}"


class InlineSnapshotPlugin:
    @customize
    def put_bigdata_in_file(self, value, builder: Builder):
        if not isinstance(value, DataHolder):
            return

        new = []

        for entry in value.data:
            new.append(
                # Removing this call to create_dict result in the following error
                # E inline_snapshot._exceptions.UsageError: Customized value does not match original value:
                # E
                # E original_value={'data': CustomExternal(value='very_bigdata', format=None, storage=None)}
                # E
                # E customized_value={'data': 'very_bigdata'}
                # E customized_representation=CustomDict(value={CustomCode("'data'"): CustomExternal(value='very_bigdata', format=None, storage=None)})
                builder.create_dict(
                    {
                        "data": builder.create_external(entry["data"]),
                    }
                )
            )

        return builder.create_list(new)

from inline_snapshot import snapshot
from .conftest import DataHolder


def test_data():
    assert DataHolder([{"data": "bigdata"}]) == snapshot()

I see that the error was improved. I'm still finding it confusing 😅

[qdewaghe]

Another fun one is trying to use create_code with the 3.14 template strings. They don't implement __eq__ https://peps.python.org/pep-0750/#overridden-eq-and-hash-for-template-and-interpolation

from string.templatelib import Template, Interpolation

from inline_snapshot.plugin import Builder, customize
from typing import Literal


def convert(value: object, conversion: Literal["a", "r", "s"] | None) -> object:
    if conversion == "a":
        return ascii(value)
    elif conversion == "r":
        return repr(value)
    elif conversion == "s":
        return str(value)
    return value


def f(template: Template) -> str:
    parts = []
    for item in template:
        match item:
            case str() as s:
                parts.append(s)
            case Interpolation(value, _, conversion, format_spec):
                value = convert(value, conversion)
                value = format(value, format_spec)
                parts.append(value)
    return "".join(parts)


class InlineSnapshotPlugin:

    @customize
    def tstr_handler(self, value, builder: Builder):
        if not isinstance(value, str):
            return

        return builder.create_call(f, [builder.create_code(f't"{value}"')])

from .conftest import f
from inline_snapshot import snapshot


def test_template():
    assert "c" == snapshot(f(t"b"))

By modifying inline-snapshot, it almost works:

diff --git a/src/inline_snapshot/_new_adapter.py b/src/inline_snapshot/_new_adapter.py
index f8456ba..54688cd 100644
--- a/src/inline_snapshot/_new_adapter.py
+++ b/src/inline_snapshot/_new_adapter.py
@@ -5,6 +5,7 @@ import warnings
 from collections import defaultdict
 from typing import Generator
 from typing import Sequence
+from string.templatelib import Template

 from inline_snapshot._adapter_context import AdapterContext
 from inline_snapshot._align import add_x
@@ -197,7 +198,13 @@ class NewAdapter:
                 )
             return old_value

-        if not old_value._eval() == new_value.original_value:
+        import sys
+
+        is_template_str = sys.version_info >= (3, 14) and isinstance(
+            old_node, ast.TemplateStr
+        )
+
+        if is_template_str or (old_value._eval() == new_value.original_value):
             if isinstance(old_value, CustomUndefined):
                 flag = "create"
             else:
diff --git a/src/inline_snapshot/_utils.py b/src/inline_snapshot/_utils.py
index 0ba4027..64810b7 100644
--- a/src/inline_snapshot/_utils.py
+++ b/src/inline_snapshot/_utils.py
@@ -150,6 +150,7 @@ class simple_token(namedtuple("simple_token", "type,string")):

 def clone(obj):
     new = copy.deepcopy(obj)
+    return new
     if not obj == new:
         raise UsageError(
             f"""\

Almost because asttokens does not return quite the right range for the template string.