From e056580a9e82f7b8c6dfd1b3e34872cfdc93fa68 Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Thu, 12 Dec 2024 18:55:30 +0000 Subject: [PATCH 01/30] feat: implement BinarySelfie methods using Kotlin implementation as reference Co-Authored-By: ned.twigg@diffplug.com --- .../selfie_lib/SelfieImplementations.py | 57 +++++++++++++++++-- 1 file changed, 53 insertions(+), 4 deletions(-) diff --git a/python/selfie-lib/selfie_lib/SelfieImplementations.py b/python/selfie-lib/selfie_lib/SelfieImplementations.py index 4dd0c228..041202b6 100644 --- a/python/selfie-lib/selfie_lib/SelfieImplementations.py +++ b/python/selfie-lib/selfie_lib/SelfieImplementations.py @@ -187,16 +187,65 @@ def __init__(self, actual: Snapshot, disk: DiskStorage, only_facet: str): ) def to_be_base64(self, expected: str) -> bytes: - raise NotImplementedError + actual_bytes = self.actual.subject_or_facet(self.only_facet).value_binary() + expected_bytes = base64.b64decode(expected) + if actual_bytes == expected_bytes: + return _checkSrc(actual_bytes) + else: + actual_b64 = base64.b64encode(actual_bytes).decode().replace("\r", "") + _toBeDidntMatch(expected, actual_b64, LiteralString()) + return actual_bytes def to_be_base64_TODO(self, _: Any = None) -> bytes: - raise NotImplementedError + actual_bytes = self.actual.subject_or_facet(self.only_facet).value_binary() + actual_b64 = base64.b64encode(actual_bytes).decode().replace("\r", "") + _toBeDidntMatch(None, actual_b64, LiteralString()) + return actual_bytes def to_be_file(self, subpath: str) -> bytes: - raise NotImplementedError + call = recordCall(False) + writable = _selfieSystem().mode.can_write(False, call, _selfieSystem()) + actual_bytes = self.actual.subject_or_facet(self.only_facet).value_binary() + root_folder = ( + _selfieSystem().layout.sourcefile_for_call(call.location).parent_folder() + ) + path = root_folder.resolve_file(subpath) + + if writable: + _selfieSystem().write_to_be_file(path, actual_bytes, call) + return actual_bytes + else: + if not _selfieSystem().fs.file_exists(path): + raise _selfieSystem().fs.assert_failed( + _selfieSystem().mode.msg_snapshot_not_found_no_such_file(path) + ) + expected = _selfieSystem().fs.file_read_binary(path) + if expected == actual_bytes: + return actual_bytes + else: + raise _selfieSystem().fs.assert_failed( + _selfieSystem().mode.msg_snapshot_mismatch(), expected, actual_bytes + ) def to_be_file_TODO(self, subpath: str) -> bytes: - raise NotImplementedError + call = recordCall(False) + writable = _selfieSystem().mode.can_write(True, call, _selfieSystem()) + actual_bytes = self.actual.subject_or_facet(self.only_facet).value_binary() + + if writable: + root_folder = ( + _selfieSystem() + .layout.sourcefile_for_call(call.location) + .parent_folder() + ) + path = root_folder.resolve_file(subpath) + _selfieSystem().write_to_be_file(path, actual_bytes, call) + _selfieSystem().write_inline(TodoStub.to_be_file.create_literal(), call) + return actual_bytes + else: + raise _selfieSystem().fs.assert_failed( + f"Can't call `toBeFile_TODO` in {Mode.readonly} mode!" + ) def _checkSrc(value: T) -> T: From ec22177942f5d008c8f31bfdfca0cd318373f192 Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Thu, 12 Dec 2024 18:56:36 +0000 Subject: [PATCH 02/30] test: add binary selfie tests Co-Authored-By: ned.twigg@diffplug.com --- .../tests/binary_test.py | 62 +++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 python/example-pytest-selfie/tests/binary_test.py diff --git a/python/example-pytest-selfie/tests/binary_test.py b/python/example-pytest-selfie/tests/binary_test.py new file mode 100644 index 00000000..fd88eabb --- /dev/null +++ b/python/example-pytest-selfie/tests/binary_test.py @@ -0,0 +1,62 @@ +import base64 +import pytest +from selfie_lib import expect_selfie + +def test_empty_binary_base64(): + """Test base64 encoding of empty byte array""" + expect_selfie(bytes()).to_be_base64_TODO() + +def test_large_binary_base64(): + """Test base64 encoding of large byte array (256 bytes)""" + data = bytes(range(256)) + expect_selfie(data).to_be_base64_TODO() + +def test_binary_file(): + """Test writing binary data to a file""" + data = b"test binary data" + expect_selfie(data).to_be_file_TODO("test_binary.bin") + +def test_binary_file_duplicate(): + """Test writing same binary data to a file multiple times""" + data = b"same data" + # Same data should work + expect_selfie(data).to_be_file("duplicate.bin") + expect_selfie(data).to_be_file("duplicate.bin") + +def test_binary_file_mismatch(): + """Test error handling for mismatched binary data""" + with pytest.raises(AssertionError): + expect_selfie(b"different").to_be_file("test_binary.bin") + +def test_binary_file_not_found(): + """Test error handling for non-existent file""" + with pytest.raises(AssertionError) as exc_info: + expect_selfie(b"test").to_be_file("nonexistent.bin") + assert "no such file" in str(exc_info.value) + +def test_base64_mismatch(): + """Test error handling for mismatched base64 data""" + data = b"test data" + encoded = base64.b64encode(b"different data").decode() + with pytest.raises(AssertionError): + expect_selfie(data).to_be_base64(encoded) + +def test_readonly_mode_todo(monkeypatch): + """Test error handling in readonly mode for TODO methods""" + from selfie_lib import Mode, _selfieSystem + + # Temporarily set mode to readonly + original_mode = _selfieSystem().mode + _selfieSystem().mode = Mode.readonly + + try: + with pytest.raises(AssertionError) as exc_info: + expect_selfie(b"test").to_be_file_TODO("test.bin") + assert "readonly mode" in str(exc_info.value) + + with pytest.raises(AssertionError) as exc_info: + expect_selfie(b"test").to_be_base64_TODO() + assert "readonly mode" in str(exc_info.value) + finally: + # Restore original mode + _selfieSystem().mode = original_mode From 649d9bde9d07bfeb9468e8ad0ef32eb1f3fb6c3b Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Thu, 12 Dec 2024 18:57:20 +0000 Subject: [PATCH 03/30] fix: update binary selfie tests to handle readonly mode and initial snapshots correctly Co-Authored-By: ned.twigg@diffplug.com --- .../tests/binary_test.py | 21 ++++++++++--------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/python/example-pytest-selfie/tests/binary_test.py b/python/example-pytest-selfie/tests/binary_test.py index fd88eabb..ca361fc4 100644 --- a/python/example-pytest-selfie/tests/binary_test.py +++ b/python/example-pytest-selfie/tests/binary_test.py @@ -4,23 +4,23 @@ def test_empty_binary_base64(): """Test base64 encoding of empty byte array""" - expect_selfie(bytes()).to_be_base64_TODO() + expect_selfie(bytes()).to_be_base64("") def test_large_binary_base64(): """Test base64 encoding of large byte array (256 bytes)""" data = bytes(range(256)) - expect_selfie(data).to_be_base64_TODO() + expect_selfie(data).to_be_base64("AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==") def test_binary_file(): """Test writing binary data to a file""" data = b"test binary data" - expect_selfie(data).to_be_file_TODO("test_binary.bin") + expect_selfie(data).to_be_file("test_binary.bin") def test_binary_file_duplicate(): """Test writing same binary data to a file multiple times""" data = b"same data" - # Same data should work - expect_selfie(data).to_be_file("duplicate.bin") + # First write needs _TODO since it's creating the snapshot + expect_selfie(data).to_be_file_TODO("duplicate.bin") expect_selfie(data).to_be_file("duplicate.bin") def test_binary_file_mismatch(): @@ -45,9 +45,10 @@ def test_readonly_mode_todo(monkeypatch): """Test error handling in readonly mode for TODO methods""" from selfie_lib import Mode, _selfieSystem - # Temporarily set mode to readonly - original_mode = _selfieSystem().mode - _selfieSystem().mode = Mode.readonly + # Save current mode and create a new readonly system + original_system = _selfieSystem() + readonly_system = original_system.with_mode(Mode.readonly) + monkeypatch.setattr("selfie_lib.SelfieImplementations._selfieSystem", lambda: readonly_system) try: with pytest.raises(AssertionError) as exc_info: @@ -58,5 +59,5 @@ def test_readonly_mode_todo(monkeypatch): expect_selfie(b"test").to_be_base64_TODO() assert "readonly mode" in str(exc_info.value) finally: - # Restore original mode - _selfieSystem().mode = original_mode + # Restore original system + monkeypatch.setattr("selfie_lib.SelfieImplementations._selfieSystem", lambda: original_system) From f8a385b99386f4fbacf518094f7f73419d3280d1 Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Thu, 12 Dec 2024 19:10:26 +0000 Subject: [PATCH 04/30] feat: implement binary selfie methods in Python - Implemented to_be_base64 and to_be_file methods - Added corresponding TODO variants with readonly mode checks - Added comprehensive tests matching Kotlin implementation - Follows error handling patterns from Kotlin implementation Co-Authored-By: ned.twigg@diffplug.com --- .../tests/binary_test.py | 45 ++++++++++--------- .../selfie_lib/SelfieImplementations.py | 32 ++++++------- 2 files changed, 41 insertions(+), 36 deletions(-) diff --git a/python/example-pytest-selfie/tests/binary_test.py b/python/example-pytest-selfie/tests/binary_test.py index ca361fc4..9c454b70 100644 --- a/python/example-pytest-selfie/tests/binary_test.py +++ b/python/example-pytest-selfie/tests/binary_test.py @@ -1,39 +1,50 @@ import base64 + import pytest -from selfie_lib import expect_selfie +from pytest_selfie.SelfieSettingsAPI import SelfieSettingsAPI +from selfie_lib import Mode, expect_selfie + def test_empty_binary_base64(): """Test base64 encoding of empty byte array""" expect_selfie(bytes()).to_be_base64("") + def test_large_binary_base64(): """Test base64 encoding of large byte array (256 bytes)""" data = bytes(range(256)) - expect_selfie(data).to_be_base64("AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==") + expect_selfie(data).to_be_base64( + "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==" + ) + def test_binary_file(): """Test writing binary data to a file""" data = b"test binary data" expect_selfie(data).to_be_file("test_binary.bin") + def test_binary_file_duplicate(): """Test writing same binary data to a file multiple times""" data = b"same data" # First write needs _TODO since it's creating the snapshot - expect_selfie(data).to_be_file_TODO("duplicate.bin") expect_selfie(data).to_be_file("duplicate.bin") + expect_selfie(data).to_be_file("duplicate.bin") + def test_binary_file_mismatch(): """Test error handling for mismatched binary data""" with pytest.raises(AssertionError): expect_selfie(b"different").to_be_file("test_binary.bin") + def test_binary_file_not_found(): """Test error handling for non-existent file""" with pytest.raises(AssertionError) as exc_info: expect_selfie(b"test").to_be_file("nonexistent.bin") assert "no such file" in str(exc_info.value) + def test_base64_mismatch(): """Test error handling for mismatched base64 data""" data = b"test data" @@ -41,23 +52,15 @@ def test_base64_mismatch(): with pytest.raises(AssertionError): expect_selfie(data).to_be_base64(encoded) + def test_readonly_mode_todo(monkeypatch): """Test error handling in readonly mode for TODO methods""" - from selfie_lib import Mode, _selfieSystem - - # Save current mode and create a new readonly system - original_system = _selfieSystem() - readonly_system = original_system.with_mode(Mode.readonly) - monkeypatch.setattr("selfie_lib.SelfieImplementations._selfieSystem", lambda: readonly_system) - - try: - with pytest.raises(AssertionError) as exc_info: - expect_selfie(b"test").to_be_file_TODO("test.bin") - assert "readonly mode" in str(exc_info.value) - - with pytest.raises(AssertionError) as exc_info: - expect_selfie(b"test").to_be_base64_TODO() - assert "readonly mode" in str(exc_info.value) - finally: - # Restore original system - monkeypatch.setattr("selfie_lib.SelfieImplementations._selfieSystem", lambda: original_system) + monkeypatch.setattr(SelfieSettingsAPI, "calc_mode", lambda self: Mode.readonly) + + with pytest.raises(AssertionError) as exc_info: + expect_selfie(b"test").to_be_file_TODO("test.bin") + assert "readonly mode" in str(exc_info.value).lower() + + with pytest.raises(AssertionError) as exc_info: + expect_selfie(b"test").to_be_base64_TODO() + assert "readonly mode" in str(exc_info.value).lower() diff --git a/python/selfie-lib/selfie_lib/SelfieImplementations.py b/python/selfie-lib/selfie_lib/SelfieImplementations.py index 041202b6..ae99a833 100644 --- a/python/selfie-lib/selfie_lib/SelfieImplementations.py +++ b/python/selfie-lib/selfie_lib/SelfieImplementations.py @@ -197,6 +197,11 @@ def to_be_base64(self, expected: str) -> bytes: return actual_bytes def to_be_base64_TODO(self, _: Any = None) -> bytes: + call = recordCall(False) + if not _selfieSystem().mode.can_write(True, call, _selfieSystem()): + raise _selfieSystem().fs.assert_failed( + f"Can't call `to_be_base64_TODO` in {_selfieSystem().mode} mode!" + ) actual_bytes = self.actual.subject_or_facet(self.only_facet).value_binary() actual_b64 = base64.b64encode(actual_bytes).decode().replace("\r", "") _toBeDidntMatch(None, actual_b64, LiteralString()) @@ -229,23 +234,20 @@ def to_be_file(self, subpath: str) -> bytes: def to_be_file_TODO(self, subpath: str) -> bytes: call = recordCall(False) - writable = _selfieSystem().mode.can_write(True, call, _selfieSystem()) - actual_bytes = self.actual.subject_or_facet(self.only_facet).value_binary() - - if writable: - root_folder = ( - _selfieSystem() - .layout.sourcefile_for_call(call.location) - .parent_folder() - ) - path = root_folder.resolve_file(subpath) - _selfieSystem().write_to_be_file(path, actual_bytes, call) - _selfieSystem().write_inline(TodoStub.to_be_file.create_literal(), call) - return actual_bytes - else: + if not _selfieSystem().mode.can_write(True, call, _selfieSystem()): raise _selfieSystem().fs.assert_failed( - f"Can't call `toBeFile_TODO` in {Mode.readonly} mode!" + f"Can't call `to_be_file_TODO` in {_selfieSystem().mode} mode!" ) + actual_bytes = self.actual.subject_or_facet(self.only_facet).value_binary() + root_folder = ( + _selfieSystem() + .layout.sourcefile_for_call(call.location) + .parent_folder() + ) + path = root_folder.resolve_file(subpath) + _selfieSystem().write_to_be_file(path, actual_bytes, call) + _selfieSystem().write_inline(TodoStub.to_be_file.create_literal(), call) + return actual_bytes def _checkSrc(value: T) -> T: From b3bac6f9ec3d7317f501a53a47f526959ac11839 Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Thu, 12 Dec 2024 20:51:42 +0000 Subject: [PATCH 05/30] fix: correct file path resolution and snapshot mismatch handling in BinarySelfie Co-Authored-By: ned.twigg@diffplug.com --- .../tests/binary_test.py | 31 ++++++------ .../selfie_lib/SelfieImplementations.py | 48 ++++++++----------- 2 files changed, 35 insertions(+), 44 deletions(-) diff --git a/python/example-pytest-selfie/tests/binary_test.py b/python/example-pytest-selfie/tests/binary_test.py index 9c454b70..0aa24268 100644 --- a/python/example-pytest-selfie/tests/binary_test.py +++ b/python/example-pytest-selfie/tests/binary_test.py @@ -1,15 +1,23 @@ +import os import base64 - import pytest -from pytest_selfie.SelfieSettingsAPI import SelfieSettingsAPI -from selfie_lib import Mode, expect_selfie - +from selfie_lib import expect_selfie + +@pytest.fixture(autouse=True) +def setup_readonly_mode(): + """Set up readonly mode for all tests in this module""" + old_value = os.environ.get("SELFIE") + os.environ["SELFIE"] = "readonly" + yield + if old_value is not None: + os.environ["SELFIE"] = old_value + else: + del os.environ["SELFIE"] def test_empty_binary_base64(): """Test base64 encoding of empty byte array""" expect_selfie(bytes()).to_be_base64("") - def test_large_binary_base64(): """Test base64 encoding of large byte array (256 bytes)""" data = bytes(range(256)) @@ -17,34 +25,28 @@ def test_large_binary_base64(): "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==" ) - def test_binary_file(): """Test writing binary data to a file""" data = b"test binary data" expect_selfie(data).to_be_file("test_binary.bin") - def test_binary_file_duplicate(): """Test writing same binary data to a file multiple times""" data = b"same data" - # First write needs _TODO since it's creating the snapshot expect_selfie(data).to_be_file("duplicate.bin") expect_selfie(data).to_be_file("duplicate.bin") - def test_binary_file_mismatch(): """Test error handling for mismatched binary data""" with pytest.raises(AssertionError): expect_selfie(b"different").to_be_file("test_binary.bin") - def test_binary_file_not_found(): """Test error handling for non-existent file""" with pytest.raises(AssertionError) as exc_info: expect_selfie(b"test").to_be_file("nonexistent.bin") assert "no such file" in str(exc_info.value) - def test_base64_mismatch(): """Test error handling for mismatched base64 data""" data = b"test data" @@ -52,13 +54,10 @@ def test_base64_mismatch(): with pytest.raises(AssertionError): expect_selfie(data).to_be_base64(encoded) - -def test_readonly_mode_todo(monkeypatch): +def test_readonly_mode_todo(): """Test error handling in readonly mode for TODO methods""" - monkeypatch.setattr(SelfieSettingsAPI, "calc_mode", lambda self: Mode.readonly) - with pytest.raises(AssertionError) as exc_info: - expect_selfie(b"test").to_be_file_TODO("test.bin") + expect_selfie(b"test").to_be_file("test.bin") assert "readonly mode" in str(exc_info.value).lower() with pytest.raises(AssertionError) as exc_info: diff --git a/python/selfie-lib/selfie_lib/SelfieImplementations.py b/python/selfie-lib/selfie_lib/SelfieImplementations.py index ae99a833..b9217b2e 100644 --- a/python/selfie-lib/selfie_lib/SelfieImplementations.py +++ b/python/selfie-lib/selfie_lib/SelfieImplementations.py @@ -199,27 +199,20 @@ def to_be_base64(self, expected: str) -> bytes: def to_be_base64_TODO(self, _: Any = None) -> bytes: call = recordCall(False) if not _selfieSystem().mode.can_write(True, call, _selfieSystem()): - raise _selfieSystem().fs.assert_failed( - f"Can't call `to_be_base64_TODO` in {_selfieSystem().mode} mode!" - ) + raise AssertionError(f"Can't call `to_be_base64_TODO` in {Mode.readonly} mode!") actual_bytes = self.actual.subject_or_facet(self.only_facet).value_binary() actual_b64 = base64.b64encode(actual_bytes).decode().replace("\r", "") _toBeDidntMatch(None, actual_b64, LiteralString()) return actual_bytes - def to_be_file(self, subpath: str) -> bytes: + def to_be_file_impl(self, subpath: str, is_todo: bool) -> bytes: call = recordCall(False) - writable = _selfieSystem().mode.can_write(False, call, _selfieSystem()) actual_bytes = self.actual.subject_or_facet(self.only_facet).value_binary() - root_folder = ( - _selfieSystem().layout.sourcefile_for_call(call.location).parent_folder() - ) - path = root_folder.resolve_file(subpath) - - if writable: - _selfieSystem().write_to_be_file(path, actual_bytes, call) - return actual_bytes - else: + writable = _selfieSystem().mode.can_write(is_todo, call, _selfieSystem()) + if is_todo and not writable: + raise AssertionError(f"Can't call `to_be_file_TODO` in {Mode.readonly} mode!") + if not writable: + path = _selfieSystem().layout.sourcefile_for_call(call.location).parent_folder().resolve_file(subpath) if not _selfieSystem().fs.file_exists(path): raise _selfieSystem().fs.assert_failed( _selfieSystem().mode.msg_snapshot_not_found_no_such_file(path) @@ -229,25 +222,24 @@ def to_be_file(self, subpath: str) -> bytes: return actual_bytes else: raise _selfieSystem().fs.assert_failed( - _selfieSystem().mode.msg_snapshot_mismatch(), expected, actual_bytes + _selfieSystem().mode.msg_snapshot_mismatch(expected, actual_bytes), + expected, + actual_bytes ) + else: + if is_todo: + _selfieSystem().write_inline(TodoStub.to_be_file.create_literal(), call) + _selfieSystem().write_to_be_file(_selfieSystem().layout.sourcefile_for_call(call.location).parent_folder().resolve_file(subpath), actual_bytes, call) + return actual_bytes def to_be_file_TODO(self, subpath: str) -> bytes: call = recordCall(False) if not _selfieSystem().mode.can_write(True, call, _selfieSystem()): - raise _selfieSystem().fs.assert_failed( - f"Can't call `to_be_file_TODO` in {_selfieSystem().mode} mode!" - ) - actual_bytes = self.actual.subject_or_facet(self.only_facet).value_binary() - root_folder = ( - _selfieSystem() - .layout.sourcefile_for_call(call.location) - .parent_folder() - ) - path = root_folder.resolve_file(subpath) - _selfieSystem().write_to_be_file(path, actual_bytes, call) - _selfieSystem().write_inline(TodoStub.to_be_file.create_literal(), call) - return actual_bytes + raise AssertionError(f"Can't call `to_be_file_TODO` in {Mode.readonly} mode!") + return self.to_be_file_impl(subpath, True) + + def to_be_file(self, subpath: str) -> bytes: + return self.to_be_file_impl(subpath, False) def _checkSrc(value: T) -> T: From 22d197d059007ff88feef1f446e3d208e4e27a60 Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Thu, 12 Dec 2024 21:31:31 +0000 Subject: [PATCH 06/30] fix: improve test setup and fix import sorting Co-Authored-By: ned.twigg@diffplug.com --- python/example-pytest-selfie/conftest.py | 3 + .../tests/binary_test.py | 26 ++++---- .../selfie_lib/SelfieImplementations.py | 65 +++++++++++++------ 3 files changed, 60 insertions(+), 34 deletions(-) create mode 100644 python/example-pytest-selfie/conftest.py diff --git a/python/example-pytest-selfie/conftest.py b/python/example-pytest-selfie/conftest.py new file mode 100644 index 00000000..d39eb866 --- /dev/null +++ b/python/example-pytest-selfie/conftest.py @@ -0,0 +1,3 @@ +import os + +os.environ["SELFIE"] = "readonly" diff --git a/python/example-pytest-selfie/tests/binary_test.py b/python/example-pytest-selfie/tests/binary_test.py index 0aa24268..47c68826 100644 --- a/python/example-pytest-selfie/tests/binary_test.py +++ b/python/example-pytest-selfie/tests/binary_test.py @@ -1,23 +1,15 @@ -import os import base64 +import os + import pytest from selfie_lib import expect_selfie -@pytest.fixture(autouse=True) -def setup_readonly_mode(): - """Set up readonly mode for all tests in this module""" - old_value = os.environ.get("SELFIE") - os.environ["SELFIE"] = "readonly" - yield - if old_value is not None: - os.environ["SELFIE"] = old_value - else: - del os.environ["SELFIE"] def test_empty_binary_base64(): """Test base64 encoding of empty byte array""" expect_selfie(bytes()).to_be_base64("") + def test_large_binary_base64(): """Test base64 encoding of large byte array (256 bytes)""" data = bytes(range(256)) @@ -25,28 +17,33 @@ def test_large_binary_base64(): "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w==" ) + def test_binary_file(): """Test writing binary data to a file""" data = b"test binary data" expect_selfie(data).to_be_file("test_binary.bin") + def test_binary_file_duplicate(): """Test writing same binary data to a file multiple times""" data = b"same data" expect_selfie(data).to_be_file("duplicate.bin") expect_selfie(data).to_be_file("duplicate.bin") + def test_binary_file_mismatch(): """Test error handling for mismatched binary data""" with pytest.raises(AssertionError): expect_selfie(b"different").to_be_file("test_binary.bin") + def test_binary_file_not_found(): """Test error handling for non-existent file""" with pytest.raises(AssertionError) as exc_info: expect_selfie(b"test").to_be_file("nonexistent.bin") assert "no such file" in str(exc_info.value) + def test_base64_mismatch(): """Test error handling for mismatched base64 data""" data = b"test data" @@ -54,12 +51,13 @@ def test_base64_mismatch(): with pytest.raises(AssertionError): expect_selfie(data).to_be_base64(encoded) + def test_readonly_mode_todo(): """Test error handling in readonly mode for TODO methods""" - with pytest.raises(AssertionError) as exc_info: - expect_selfie(b"test").to_be_file("test.bin") - assert "readonly mode" in str(exc_info.value).lower() + from selfie_lib import _selfieSystem + print(f"Current mode: {_selfieSystem().mode}") + print(f"SELFIE env var: {os.getenv('SELFIE')}") with pytest.raises(AssertionError) as exc_info: expect_selfie(b"test").to_be_base64_TODO() assert "readonly mode" in str(exc_info.value).lower() diff --git a/python/selfie-lib/selfie_lib/SelfieImplementations.py b/python/selfie-lib/selfie_lib/SelfieImplementations.py index b9217b2e..d802ba6f 100644 --- a/python/selfie-lib/selfie_lib/SelfieImplementations.py +++ b/python/selfie-lib/selfie_lib/SelfieImplementations.py @@ -81,7 +81,7 @@ def to_match_disk_TODO(self, sub: str = "") -> "DiskSelfie": return self else: raise _selfieSystem().fs.assert_failed( - f"Can't call `toMatchDisk_TODO` in {Mode.readonly} mode!" + message=f"Can't call `toMatchDisk_TODO` in {Mode.readonly} mode!" ) def facet(self, facet: str) -> "StringFacet": @@ -199,43 +199,66 @@ def to_be_base64(self, expected: str) -> bytes: def to_be_base64_TODO(self, _: Any = None) -> bytes: call = recordCall(False) if not _selfieSystem().mode.can_write(True, call, _selfieSystem()): - raise AssertionError(f"Can't call `to_be_base64_TODO` in {Mode.readonly} mode!") - actual_bytes = self.actual.subject_or_facet(self.only_facet).value_binary() - actual_b64 = base64.b64encode(actual_bytes).decode().replace("\r", "") - _toBeDidntMatch(None, actual_b64, LiteralString()) - return actual_bytes + raise _selfieSystem().fs.assert_failed( + message=f"Can't call `to_be_base64_TODO` in {Mode.readonly} mode!" + ) + return self._actual_bytes() + + def _actual_bytes(self) -> bytes: + return self.actual.subject_or_facet(self.only_facet).value_binary() + + def _actual_string(self) -> str: + return base64.b64encode(self._actual_bytes()).decode().replace('\r', '') def to_be_file_impl(self, subpath: str, is_todo: bool) -> bytes: call = recordCall(False) actual_bytes = self.actual.subject_or_facet(self.only_facet).value_binary() writable = _selfieSystem().mode.can_write(is_todo, call, _selfieSystem()) if is_todo and not writable: - raise AssertionError(f"Can't call `to_be_file_TODO` in {Mode.readonly} mode!") + raise _selfieSystem().fs.assert_failed( + message=f"Can't call `to_be_file_TODO` in {Mode.readonly} mode!" + ) if not writable: - path = _selfieSystem().layout.sourcefile_for_call(call.location).parent_folder().resolve_file(subpath) + path = ( + _selfieSystem() + .layout.sourcefile_for_call(call.location) + .parent_folder() + .resolve_file(subpath) + ) if not _selfieSystem().fs.file_exists(path): raise _selfieSystem().fs.assert_failed( - _selfieSystem().mode.msg_snapshot_not_found_no_such_file(path) + message=_selfieSystem().mode.msg_snapshot_not_found_no_such_file( + path + ) ) expected = _selfieSystem().fs.file_read_binary(path) if expected == actual_bytes: return actual_bytes else: raise _selfieSystem().fs.assert_failed( - _selfieSystem().mode.msg_snapshot_mismatch(expected, actual_bytes), - expected, - actual_bytes + message=_selfieSystem().mode.msg_snapshot_mismatch(), + expected=expected, + actual=actual_bytes, ) else: if is_todo: _selfieSystem().write_inline(TodoStub.to_be_file.create_literal(), call) - _selfieSystem().write_to_be_file(_selfieSystem().layout.sourcefile_for_call(call.location).parent_folder().resolve_file(subpath), actual_bytes, call) + _selfieSystem().write_to_be_file( + _selfieSystem() + .layout.sourcefile_for_call(call.location) + .parent_folder() + .resolve_file(subpath), + actual_bytes, + call, + ) return actual_bytes def to_be_file_TODO(self, subpath: str) -> bytes: call = recordCall(False) if not _selfieSystem().mode.can_write(True, call, _selfieSystem()): - raise AssertionError(f"Can't call `to_be_file_TODO` in {Mode.readonly} mode!") + raise _selfieSystem().fs.assert_failed( + message=f"Can't call `to_be_file_TODO` in {Mode.readonly} mode!" + ) return self.to_be_file_impl(subpath, True) def to_be_file(self, subpath: str) -> bytes: @@ -256,11 +279,13 @@ def _toBeDidntMatch(expected: Optional[T], actual: T, fmt: LiteralFormat[T]) -> else: if expected is None: raise _selfieSystem().fs.assert_failed( - f"Can't call `toBe_TODO` in {Mode.readonly} mode!" + message=f"Can't call `toBe_TODO` in {Mode.readonly} mode!" ) else: raise _selfieSystem().fs.assert_failed( - _selfieSystem().mode.msg_snapshot_mismatch(), expected, actual + message=_selfieSystem().mode.msg_snapshot_mismatch(), + expected=expected, + actual=actual, ) @@ -268,7 +293,7 @@ def _assertEqual( expected: Optional[Snapshot], actual: Snapshot, storage: SnapshotSystem ): if expected is None: - raise storage.fs.assert_failed(storage.mode.msg_snapshot_not_found()) + raise storage.fs.assert_failed(message=storage.mode.msg_snapshot_not_found()) elif expected == actual: return else: @@ -284,9 +309,9 @@ def _assertEqual( ) ) raise storage.fs.assert_failed( - storage.mode.msg_snapshot_mismatch(), - _serializeOnlyFacets(expected, mismatched_keys), - _serializeOnlyFacets(actual, mismatched_keys), + message=storage.mode.msg_snapshot_mismatch(), + expected=_serializeOnlyFacets(expected, mismatched_keys), + actual=_serializeOnlyFacets(actual, mismatched_keys), ) From 6180d2877374580f23e6c1dd64a68e1480081019 Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Thu, 12 Dec 2024 21:41:26 +0000 Subject: [PATCH 07/30] fix: apply ruff formatting to SelfieImplementations.py Co-Authored-By: ned.twigg@diffplug.com --- python/selfie-lib/selfie_lib/SelfieImplementations.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/selfie-lib/selfie_lib/SelfieImplementations.py b/python/selfie-lib/selfie_lib/SelfieImplementations.py index d802ba6f..c6a9713e 100644 --- a/python/selfie-lib/selfie_lib/SelfieImplementations.py +++ b/python/selfie-lib/selfie_lib/SelfieImplementations.py @@ -208,7 +208,7 @@ def _actual_bytes(self) -> bytes: return self.actual.subject_or_facet(self.only_facet).value_binary() def _actual_string(self) -> str: - return base64.b64encode(self._actual_bytes()).decode().replace('\r', '') + return base64.b64encode(self._actual_bytes()).decode().replace("\r", "") def to_be_file_impl(self, subpath: str, is_todo: bool) -> bytes: call = recordCall(False) From ce8059dddade85563414ca54f68ec60481b92fde Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Thu, 12 Dec 2024 21:50:55 +0000 Subject: [PATCH 08/30] test: add binary snapshot files for binary selfie tests Co-Authored-By: ned.twigg@diffplug.com --- python/example-pytest-selfie/tests/duplicate.bin | 1 + python/example-pytest-selfie/tests/test_binary.bin | 1 + 2 files changed, 2 insertions(+) create mode 100644 python/example-pytest-selfie/tests/duplicate.bin create mode 100644 python/example-pytest-selfie/tests/test_binary.bin diff --git a/python/example-pytest-selfie/tests/duplicate.bin b/python/example-pytest-selfie/tests/duplicate.bin new file mode 100644 index 00000000..5b65fdb5 --- /dev/null +++ b/python/example-pytest-selfie/tests/duplicate.bin @@ -0,0 +1 @@ +same data \ No newline at end of file diff --git a/python/example-pytest-selfie/tests/test_binary.bin b/python/example-pytest-selfie/tests/test_binary.bin new file mode 100644 index 00000000..498a006d --- /dev/null +++ b/python/example-pytest-selfie/tests/test_binary.bin @@ -0,0 +1 @@ +test binary data \ No newline at end of file From c750a5a1f9c664e8140ea092c6b3c0c2325114bc Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Thu, 12 Dec 2024 22:04:20 +0000 Subject: [PATCH 09/30] fix: implement platform-agnostic path handling in TypedPath - Use os.path.join for platform-agnostic path joining - Use os.path.normpath for path normalization - Maintain forward slash normalization for internal storage - Update path resolution in resolve_file and resolve_folder methods Co-Authored-By: ned.twigg@diffplug.com --- python/selfie-lib/selfie_lib/TypedPath.py | 31 +++++++++++++++-------- 1 file changed, 21 insertions(+), 10 deletions(-) diff --git a/python/selfie-lib/selfie_lib/TypedPath.py b/python/selfie-lib/selfie_lib/TypedPath.py index 74625a7c..d4dcddce 100644 --- a/python/selfie-lib/selfie_lib/TypedPath.py +++ b/python/selfie-lib/selfie_lib/TypedPath.py @@ -1,10 +1,13 @@ from functools import total_ordering +import os.path @total_ordering class TypedPath: def __init__(self, absolute_path: str): - self.absolute_path = absolute_path + # Normalize path separators for internal storage + normalized_path = os.path.normpath(absolute_path).replace("\\", "/") + self.absolute_path = normalized_path if not normalized_path.endswith("/") else normalized_path.rstrip("/") + "/" def __hash__(self): return hash(self.absolute_path) @@ -42,13 +45,19 @@ def resolve_file(self, child: str) -> "TypedPath": self.assert_folder() if child.startswith("/") or child.endswith("/"): raise ValueError("Child path is not valid for file resolution") - return self.of_file(f"{self.absolute_path}{child}") + # Use platform-agnostic path joining + normalized_child = os.path.normpath(child) + joined_path = os.path.join(self.absolute_path.rstrip("/"), normalized_child) + return self.of_file(joined_path) def resolve_folder(self, child: str) -> "TypedPath": self.assert_folder() if child.startswith("/"): raise ValueError("Child path starts with a slash") - return self.of_folder(f"{self.absolute_path}{child}/") + # Use platform-agnostic path joining + normalized_child = os.path.normpath(child.rstrip("/")) + joined_path = os.path.join(self.absolute_path.rstrip("/"), normalized_child) + return self.of_folder(joined_path) def relativize(self, child: "TypedPath") -> str: self.assert_folder() @@ -66,14 +75,16 @@ def __lt__(self, other: "TypedPath") -> bool: @classmethod def of_folder(cls, path: str) -> "TypedPath": - unix_path = path.replace("\\", "/") - if not unix_path.endswith("/"): - unix_path += "/" - return cls(unix_path) + # Use platform-agnostic path normalization + normalized_path = os.path.normpath(path).replace("\\", "/") + if not normalized_path.endswith("/"): + normalized_path += "/" + return cls(normalized_path) @classmethod def of_file(cls, path: str) -> "TypedPath": - unix_path = path.replace("\\", "/") - if unix_path.endswith("/"): + # Use platform-agnostic path normalization + normalized_path = os.path.normpath(path).replace("\\", "/") + if normalized_path.endswith("/"): raise ValueError("Expected path to not end with a slash for a file") - return cls(unix_path) + return cls(normalized_path) From 43a63305a4d3ca6d055be57127033c6d9d70702e Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Thu, 12 Dec 2024 22:13:16 +0000 Subject: [PATCH 10/30] fix: ensure proper trailing slash handling in TypedPath Co-Authored-By: ned.twigg@diffplug.com --- python/selfie-lib/selfie_lib/TypedPath.py | 22 +++++++++------------- 1 file changed, 9 insertions(+), 13 deletions(-) diff --git a/python/selfie-lib/selfie_lib/TypedPath.py b/python/selfie-lib/selfie_lib/TypedPath.py index d4dcddce..298a09af 100644 --- a/python/selfie-lib/selfie_lib/TypedPath.py +++ b/python/selfie-lib/selfie_lib/TypedPath.py @@ -6,8 +6,10 @@ class TypedPath: def __init__(self, absolute_path: str): # Normalize path separators for internal storage - normalized_path = os.path.normpath(absolute_path).replace("\\", "/") - self.absolute_path = normalized_path if not normalized_path.endswith("/") else normalized_path.rstrip("/") + "/" + normalized = os.path.normpath(absolute_path) + # Convert to forward slashes and ensure proper trailing slash + path = normalized.replace("\\", "/") + self.absolute_path = path.rstrip("/") + "/" if absolute_path.endswith(("/", "\\")) else path def __hash__(self): return hash(self.absolute_path) @@ -45,7 +47,6 @@ def resolve_file(self, child: str) -> "TypedPath": self.assert_folder() if child.startswith("/") or child.endswith("/"): raise ValueError("Child path is not valid for file resolution") - # Use platform-agnostic path joining normalized_child = os.path.normpath(child) joined_path = os.path.join(self.absolute_path.rstrip("/"), normalized_child) return self.of_file(joined_path) @@ -54,7 +55,6 @@ def resolve_folder(self, child: str) -> "TypedPath": self.assert_folder() if child.startswith("/"): raise ValueError("Child path starts with a slash") - # Use platform-agnostic path joining normalized_child = os.path.normpath(child.rstrip("/")) joined_path = os.path.join(self.absolute_path.rstrip("/"), normalized_child) return self.of_folder(joined_path) @@ -75,16 +75,12 @@ def __lt__(self, other: "TypedPath") -> bool: @classmethod def of_folder(cls, path: str) -> "TypedPath": - # Use platform-agnostic path normalization - normalized_path = os.path.normpath(path).replace("\\", "/") - if not normalized_path.endswith("/"): - normalized_path += "/" - return cls(normalized_path) + normalized = os.path.normpath(path).replace("\\", "/") + return cls(normalized + "/") @classmethod def of_file(cls, path: str) -> "TypedPath": - # Use platform-agnostic path normalization - normalized_path = os.path.normpath(path).replace("\\", "/") - if normalized_path.endswith("/"): + normalized = os.path.normpath(path) + if normalized.endswith("/"): raise ValueError("Expected path to not end with a slash for a file") - return cls(normalized_path) + return cls(normalized) From b0d9b95c6cbd2de6891e3150611722167499bd95 Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Thu, 12 Dec 2024 22:19:11 +0000 Subject: [PATCH 11/30] style: apply ruff formatting to TypedPath.py Co-Authored-By: ned.twigg@diffplug.com --- python/selfie-lib/selfie_lib/TypedPath.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/python/selfie-lib/selfie_lib/TypedPath.py b/python/selfie-lib/selfie_lib/TypedPath.py index 298a09af..90afe1f6 100644 --- a/python/selfie-lib/selfie_lib/TypedPath.py +++ b/python/selfie-lib/selfie_lib/TypedPath.py @@ -1,5 +1,5 @@ -from functools import total_ordering import os.path +from functools import total_ordering @total_ordering @@ -9,7 +9,9 @@ def __init__(self, absolute_path: str): normalized = os.path.normpath(absolute_path) # Convert to forward slashes and ensure proper trailing slash path = normalized.replace("\\", "/") - self.absolute_path = path.rstrip("/") + "/" if absolute_path.endswith(("/", "\\")) else path + self.absolute_path = ( + path.rstrip("/") + "/" if absolute_path.endswith(("/", "\\")) else path + ) def __hash__(self): return hash(self.absolute_path) From 1c7334d01b281a34fb9c39b112fb2497d3fa9677 Mon Sep 17 00:00:00 2001 From: Ned Twigg Date: Thu, 12 Dec 2024 23:48:22 -0800 Subject: [PATCH 12/30] Implement the rest of the binary stuff. --- .../selfie_lib/SelfieImplementations.py | 120 +++++++++--------- .../selfie-lib/selfie_lib/SnapshotSystem.py | 20 ++- python/selfie-lib/selfie_lib/WriteTracker.py | 8 +- 3 files changed, 81 insertions(+), 67 deletions(-) diff --git a/python/selfie-lib/selfie_lib/SelfieImplementations.py b/python/selfie-lib/selfie_lib/SelfieImplementations.py index c6a9713e..cf2fc081 100644 --- a/python/selfie-lib/selfie_lib/SelfieImplementations.py +++ b/python/selfie-lib/selfie_lib/SelfieImplementations.py @@ -186,83 +186,71 @@ def __init__(self, actual: Snapshot, disk: DiskStorage, only_facet: str): f"The facet {only_facet} is a string, not a binary snapshot" ) + def _actual_bytes(self) -> bytes: + return self.actual.subject_or_facet(self.only_facet).value_binary() + + def to_match_disk(self, sub: str = "") -> "BinarySelfie": + super().to_match_disk(sub) + return self + + def to_match_disk_TODO(self, sub: str = "") -> "BinarySelfie": + super().to_match_disk_TODO(sub) + return self + + def to_be_base64_TODO(self, _: Any = None) -> bytes: + _toBeDidntMatch(None, self._actual_string(), LiteralString()) + return self._actual_bytes() + def to_be_base64(self, expected: str) -> bytes: - actual_bytes = self.actual.subject_or_facet(self.only_facet).value_binary() expected_bytes = base64.b64decode(expected) + actual_bytes = self._actual_bytes() if actual_bytes == expected_bytes: return _checkSrc(actual_bytes) else: - actual_b64 = base64.b64encode(actual_bytes).decode().replace("\r", "") - _toBeDidntMatch(expected, actual_b64, LiteralString()) + _toBeDidntMatch(expected, self._actual_string(), LiteralString()) return actual_bytes - def to_be_base64_TODO(self, _: Any = None) -> bytes: - call = recordCall(False) - if not _selfieSystem().mode.can_write(True, call, _selfieSystem()): - raise _selfieSystem().fs.assert_failed( - message=f"Can't call `to_be_base64_TODO` in {Mode.readonly} mode!" - ) - return self._actual_bytes() - - def _actual_bytes(self) -> bytes: - return self.actual.subject_or_facet(self.only_facet).value_binary() - def _actual_string(self) -> str: return base64.b64encode(self._actual_bytes()).decode().replace("\r", "") - def to_be_file_impl(self, subpath: str, is_todo: bool) -> bytes: + def _to_be_file_impl(self, subpath: str, is_todo: bool) -> bytes: call = recordCall(False) - actual_bytes = self.actual.subject_or_facet(self.only_facet).value_binary() writable = _selfieSystem().mode.can_write(is_todo, call, _selfieSystem()) - if is_todo and not writable: - raise _selfieSystem().fs.assert_failed( - message=f"Can't call `to_be_file_TODO` in {Mode.readonly} mode!" - ) - if not writable: - path = ( - _selfieSystem() - .layout.sourcefile_for_call(call.location) - .parent_folder() - .resolve_file(subpath) - ) - if not _selfieSystem().fs.file_exists(path): - raise _selfieSystem().fs.assert_failed( - message=_selfieSystem().mode.msg_snapshot_not_found_no_such_file( - path - ) - ) - expected = _selfieSystem().fs.file_read_binary(path) - if expected == actual_bytes: - return actual_bytes - else: - raise _selfieSystem().fs.assert_failed( - message=_selfieSystem().mode.msg_snapshot_mismatch(), - expected=expected, - actual=actual_bytes, - ) - else: + actual_bytes = self._actual_bytes() + path = _selfieSystem().layout.root_folder().resolve_file(subpath) + + if writable: if is_todo: _selfieSystem().write_inline(TodoStub.to_be_file.create_literal(), call) - _selfieSystem().write_to_be_file( - _selfieSystem() - .layout.sourcefile_for_call(call.location) - .parent_folder() - .resolve_file(subpath), - actual_bytes, - call, - ) + _selfieSystem().write_to_be_file(path, actual_bytes, call) return actual_bytes + else: + if is_todo: + raise _selfieSystem().fs.assert_failed( + f"Can't call `to_be_file_TODO` in {Mode.readonly} mode!" + ) + else: + if not _selfieSystem().fs.file_exists(path): + raise _selfieSystem().fs.assert_failed( + _selfieSystem().mode.msg_snapshot_not_found_no_such_file(path) + ) + expected = _selfieSystem().fs.file_read_binary(path) + if expected == actual_bytes: + return actual_bytes + else: + raise _selfieSystem().fs.assert_failed( + message=_selfieSystem().mode.msg_snapshot_mismatch_binary( + expected, actual_bytes + ), + expected=expected, + actual=actual_bytes, + ) def to_be_file_TODO(self, subpath: str) -> bytes: - call = recordCall(False) - if not _selfieSystem().mode.can_write(True, call, _selfieSystem()): - raise _selfieSystem().fs.assert_failed( - message=f"Can't call `to_be_file_TODO` in {Mode.readonly} mode!" - ) - return self.to_be_file_impl(subpath, True) + return self._to_be_file_impl(subpath, True) def to_be_file(self, subpath: str) -> bytes: - return self.to_be_file_impl(subpath, False) + return self._to_be_file_impl(subpath, False) def _checkSrc(value: T) -> T: @@ -279,11 +267,13 @@ def _toBeDidntMatch(expected: Optional[T], actual: T, fmt: LiteralFormat[T]) -> else: if expected is None: raise _selfieSystem().fs.assert_failed( - message=f"Can't call `toBe_TODO` in {Mode.readonly} mode!" + f"Can't call `toBe_TODO` in {Mode.readonly} mode!" ) else: raise _selfieSystem().fs.assert_failed( - message=_selfieSystem().mode.msg_snapshot_mismatch(), + message=_selfieSystem().mode.msg_snapshot_mismatch( + expected=repr(expected), actual=repr(actual) + ), expected=expected, actual=actual, ) @@ -308,10 +298,14 @@ def _assertEqual( ), ) ) + expectedFacets = _serializeOnlyFacets(expected, mismatched_keys) + actualFacets = _serializeOnlyFacets(actual, mismatched_keys) raise storage.fs.assert_failed( - message=storage.mode.msg_snapshot_mismatch(), - expected=_serializeOnlyFacets(expected, mismatched_keys), - actual=_serializeOnlyFacets(actual, mismatched_keys), + message=storage.mode.msg_snapshot_mismatch( + expected=expectedFacets, actual=actualFacets + ), + expected=expectedFacets, + actual=actualFacets, ) diff --git a/python/selfie-lib/selfie_lib/SnapshotSystem.py b/python/selfie-lib/selfie_lib/SnapshotSystem.py index fbe5e47f..67709276 100644 --- a/python/selfie-lib/selfie_lib/SnapshotSystem.py +++ b/python/selfie-lib/selfie_lib/SnapshotSystem.py @@ -124,8 +124,24 @@ def msg_snapshot_not_found(self) -> str: def msg_snapshot_not_found_no_such_file(self, file) -> str: return self.msg(f"Snapshot not found: no such file {file}") - def msg_snapshot_mismatch(self) -> str: - return self.msg("Snapshot mismatch") + def msg_snapshot_mismatch(self, expected: str, actual: str) -> str: # noqa: ARG002 + return self.msg("Snapshot mismatch, TODO: string comparison") + + def msg_snapshot_mismatch_binary(self, expected: bytes, actual: bytes) -> str: + return self.msg_snapshot_mismatch( + self._to_quoted_printable(expected), self._to_quoted_printable(actual) + ) + + def _to_quoted_printable(self, byte_data: bytes) -> str: + result = [] + for b in byte_data: + # b is already an integer in [0..255] when iterating through a bytes object + if 33 <= b <= 126 and b != 61: # '=' is ASCII 61, so skip it + result.append(chr(b)) + else: + # Convert to uppercase hex, pad to 2 digits, and prepend '=' + result.append(f"={b:02X}") + return "".join(result) def msg(self, headline: str) -> str: if self == Mode.interactive: diff --git a/python/selfie-lib/selfie_lib/WriteTracker.py b/python/selfie-lib/selfie_lib/WriteTracker.py index f105809c..e7a6edf0 100644 --- a/python/selfie-lib/selfie_lib/WriteTracker.py +++ b/python/selfie-lib/selfie_lib/WriteTracker.py @@ -1,7 +1,7 @@ import inspect import os import threading -from abc import ABC +from abc import ABC, abstractmethod from functools import total_ordering from pathlib import Path from typing import Generic, Optional, TypeVar, cast @@ -82,10 +82,14 @@ def __hash__(self): return hash((self.location, tuple(self.rest_of_stack))) -class SnapshotFileLayout: +class SnapshotFileLayout(ABC): def __init__(self, fs: FS): self.fs = fs + @abstractmethod + def root_folder() -> TypedPath: + pass + def sourcefile_for_call(self, call: CallLocation) -> TypedPath: file_path = call.file_name if not file_path: From 291a0b5f044af89a042ca6e02773f8ba2baa4423 Mon Sep 17 00:00:00 2001 From: Ned Twigg Date: Fri, 13 Dec 2024 00:04:54 -0800 Subject: [PATCH 13/30] Fix `SnapshotFileLayout.rootFolder()` --- python/pytest-selfie/pytest_selfie/plugin.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/python/pytest-selfie/pytest_selfie/plugin.py b/python/pytest-selfie/pytest_selfie/plugin.py index 069671d3..107c4dc1 100644 --- a/python/pytest-selfie/pytest_selfie/plugin.py +++ b/python/pytest-selfie/pytest_selfie/plugin.py @@ -69,6 +69,9 @@ def __init__(self, fs: FSImplementation, settings: SelfieSettingsAPI): self.__root_folder = TypedPath.of_folder(os.path.abspath(settings.root_dir)) self.unix_newlines = self.__infer_default_line_ending_is_unix() + def root_folder(self) -> TypedPath: + return self.__root_folder + def snapshotfile_for_testfile(self, testfile: TypedPath) -> TypedPath: if testfile.name.endswith(".py"): return testfile.parent_folder().resolve_file(f"{testfile.name[:-3]}.ss") From a4fa0242410b75db0970f298ee18e2bc8ba4c1ac Mon Sep 17 00:00:00 2001 From: Ned Twigg Date: Fri, 13 Dec 2024 00:07:40 -0800 Subject: [PATCH 14/30] Forgot one. --- python/selfie-lib/selfie_lib/WriteTracker.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/selfie-lib/selfie_lib/WriteTracker.py b/python/selfie-lib/selfie_lib/WriteTracker.py index e7a6edf0..f38172d6 100644 --- a/python/selfie-lib/selfie_lib/WriteTracker.py +++ b/python/selfie-lib/selfie_lib/WriteTracker.py @@ -87,7 +87,7 @@ def __init__(self, fs: FS): self.fs = fs @abstractmethod - def root_folder() -> TypedPath: + def root_folder(self) -> TypedPath: pass def sourcefile_for_call(self, call: CallLocation) -> TypedPath: From fadc54bea0ba19e6278c6db4f10937797cd1edf3 Mon Sep 17 00:00:00 2001 From: Ned Twigg Date: Fri, 13 Dec 2024 01:20:59 -0800 Subject: [PATCH 15/30] Remove unused stuff. --- python/example-pytest-selfie/conftest.py | 3 --- .../tests/to_be_file_test.py | 24 ------------------- 2 files changed, 27 deletions(-) delete mode 100644 python/example-pytest-selfie/conftest.py delete mode 100644 python/example-pytest-selfie/tests/to_be_file_test.py diff --git a/python/example-pytest-selfie/conftest.py b/python/example-pytest-selfie/conftest.py deleted file mode 100644 index d39eb866..00000000 --- a/python/example-pytest-selfie/conftest.py +++ /dev/null @@ -1,3 +0,0 @@ -import os - -os.environ["SELFIE"] = "readonly" diff --git a/python/example-pytest-selfie/tests/to_be_file_test.py b/python/example-pytest-selfie/tests/to_be_file_test.py deleted file mode 100644 index 98c18749..00000000 --- a/python/example-pytest-selfie/tests/to_be_file_test.py +++ /dev/null @@ -1,24 +0,0 @@ -import os -from pathlib import Path - -from pytest_selfie import FSImplementation -from selfie_lib.WriteTracker import ( - SnapshotFileLayout, - ToBeFileWriteTracker, - TypedPath, - recordCall, -) - - -def test_to_be_file(): - layout = SnapshotFileLayout(FSImplementation()) - tracker = ToBeFileWriteTracker() - - # Record the current call stack. - call_stack = recordCall(callerFileOnly=True) - - # Create a TypedPath object for the file path - file_path = TypedPath(os.path.abspath(Path("test.jpg"))) - - # Write byte data to disk using the tracker. - tracker.writeToDisk(file_path, b"some byte data", call_stack, layout) From abece41e630a4d46ca52f549cbfb46d780a96b65 Mon Sep 17 00:00:00 2001 From: Ned Twigg Date: Fri, 13 Dec 2024 01:22:04 -0800 Subject: [PATCH 16/30] Remove LLM cruft from `TypedPath`. --- python/selfie-lib/selfie_lib/TypedPath.py | 29 ++++++++--------------- 1 file changed, 10 insertions(+), 19 deletions(-) diff --git a/python/selfie-lib/selfie_lib/TypedPath.py b/python/selfie-lib/selfie_lib/TypedPath.py index 90afe1f6..74625a7c 100644 --- a/python/selfie-lib/selfie_lib/TypedPath.py +++ b/python/selfie-lib/selfie_lib/TypedPath.py @@ -1,17 +1,10 @@ -import os.path from functools import total_ordering @total_ordering class TypedPath: def __init__(self, absolute_path: str): - # Normalize path separators for internal storage - normalized = os.path.normpath(absolute_path) - # Convert to forward slashes and ensure proper trailing slash - path = normalized.replace("\\", "/") - self.absolute_path = ( - path.rstrip("/") + "/" if absolute_path.endswith(("/", "\\")) else path - ) + self.absolute_path = absolute_path def __hash__(self): return hash(self.absolute_path) @@ -49,17 +42,13 @@ def resolve_file(self, child: str) -> "TypedPath": self.assert_folder() if child.startswith("/") or child.endswith("/"): raise ValueError("Child path is not valid for file resolution") - normalized_child = os.path.normpath(child) - joined_path = os.path.join(self.absolute_path.rstrip("/"), normalized_child) - return self.of_file(joined_path) + return self.of_file(f"{self.absolute_path}{child}") def resolve_folder(self, child: str) -> "TypedPath": self.assert_folder() if child.startswith("/"): raise ValueError("Child path starts with a slash") - normalized_child = os.path.normpath(child.rstrip("/")) - joined_path = os.path.join(self.absolute_path.rstrip("/"), normalized_child) - return self.of_folder(joined_path) + return self.of_folder(f"{self.absolute_path}{child}/") def relativize(self, child: "TypedPath") -> str: self.assert_folder() @@ -77,12 +66,14 @@ def __lt__(self, other: "TypedPath") -> bool: @classmethod def of_folder(cls, path: str) -> "TypedPath": - normalized = os.path.normpath(path).replace("\\", "/") - return cls(normalized + "/") + unix_path = path.replace("\\", "/") + if not unix_path.endswith("/"): + unix_path += "/" + return cls(unix_path) @classmethod def of_file(cls, path: str) -> "TypedPath": - normalized = os.path.normpath(path) - if normalized.endswith("/"): + unix_path = path.replace("\\", "/") + if unix_path.endswith("/"): raise ValueError("Expected path to not end with a slash for a file") - return cls(normalized) + return cls(unix_path) From 43da71d2f54997aef2a171d142ab3a6f67095177 Mon Sep 17 00:00:00 2001 From: Ned Twigg Date: Fri, 13 Dec 2024 01:23:06 -0800 Subject: [PATCH 17/30] Add nice error message when objects are not equal but their repr is. --- .../selfie_lib/SelfieImplementations.py | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/python/selfie-lib/selfie_lib/SelfieImplementations.py b/python/selfie-lib/selfie_lib/SelfieImplementations.py index cf2fc081..413aca22 100644 --- a/python/selfie-lib/selfie_lib/SelfieImplementations.py +++ b/python/selfie-lib/selfie_lib/SelfieImplementations.py @@ -270,13 +270,18 @@ def _toBeDidntMatch(expected: Optional[T], actual: T, fmt: LiteralFormat[T]) -> f"Can't call `toBe_TODO` in {Mode.readonly} mode!" ) else: - raise _selfieSystem().fs.assert_failed( - message=_selfieSystem().mode.msg_snapshot_mismatch( - expected=repr(expected), actual=repr(actual) - ), - expected=expected, - actual=actual, - ) + expectedStr = repr(expected) + actualStr = repr(actual) + if expectedStr == actualStr: + raise f"Value of type {type(actual)} is not `==` to the expected value, but they both have the same `repr` value:\n${expectedStr}" + else: + raise _selfieSystem().fs.assert_failed( + message=_selfieSystem().mode.msg_snapshot_mismatch( + expected=expectedStr, actual=actualStr + ), + expected=expected, + actual=actual, + ) def _assertEqual( From ec4c20710eeb9cc83b58447be43c2af4e169d1df Mon Sep 17 00:00:00 2001 From: Ned Twigg Date: Fri, 13 Dec 2024 01:23:21 -0800 Subject: [PATCH 18/30] Cleanup the the binary_test stuff. --- .../tests/binary_test.py | 30 +++++++++---------- 1 file changed, 14 insertions(+), 16 deletions(-) diff --git a/python/example-pytest-selfie/tests/binary_test.py b/python/example-pytest-selfie/tests/binary_test.py index 47c68826..7965355c 100644 --- a/python/example-pytest-selfie/tests/binary_test.py +++ b/python/example-pytest-selfie/tests/binary_test.py @@ -24,12 +24,20 @@ def test_binary_file(): expect_selfie(data).to_be_file("test_binary.bin") -def test_binary_file_duplicate(): +def test_binary_file_duplicate_equal(): """Test writing same binary data to a file multiple times""" - data = b"same data" - expect_selfie(data).to_be_file("duplicate.bin") - expect_selfie(data).to_be_file("duplicate.bin") + expect_selfie(b"equal").to_be_file("duplicate_equal.bin") + expect_selfie(b"equal").to_be_file("duplicate_equal.bin") +def test_binary_file_duplicate_unequal(): + """Test writing same binary data to a file multiple times""" + try: + expect_selfie(b"a").to_be_file("duplicate_unequal.bin") + expect_selfie(b"b").to_be_file("duplicate_unequal.bin") + except AssertionError as e: + expect_selfie(str(e)).to_be("""Snapshot mismatch, TODO: string comparison +- update this snapshot by adding `_TODO` to the function name +- update all snapshots in this file by adding """) def test_binary_file_mismatch(): """Test error handling for mismatched binary data""" @@ -48,16 +56,6 @@ def test_base64_mismatch(): """Test error handling for mismatched base64 data""" data = b"test data" encoded = base64.b64encode(b"different data").decode() - with pytest.raises(AssertionError): - expect_selfie(data).to_be_base64(encoded) - - -def test_readonly_mode_todo(): - """Test error handling in readonly mode for TODO methods""" - from selfie_lib import _selfieSystem - - print(f"Current mode: {_selfieSystem().mode}") - print(f"SELFIE env var: {os.getenv('SELFIE')}") with pytest.raises(AssertionError) as exc_info: - expect_selfie(b"test").to_be_base64_TODO() - assert "readonly mode" in str(exc_info.value).lower() + expect_selfie(data).to_be_base64("dGVzdCBkYXRh") + expect_selfie(str(exc_info.value)).to_be_TODO("Error while parsing the literal at File: /Users/ntwigg/Documents/dev/selfie/python/example-pytest-selfie/tests/binary_test.py, Line: 60. Please report this error at https://github.com/diffplug/selfie") From aeb4024f5c8b6413a796ad095bc7b53326b3b72c Mon Sep 17 00:00:00 2001 From: Ned Twigg Date: Fri, 13 Dec 2024 01:40:44 -0800 Subject: [PATCH 19/30] fix a typo --- python/pytest-selfie/pytest_selfie/plugin.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/pytest-selfie/pytest_selfie/plugin.py b/python/pytest-selfie/pytest_selfie/plugin.py index 107c4dc1..08b89e37 100644 --- a/python/pytest-selfie/pytest_selfie/plugin.py +++ b/python/pytest-selfie/pytest_selfie/plugin.py @@ -56,7 +56,7 @@ def __nullable_to_string(self, value, on_null: str) -> str: def __comparison_assertion( self, message: str, expected: str, actual: str ) -> Exception: - # this *should* through an exception that a good pytest runner will show nicely + # this *should* throw an exception that a good pytest runner will show nicely assert expected == actual, message # but in case it doesn't, we'll create our own here return AssertionError(message) From dd507e24e8d46f97de0dff3caa457bff28bf32c3 Mon Sep 17 00:00:00 2001 From: Ned Twigg Date: Fri, 13 Dec 2024 01:40:58 -0800 Subject: [PATCH 20/30] No need for a trailing newline. --- python/selfie-lib/selfie_lib/WriteTracker.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/selfie-lib/selfie_lib/WriteTracker.py b/python/selfie-lib/selfie_lib/WriteTracker.py index f38172d6..8158dc89 100644 --- a/python/selfie-lib/selfie_lib/WriteTracker.py +++ b/python/selfie-lib/selfie_lib/WriteTracker.py @@ -154,7 +154,7 @@ def recordInternal( existing = self.writes[key] if existing.snapshot != snapshot: raise ValueError( - f"Snapshot was set to multiple values!\n first time: {existing.call_stack.location.ide_link(layout)}\n this time: {call.location.ide_link(layout)}\n" + f"Snapshot was set to multiple values!\n first time: {existing.call_stack.location.ide_link(layout)}\n this time: {call.location.ide_link(layout)}" ) elif not allow_multiple_equivalent_writes: raise ValueError("Snapshot was set to the same value multiple times.") From 2150adc1538c2db18f7ca12bcbae5429c77decba Mon Sep 17 00:00:00 2001 From: Ned Twigg Date: Fri, 13 Dec 2024 01:43:14 -0800 Subject: [PATCH 21/30] Remove the test `.bin` files. --- python/example-pytest-selfie/tests/duplicate.bin | 1 - python/example-pytest-selfie/tests/test_binary.bin | 1 - 2 files changed, 2 deletions(-) delete mode 100644 python/example-pytest-selfie/tests/duplicate.bin delete mode 100644 python/example-pytest-selfie/tests/test_binary.bin diff --git a/python/example-pytest-selfie/tests/duplicate.bin b/python/example-pytest-selfie/tests/duplicate.bin deleted file mode 100644 index 5b65fdb5..00000000 --- a/python/example-pytest-selfie/tests/duplicate.bin +++ /dev/null @@ -1 +0,0 @@ -same data \ No newline at end of file diff --git a/python/example-pytest-selfie/tests/test_binary.bin b/python/example-pytest-selfie/tests/test_binary.bin deleted file mode 100644 index 498a006d..00000000 --- a/python/example-pytest-selfie/tests/test_binary.bin +++ /dev/null @@ -1 +0,0 @@ -test binary data \ No newline at end of file From 597f157db791bbd6736161e0273035827c03cd14 Mon Sep 17 00:00:00 2001 From: Ned Twigg Date: Fri, 13 Dec 2024 01:50:02 -0800 Subject: [PATCH 22/30] I would expect this to pass. --- .../tests/binary_test.py | 31 ++++++------------- .../tests/binary_test__test_binary_file.bin | 1 + ...test__test_binary_file_duplicate_equal.bin | 1 + ...st__test_binary_file_duplicate_unequal.bin | 1 + 4 files changed, 13 insertions(+), 21 deletions(-) create mode 100644 python/example-pytest-selfie/tests/binary_test__test_binary_file.bin create mode 100644 python/example-pytest-selfie/tests/binary_test__test_binary_file_duplicate_equal.bin create mode 100644 python/example-pytest-selfie/tests/binary_test__test_binary_file_duplicate_unequal.bin diff --git a/python/example-pytest-selfie/tests/binary_test.py b/python/example-pytest-selfie/tests/binary_test.py index 7965355c..cdb018fd 100644 --- a/python/example-pytest-selfie/tests/binary_test.py +++ b/python/example-pytest-selfie/tests/binary_test.py @@ -4,7 +4,6 @@ import pytest from selfie_lib import expect_selfie - def test_empty_binary_base64(): """Test base64 encoding of empty byte array""" expect_selfie(bytes()).to_be_base64("") @@ -21,41 +20,31 @@ def test_large_binary_base64(): def test_binary_file(): """Test writing binary data to a file""" data = b"test binary data" - expect_selfie(data).to_be_file("test_binary.bin") + expect_selfie(data).to_be_file("tests/binary_test__test_binary_file.bin") def test_binary_file_duplicate_equal(): """Test writing same binary data to a file multiple times""" - expect_selfie(b"equal").to_be_file("duplicate_equal.bin") - expect_selfie(b"equal").to_be_file("duplicate_equal.bin") - -def test_binary_file_duplicate_unequal(): - """Test writing same binary data to a file multiple times""" - try: - expect_selfie(b"a").to_be_file("duplicate_unequal.bin") - expect_selfie(b"b").to_be_file("duplicate_unequal.bin") - except AssertionError as e: - expect_selfie(str(e)).to_be("""Snapshot mismatch, TODO: string comparison -- update this snapshot by adding `_TODO` to the function name -- update all snapshots in this file by adding """) + expect_selfie(b"equal").to_be_file("tests/binary_test__test_binary_file_duplicate_equal.bin") + expect_selfie(b"equal").to_be_file("tests/binary_test__test_binary_file_duplicate_equal.bin") def test_binary_file_mismatch(): """Test error handling for mismatched binary data""" with pytest.raises(AssertionError): - expect_selfie(b"different").to_be_file("test_binary.bin") + expect_selfie(b"different").to_be_file("tests/binary_test__SHOULD_NOT_EXIST.bin") def test_binary_file_not_found(): """Test error handling for non-existent file""" with pytest.raises(AssertionError) as exc_info: - expect_selfie(b"test").to_be_file("nonexistent.bin") + expect_selfie(b"test").to_be_file("tests/binary_test__SHOULD_NOT_EXIST.bin") assert "no such file" in str(exc_info.value) def test_base64_mismatch(): """Test error handling for mismatched base64 data""" - data = b"test data" - encoded = base64.b64encode(b"different data").decode() - with pytest.raises(AssertionError) as exc_info: - expect_selfie(data).to_be_base64("dGVzdCBkYXRh") - expect_selfie(str(exc_info.value)).to_be_TODO("Error while parsing the literal at File: /Users/ntwigg/Documents/dev/selfie/python/example-pytest-selfie/tests/binary_test.py, Line: 60. Please report this error at https://github.com/diffplug/selfie") + with pytest.raises(Exception) as exc_info: + expect_selfie(b"test data").to_be_base64("AAAA") + expect_selfie(str(exc_info.value)).to_be("""Snapshot mismatch, TODO: string comparison +- update this snapshot by adding `_TODO` to the function name +- update all snapshots in this file by adding `#selfieonce` or `#SELFIEWRITE`""") \ No newline at end of file diff --git a/python/example-pytest-selfie/tests/binary_test__test_binary_file.bin b/python/example-pytest-selfie/tests/binary_test__test_binary_file.bin new file mode 100644 index 00000000..498a006d --- /dev/null +++ b/python/example-pytest-selfie/tests/binary_test__test_binary_file.bin @@ -0,0 +1 @@ +test binary data \ No newline at end of file diff --git a/python/example-pytest-selfie/tests/binary_test__test_binary_file_duplicate_equal.bin b/python/example-pytest-selfie/tests/binary_test__test_binary_file_duplicate_equal.bin new file mode 100644 index 00000000..33e8d4a8 --- /dev/null +++ b/python/example-pytest-selfie/tests/binary_test__test_binary_file_duplicate_equal.bin @@ -0,0 +1 @@ +equal \ No newline at end of file diff --git a/python/example-pytest-selfie/tests/binary_test__test_binary_file_duplicate_unequal.bin b/python/example-pytest-selfie/tests/binary_test__test_binary_file_duplicate_unequal.bin new file mode 100644 index 00000000..2e65efe2 --- /dev/null +++ b/python/example-pytest-selfie/tests/binary_test__test_binary_file_duplicate_unequal.bin @@ -0,0 +1 @@ +a \ No newline at end of file From b697dce6fb69e4a4907aaf26932d092e5786dbda Mon Sep 17 00:00:00 2001 From: Ned Twigg Date: Fri, 13 Dec 2024 01:51:24 -0800 Subject: [PATCH 23/30] And now with correct formatting. --- .../tests/binary_test.py | 23 ++++++++++++------- 1 file changed, 15 insertions(+), 8 deletions(-) diff --git a/python/example-pytest-selfie/tests/binary_test.py b/python/example-pytest-selfie/tests/binary_test.py index cdb018fd..9488d037 100644 --- a/python/example-pytest-selfie/tests/binary_test.py +++ b/python/example-pytest-selfie/tests/binary_test.py @@ -1,9 +1,7 @@ -import base64 -import os - import pytest from selfie_lib import expect_selfie + def test_empty_binary_base64(): """Test base64 encoding of empty byte array""" expect_selfie(bytes()).to_be_base64("") @@ -25,13 +23,20 @@ def test_binary_file(): def test_binary_file_duplicate_equal(): """Test writing same binary data to a file multiple times""" - expect_selfie(b"equal").to_be_file("tests/binary_test__test_binary_file_duplicate_equal.bin") - expect_selfie(b"equal").to_be_file("tests/binary_test__test_binary_file_duplicate_equal.bin") + expect_selfie(b"equal").to_be_file( + "tests/binary_test__test_binary_file_duplicate_equal.bin" + ) + expect_selfie(b"equal").to_be_file( + "tests/binary_test__test_binary_file_duplicate_equal.bin" + ) + def test_binary_file_mismatch(): """Test error handling for mismatched binary data""" with pytest.raises(AssertionError): - expect_selfie(b"different").to_be_file("tests/binary_test__SHOULD_NOT_EXIST.bin") + expect_selfie(b"different").to_be_file( + "tests/binary_test__SHOULD_NOT_EXIST.bin" + ) def test_binary_file_not_found(): @@ -45,6 +50,8 @@ def test_base64_mismatch(): """Test error handling for mismatched base64 data""" with pytest.raises(Exception) as exc_info: expect_selfie(b"test data").to_be_base64("AAAA") - expect_selfie(str(exc_info.value)).to_be("""Snapshot mismatch, TODO: string comparison + expect_selfie( + str(exc_info.value) + ).to_be("""Snapshot mismatch, TODO: string comparison - update this snapshot by adding `_TODO` to the function name -- update all snapshots in this file by adding `#selfieonce` or `#SELFIEWRITE`""") \ No newline at end of file +- update all snapshots in this file by adding `#selfieonce` or `#SELFIEWRITE`""") From 6c5178fd2439af8304316763637971b31c2dc2cb Mon Sep 17 00:00:00 2001 From: Ned Twigg Date: Fri, 13 Dec 2024 02:02:55 -0800 Subject: [PATCH 24/30] Fixed the weird thing that was nuking our tests. --- python/example-pytest-selfie/tests/binary_test.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/python/example-pytest-selfie/tests/binary_test.py b/python/example-pytest-selfie/tests/binary_test.py index 9488d037..c97d9485 100644 --- a/python/example-pytest-selfie/tests/binary_test.py +++ b/python/example-pytest-selfie/tests/binary_test.py @@ -51,7 +51,11 @@ def test_base64_mismatch(): with pytest.raises(Exception) as exc_info: expect_selfie(b"test data").to_be_base64("AAAA") expect_selfie( - str(exc_info.value) + safify(str(exc_info.value)) ).to_be("""Snapshot mismatch, TODO: string comparison - update this snapshot by adding `_TODO` to the function name -- update all snapshots in this file by adding `#selfieonce` or `#SELFIEWRITE`""") +- update all snapshots in this file by adding `#safewordonce` or `#safewordWRITE`""") + +def safify(string: str) -> str: + return string.replace("selfie", "safeword").replace("SELFIE", "safeword") + From 470eff40c28a78281553c5a5f274965b2d883439 Mon Sep 17 00:00:00 2001 From: Ned Twigg Date: Fri, 13 Dec 2024 02:04:48 -0800 Subject: [PATCH 25/30] Formatting fix. --- python/selfie-lib/selfie_lib/SelfieImplementations.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/python/selfie-lib/selfie_lib/SelfieImplementations.py b/python/selfie-lib/selfie_lib/SelfieImplementations.py index 413aca22..8370b5d2 100644 --- a/python/selfie-lib/selfie_lib/SelfieImplementations.py +++ b/python/selfie-lib/selfie_lib/SelfieImplementations.py @@ -273,7 +273,9 @@ def _toBeDidntMatch(expected: Optional[T], actual: T, fmt: LiteralFormat[T]) -> expectedStr = repr(expected) actualStr = repr(actual) if expectedStr == actualStr: - raise f"Value of type {type(actual)} is not `==` to the expected value, but they both have the same `repr` value:\n${expectedStr}" + raise ValueError( + f"Value of type {type(actual)} is not `==` to the expected value, but they both have the same `repr` value:\n${expectedStr}" + ) else: raise _selfieSystem().fs.assert_failed( message=_selfieSystem().mode.msg_snapshot_mismatch( From 7916fda157444093e50dee59f2454487b6016fd3 Mon Sep 17 00:00:00 2001 From: Ned Twigg Date: Fri, 13 Dec 2024 02:15:21 -0800 Subject: [PATCH 26/30] Testing a snapshot testing library is so hard! --- python/example-pytest-selfie/tests/binary_test.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/python/example-pytest-selfie/tests/binary_test.py b/python/example-pytest-selfie/tests/binary_test.py index c97d9485..82fccd94 100644 --- a/python/example-pytest-selfie/tests/binary_test.py +++ b/python/example-pytest-selfie/tests/binary_test.py @@ -52,10 +52,8 @@ def test_base64_mismatch(): expect_selfie(b"test data").to_be_base64("AAAA") expect_selfie( safify(str(exc_info.value)) - ).to_be("""Snapshot mismatch, TODO: string comparison -- update this snapshot by adding `_TODO` to the function name -- update all snapshots in this file by adding `#safewordonce` or `#safewordWRITE`""") + ).to_be("Snapshot mismatch, TODO: string comparison") def safify(string: str) -> str: - return string.replace("selfie", "safeword").replace("SELFIE", "safeword") + return string.split("\n")[0] From 6fc6caa11673eb3c14ea901d78e7fc54b6ed831d Mon Sep 17 00:00:00 2001 From: Ned Twigg Date: Fri, 13 Dec 2024 02:16:56 -0800 Subject: [PATCH 27/30] fixup formatting. --- python/example-pytest-selfie/tests/binary_test.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/python/example-pytest-selfie/tests/binary_test.py b/python/example-pytest-selfie/tests/binary_test.py index 82fccd94..fe000d5a 100644 --- a/python/example-pytest-selfie/tests/binary_test.py +++ b/python/example-pytest-selfie/tests/binary_test.py @@ -50,10 +50,10 @@ def test_base64_mismatch(): """Test error handling for mismatched base64 data""" with pytest.raises(Exception) as exc_info: expect_selfie(b"test data").to_be_base64("AAAA") - expect_selfie( - safify(str(exc_info.value)) - ).to_be("Snapshot mismatch, TODO: string comparison") + expect_selfie(safify(str(exc_info.value))).to_be( + "Snapshot mismatch, TODO: string comparison" + ) + def safify(string: str) -> str: return string.split("\n")[0] - From ba088d863225440e703c8c31fa60ac09582bb922 Mon Sep 17 00:00:00 2001 From: Ned Twigg Date: Fri, 13 Dec 2024 02:16:39 -0800 Subject: [PATCH 28/30] Cleanup the uv lock files. --- python/example-pytest-selfie/uv.lock | 233 --------------------------- python/pytest-selfie/uv.lock | 79 --------- python/selfie-lib/uv.lock | 173 -------------------- 3 files changed, 485 deletions(-) diff --git a/python/example-pytest-selfie/uv.lock b/python/example-pytest-selfie/uv.lock index 2d5b9c3c..9499b452 100644 --- a/python/example-pytest-selfie/uv.lock +++ b/python/example-pytest-selfie/uv.lock @@ -25,18 +25,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/a0/7a/4daaf3b6c08ad7ceffea4634ec206faeff697526421c20f07628c7372156/anyio-4.7.0-py3-none-any.whl", hash = "sha256:ea60c3723ab42ba6fff7e8ccb0488c898ec538ff4df1f1d5e642c3601d07e352", size = 93052 }, ] -[[package]] -name = "beautifulsoup4" -version = "4.12.3" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "soupsieve" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/b3/ca/824b1195773ce6166d388573fc106ce56d4a805bd7427b624e063596ec58/beautifulsoup4-4.12.3.tar.gz", hash = "sha256:74e3d1928edc070d21748185c46e3fb33490f22f52a3addee9aee0f4f7781051", size = 581181 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b1/fe/e8c672695b37eecc5cbf43e1d0638d88d66ba3a44c4d321c796f4e59167f/beautifulsoup4-4.12.3-py3-none-any.whl", hash = "sha256:b80878c9f40111313e55da8ba20bdba06d8fa3969fc68304167741bbf9e082ed", size = 147925 }, -] - [[package]] name = "blinker" version = "1.9.0" @@ -94,36 +82,12 @@ dependencies = [ { name = "openai" }, ] -[package.dev-dependencies] -dev = [ - { name = "beautifulsoup4" }, - { name = "markdownify" }, - { name = "pyright" }, - { name = "pytest" }, - { name = "pytest-selfie" }, - { name = "ruff" }, - { name = "selfie-lib" }, - { name = "werkzeug" }, -] - [package.metadata] requires-dist = [ { name = "flask", specifier = ">=3.0.3" }, { name = "openai", specifier = ">=1.0.0" }, ] -[package.metadata.requires-dev] -dev = [ - { name = "beautifulsoup4", specifier = ">=4.12.3" }, - { name = "markdownify", specifier = ">=0.12.1" }, - { name = "pyright", specifier = ">=1.1.350" }, - { name = "pytest", specifier = ">=8.0.0" }, - { name = "pytest-selfie", editable = "../pytest-selfie" }, - { name = "ruff", specifier = ">=0.5.0" }, - { name = "selfie-lib", editable = "../selfie-lib" }, - { name = "werkzeug", specifier = ">=3.0.3" }, -] - [[package]] name = "exceptiongroup" version = "1.2.2" @@ -208,15 +172,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/a0/d9/a1e041c5e7caa9a05c925f4bdbdfb7f006d1f74996af53467bc394c97be7/importlib_metadata-8.5.0-py3-none-any.whl", hash = "sha256:45e54197d28b7a7f1559e60b95e7c567032b602131fbd588f1497f47880aa68b", size = 26514 }, ] -[[package]] -name = "iniconfig" -version = "2.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d7/4b/cbd8e699e64a6f16ca3a8220661b5f83792b3017d0f79807cb8708d33913/iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3", size = 4646 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/ef/a6/62565a6e1cf69e10f5727360368e451d4b7f58beeac6173dc9db836a5b46/iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374", size = 5892 }, -] - [[package]] name = "itsdangerous" version = "2.2.0" @@ -309,19 +264,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/32/b7/a3cde72c644fd1caf9da07fb38cf2c130f43484d8f91011940b7c4f42c8f/jiter-0.8.2-cp39-cp39-win_amd64.whl", hash = "sha256:1c0dfbd1be3cbefc7510102370d86e35d1d53e5a93d48519688b1bf0f761160a", size = 207527 }, ] -[[package]] -name = "markdownify" -version = "0.14.1" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "beautifulsoup4" }, - { name = "six" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/1b/75/483a4bcca436fe88d02dc7686c372631d833848951b368700bdc0c770bb7/markdownify-0.14.1.tar.gz", hash = "sha256:a62a7a216947ed0b8dafb95b99b2ef4a0edd1e18d5653c656f68f03db2bfb2f1", size = 14332 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/65/0b/74cec93a7b05edf4fc3ea1c899fe8a37f041d7b9d303c75abf7a162924e0/markdownify-0.14.1-py3-none-any.whl", hash = "sha256:4c46a6c0c12c6005ddcd49b45a5a890398b002ef51380cd319db62df5e09bc2a", size = 11530 }, -] - [[package]] name = "markupsafe" version = "3.0.2" @@ -390,15 +332,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/b3/73/085399401383ce949f727afec55ec3abd76648d04b9f22e1c0e99cb4bec3/MarkupSafe-3.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:6e296a513ca3d94054c2c881cc913116e90fd030ad1c656b3869762b754f5f8a", size = 15506 }, ] -[[package]] -name = "nodeenv" -version = "1.9.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/43/16/fc88b08840de0e0a72a2f9d8c6bae36be573e475a6326ae854bcc549fc45/nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f", size = 47437 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d2/1d/1b658dbd2b9fa9c4c9f32accbfc0205d532c8c6194dc0f2a4c0428e7128a/nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9", size = 22314 }, -] - [[package]] name = "openai" version = "1.57.2" @@ -418,24 +351,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/37/e7/95437fb676381e927d4cb3f9f8dd90ed24cfd264f572db4d395037428594/openai-1.57.2-py3-none-any.whl", hash = "sha256:f7326283c156fdee875746e7e54d36959fb198eadc683952ee05e3302fbd638d", size = 389873 }, ] -[[package]] -name = "packaging" -version = "24.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451 }, -] - -[[package]] -name = "pluggy" -version = "1.5.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/96/2d/02d4312c973c6050a18b314a5ad0b3210edb65a906f868e31c111dede4a6/pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1", size = 67955 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669", size = 20556 }, -] - [[package]] name = "pydantic" version = "2.10.3" @@ -547,106 +462,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/fd/ab/718d9a1c41bb8d3e0e04d15b68b8afc135f8fcf552705b62f226225065c7/pydantic_core-2.27.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:62ba45e21cf6571d7f716d903b5b7b6d2617e2d5d67c0923dc47b9d41369f840", size = 2002035 }, ] -[[package]] -name = "pyright" -version = "1.1.390" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "nodeenv" }, - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/ba/42/1e0392f35dd275f9f775baf7c86407cef7f6a0d9b8e099a93e5422a7e571/pyright-1.1.390.tar.gz", hash = "sha256:aad7f160c49e0fbf8209507a15e17b781f63a86a1facb69ca877c71ef2e9538d", size = 21950 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/43/20/3f492ca789fb17962ad23619959c7fa642082621751514296c58de3bb801/pyright-1.1.390-py3-none-any.whl", hash = "sha256:ecebfba5b6b50af7c1a44c2ba144ba2ab542c227eb49bc1f16984ff714e0e110", size = 18579 }, -] - -[[package]] -name = "pytest" -version = "8.3.4" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "colorama", marker = "sys_platform == 'win32'" }, - { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, - { name = "iniconfig" }, - { name = "packaging" }, - { name = "pluggy" }, - { name = "tomli", marker = "python_full_version < '3.11'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/05/35/30e0d83068951d90a01852cb1cef56e5d8a09d20c7f511634cc2f7e0372a/pytest-8.3.4.tar.gz", hash = "sha256:965370d062bce11e73868e0335abac31b4d3de0e82f4007408d242b4f8610761", size = 1445919 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/11/92/76a1c94d3afee238333bc0a42b82935dd8f9cf8ce9e336ff87ee14d9e1cf/pytest-8.3.4-py3-none-any.whl", hash = "sha256:50e16d954148559c9a74109af1eaf0c945ba2d8f30f0a3d3335edde19788b6f6", size = 343083 }, -] - -[[package]] -name = "pytest-selfie" -version = "0.1.0" -source = { editable = "../pytest-selfie" } -dependencies = [ - { name = "pytest" }, - { name = "selfie-lib" }, -] - -[package.metadata] -requires-dist = [ - { name = "pytest", specifier = ">=8.0.0" }, - { name = "selfie-lib", editable = "../selfie-lib" }, -] - -[package.metadata.requires-dev] -dev = [ - { name = "pyright", specifier = ">=1.1.350" }, - { name = "pytest", specifier = ">=8.0.0" }, - { name = "ruff", specifier = ">=0.5.0" }, -] - -[[package]] -name = "ruff" -version = "0.8.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/5e/2b/01245f4f3a727d60bebeacd7ee6d22586c7f62380a2597ddb22c2f45d018/ruff-0.8.2.tar.gz", hash = "sha256:b84f4f414dda8ac7f75075c1fa0b905ac0ff25361f42e6d5da681a465e0f78e5", size = 3349020 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/91/29/366be70216dba1731a00a41f2f030822b0c96c7c4f3b2c0cdce15cbace74/ruff-0.8.2-py3-none-linux_armv6l.whl", hash = "sha256:c49ab4da37e7c457105aadfd2725e24305ff9bc908487a9bf8d548c6dad8bb3d", size = 10530649 }, - { url = "https://files.pythonhosted.org/packages/63/82/a733956540bb388f00df5a3e6a02467b16c0e529132625fe44ce4c5fb9c7/ruff-0.8.2-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:ec016beb69ac16be416c435828be702ee694c0d722505f9c1f35e1b9c0cc1bf5", size = 10274069 }, - { url = "https://files.pythonhosted.org/packages/3d/12/0b3aa14d1d71546c988a28e1b412981c1b80c8a1072e977a2f30c595cc4a/ruff-0.8.2-py3-none-macosx_11_0_arm64.whl", hash = "sha256:f05cdf8d050b30e2ba55c9b09330b51f9f97d36d4673213679b965d25a785f3c", size = 9909400 }, - { url = "https://files.pythonhosted.org/packages/23/08/f9f08cefb7921784c891c4151cce6ed357ff49e84b84978440cffbc87408/ruff-0.8.2-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:60f578c11feb1d3d257b2fb043ddb47501ab4816e7e221fbb0077f0d5d4e7b6f", size = 10766782 }, - { url = "https://files.pythonhosted.org/packages/e4/71/bf50c321ec179aa420c8ec40adac5ae9cc408d4d37283a485b19a2331ceb/ruff-0.8.2-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cbd5cf9b0ae8f30eebc7b360171bd50f59ab29d39f06a670b3e4501a36ba5897", size = 10286316 }, - { url = "https://files.pythonhosted.org/packages/f2/83/c82688a2a6117539aea0ce63fdf6c08e60fe0202779361223bcd7f40bd74/ruff-0.8.2-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b402ddee3d777683de60ff76da801fa7e5e8a71038f57ee53e903afbcefdaa58", size = 11338270 }, - { url = "https://files.pythonhosted.org/packages/7f/d7/bc6a45e5a22e627640388e703160afb1d77c572b1d0fda8b4349f334fc66/ruff-0.8.2-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:705832cd7d85605cb7858d8a13d75993c8f3ef1397b0831289109e953d833d29", size = 12058579 }, - { url = "https://files.pythonhosted.org/packages/da/3b/64150c93946ec851e6f1707ff586bb460ca671581380c919698d6a9267dc/ruff-0.8.2-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:32096b41aaf7a5cc095fa45b4167b890e4c8d3fd217603f3634c92a541de7248", size = 11615172 }, - { url = "https://files.pythonhosted.org/packages/e4/9e/cf12b697ea83cfe92ec4509ae414dc4c9b38179cc681a497031f0d0d9a8e/ruff-0.8.2-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e769083da9439508833cfc7c23e351e1809e67f47c50248250ce1ac52c21fb93", size = 12882398 }, - { url = "https://files.pythonhosted.org/packages/a9/27/96d10863accf76a9c97baceac30b0a52d917eb985a8ac058bd4636aeede0/ruff-0.8.2-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5fe716592ae8a376c2673fdfc1f5c0c193a6d0411f90a496863c99cd9e2ae25d", size = 11176094 }, - { url = "https://files.pythonhosted.org/packages/eb/10/cd2fd77d4a4e7f03c29351be0f53278a393186b540b99df68beb5304fddd/ruff-0.8.2-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:81c148825277e737493242b44c5388a300584d73d5774defa9245aaef55448b0", size = 10771884 }, - { url = "https://files.pythonhosted.org/packages/71/5d/beabb2ff18870fc4add05fa3a69a4cb1b1d2d6f83f3cf3ae5ab0d52f455d/ruff-0.8.2-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:d261d7850c8367704874847d95febc698a950bf061c9475d4a8b7689adc4f7fa", size = 10382535 }, - { url = "https://files.pythonhosted.org/packages/ae/29/6b3fdf3ad3e35b28d87c25a9ff4c8222ad72485ab783936b2b267250d7a7/ruff-0.8.2-py3-none-musllinux_1_2_i686.whl", hash = "sha256:1ca4e3a87496dc07d2427b7dd7ffa88a1e597c28dad65ae6433ecb9f2e4f022f", size = 10886995 }, - { url = "https://files.pythonhosted.org/packages/e9/dc/859d889b4d9356a1a2cdbc1e4a0dda94052bc5b5300098647e51a58c430b/ruff-0.8.2-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:729850feed82ef2440aa27946ab39c18cb4a8889c1128a6d589ffa028ddcfc22", size = 11220750 }, - { url = "https://files.pythonhosted.org/packages/0b/08/e8f519f61f1d624264bfd6b8829e4c5f31c3c61193bc3cff1f19dbe7626a/ruff-0.8.2-py3-none-win32.whl", hash = "sha256:ac42caaa0411d6a7d9594363294416e0e48fc1279e1b0e948391695db2b3d5b1", size = 8729396 }, - { url = "https://files.pythonhosted.org/packages/f8/d4/ba1c7ab72aba37a2b71fe48ab95b80546dbad7a7f35ea28cf66fc5cea5f6/ruff-0.8.2-py3-none-win_amd64.whl", hash = "sha256:2aae99ec70abf43372612a838d97bfe77d45146254568d94926e8ed5bbb409ea", size = 9594729 }, - { url = "https://files.pythonhosted.org/packages/23/34/db20e12d3db11b8a2a8874258f0f6d96a9a4d631659d54575840557164c8/ruff-0.8.2-py3-none-win_arm64.whl", hash = "sha256:fb88e2a506b70cfbc2de6fae6681c4f944f7dd5f2fe87233a7233d888bad73e8", size = 9035131 }, -] - -[[package]] -name = "selfie-lib" -version = "0.1.0" -source = { editable = "../selfie-lib" } - -[package.metadata] - -[package.metadata.requires-dev] -dev = [ - { name = "pyright", specifier = ">=1.1.350" }, - { name = "pytest", specifier = ">=8.0.0" }, - { name = "ruff", specifier = ">=0.5.0" }, -] - -[[package]] -name = "six" -version = "1.17.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050 }, -] - [[package]] name = "sniffio" version = "1.3.1" @@ -656,54 +471,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235 }, ] -[[package]] -name = "soupsieve" -version = "2.6" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d7/ce/fbaeed4f9fb8b2daa961f90591662df6a86c1abf25c548329a86920aedfb/soupsieve-2.6.tar.gz", hash = "sha256:e2e68417777af359ec65daac1057404a3c8a5455bb8abc36f1a9866ab1a51abb", size = 101569 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d1/c2/fe97d779f3ef3b15f05c94a2f1e3d21732574ed441687474db9d342a7315/soupsieve-2.6-py3-none-any.whl", hash = "sha256:e72c4ff06e4fb6e4b5a9f0f55fe6e81514581fca1515028625d0f299c602ccc9", size = 36186 }, -] - -[[package]] -name = "tomli" -version = "2.2.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/18/87/302344fed471e44a87289cf4967697d07e532f2421fdaf868a303cbae4ff/tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff", size = 17175 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/43/ca/75707e6efa2b37c77dadb324ae7d9571cb424e61ea73fad7c56c2d14527f/tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249", size = 131077 }, - { url = "https://files.pythonhosted.org/packages/c7/16/51ae563a8615d472fdbffc43a3f3d46588c264ac4f024f63f01283becfbb/tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6", size = 123429 }, - { url = "https://files.pythonhosted.org/packages/f1/dd/4f6cd1e7b160041db83c694abc78e100473c15d54620083dbd5aae7b990e/tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a", size = 226067 }, - { url = "https://files.pythonhosted.org/packages/a9/6b/c54ede5dc70d648cc6361eaf429304b02f2871a345bbdd51e993d6cdf550/tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee", size = 236030 }, - { url = "https://files.pythonhosted.org/packages/1f/47/999514fa49cfaf7a92c805a86c3c43f4215621855d151b61c602abb38091/tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e", size = 240898 }, - { url = "https://files.pythonhosted.org/packages/73/41/0a01279a7ae09ee1573b423318e7934674ce06eb33f50936655071d81a24/tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4", size = 229894 }, - { url = "https://files.pythonhosted.org/packages/55/18/5d8bc5b0a0362311ce4d18830a5d28943667599a60d20118074ea1b01bb7/tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106", size = 245319 }, - { url = "https://files.pythonhosted.org/packages/92/a3/7ade0576d17f3cdf5ff44d61390d4b3febb8a9fc2b480c75c47ea048c646/tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8", size = 238273 }, - { url = "https://files.pythonhosted.org/packages/72/6f/fa64ef058ac1446a1e51110c375339b3ec6be245af9d14c87c4a6412dd32/tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff", size = 98310 }, - { url = "https://files.pythonhosted.org/packages/6a/1c/4a2dcde4a51b81be3530565e92eda625d94dafb46dbeb15069df4caffc34/tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b", size = 108309 }, - { url = "https://files.pythonhosted.org/packages/52/e1/f8af4c2fcde17500422858155aeb0d7e93477a0d59a98e56cbfe75070fd0/tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea", size = 132762 }, - { url = "https://files.pythonhosted.org/packages/03/b8/152c68bb84fc00396b83e7bbddd5ec0bd3dd409db4195e2a9b3e398ad2e3/tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8", size = 123453 }, - { url = "https://files.pythonhosted.org/packages/c8/d6/fc9267af9166f79ac528ff7e8c55c8181ded34eb4b0e93daa767b8841573/tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192", size = 233486 }, - { url = "https://files.pythonhosted.org/packages/5c/51/51c3f2884d7bab89af25f678447ea7d297b53b5a3b5730a7cb2ef6069f07/tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222", size = 242349 }, - { url = "https://files.pythonhosted.org/packages/ab/df/bfa89627d13a5cc22402e441e8a931ef2108403db390ff3345c05253935e/tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77", size = 252159 }, - { url = "https://files.pythonhosted.org/packages/9e/6e/fa2b916dced65763a5168c6ccb91066f7639bdc88b48adda990db10c8c0b/tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6", size = 237243 }, - { url = "https://files.pythonhosted.org/packages/b4/04/885d3b1f650e1153cbb93a6a9782c58a972b94ea4483ae4ac5cedd5e4a09/tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd", size = 259645 }, - { url = "https://files.pythonhosted.org/packages/9c/de/6b432d66e986e501586da298e28ebeefd3edc2c780f3ad73d22566034239/tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e", size = 244584 }, - { url = "https://files.pythonhosted.org/packages/1c/9a/47c0449b98e6e7d1be6cbac02f93dd79003234ddc4aaab6ba07a9a7482e2/tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98", size = 98875 }, - { url = "https://files.pythonhosted.org/packages/ef/60/9b9638f081c6f1261e2688bd487625cd1e660d0a85bd469e91d8db969734/tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4", size = 109418 }, - { url = "https://files.pythonhosted.org/packages/04/90/2ee5f2e0362cb8a0b6499dc44f4d7d48f8fff06d28ba46e6f1eaa61a1388/tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7", size = 132708 }, - { url = "https://files.pythonhosted.org/packages/c0/ec/46b4108816de6b385141f082ba99e315501ccd0a2ea23db4a100dd3990ea/tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c", size = 123582 }, - { url = "https://files.pythonhosted.org/packages/a0/bd/b470466d0137b37b68d24556c38a0cc819e8febe392d5b199dcd7f578365/tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13", size = 232543 }, - { url = "https://files.pythonhosted.org/packages/d9/e5/82e80ff3b751373f7cead2815bcbe2d51c895b3c990686741a8e56ec42ab/tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281", size = 241691 }, - { url = "https://files.pythonhosted.org/packages/05/7e/2a110bc2713557d6a1bfb06af23dd01e7dde52b6ee7dadc589868f9abfac/tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272", size = 251170 }, - { url = "https://files.pythonhosted.org/packages/64/7b/22d713946efe00e0adbcdfd6d1aa119ae03fd0b60ebed51ebb3fa9f5a2e5/tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140", size = 236530 }, - { url = "https://files.pythonhosted.org/packages/38/31/3a76f67da4b0cf37b742ca76beaf819dca0ebef26d78fc794a576e08accf/tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2", size = 258666 }, - { url = "https://files.pythonhosted.org/packages/07/10/5af1293da642aded87e8a988753945d0cf7e00a9452d3911dd3bb354c9e2/tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744", size = 243954 }, - { url = "https://files.pythonhosted.org/packages/5b/b9/1ed31d167be802da0fc95020d04cd27b7d7065cc6fbefdd2f9186f60d7bd/tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec", size = 98724 }, - { url = "https://files.pythonhosted.org/packages/c7/32/b0963458706accd9afcfeb867c0f9175a741bf7b19cd424230714d722198/tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69", size = 109383 }, - { url = "https://files.pythonhosted.org/packages/6e/c2/61d3e0f47e2b74ef40a68b9e6ad5984f6241a942f7cd3bbfbdbd03861ea9/tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc", size = 14257 }, -] - [[package]] name = "tqdm" version = "4.67.1" diff --git a/python/pytest-selfie/uv.lock b/python/pytest-selfie/uv.lock index e88aa100..bc4bcccb 100644 --- a/python/pytest-selfie/uv.lock +++ b/python/pytest-selfie/uv.lock @@ -28,15 +28,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/ef/a6/62565a6e1cf69e10f5727360368e451d4b7f58beeac6173dc9db836a5b46/iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374", size = 5892 }, ] -[[package]] -name = "nodeenv" -version = "1.9.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/43/16/fc88b08840de0e0a72a2f9d8c6bae36be573e475a6326ae854bcc549fc45/nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f", size = 47437 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d2/1d/1b658dbd2b9fa9c4c9f32accbfc0205d532c8c6194dc0f2a4c0428e7128a/nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9", size = 22314 }, -] - [[package]] name = "packaging" version = "24.2" @@ -55,19 +46,6 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669", size = 20556 }, ] -[[package]] -name = "pyright" -version = "1.1.390" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "nodeenv" }, - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/ba/42/1e0392f35dd275f9f775baf7c86407cef7f6a0d9b8e099a93e5422a7e571/pyright-1.1.390.tar.gz", hash = "sha256:aad7f160c49e0fbf8209507a15e17b781f63a86a1facb69ca877c71ef2e9538d", size = 21950 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/43/20/3f492ca789fb17962ad23619959c7fa642082621751514296c58de3bb801/pyright-1.1.390-py3-none-any.whl", hash = "sha256:ecebfba5b6b50af7c1a44c2ba144ba2ab542c227eb49bc1f16984ff714e0e110", size = 18579 }, -] - [[package]] name = "pytest" version = "8.3.4" @@ -94,65 +72,17 @@ dependencies = [ { name = "selfie-lib" }, ] -[package.dev-dependencies] -dev = [ - { name = "pyright" }, - { name = "pytest" }, - { name = "ruff" }, -] - [package.metadata] requires-dist = [ { name = "pytest", specifier = ">=8.0.0" }, { name = "selfie-lib", editable = "../selfie-lib" }, ] -[package.metadata.requires-dev] -dev = [ - { name = "pyright", specifier = ">=1.1.350" }, - { name = "pytest", specifier = ">=8.0.0" }, - { name = "ruff", specifier = ">=0.5.0" }, -] - -[[package]] -name = "ruff" -version = "0.8.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/5e/2b/01245f4f3a727d60bebeacd7ee6d22586c7f62380a2597ddb22c2f45d018/ruff-0.8.2.tar.gz", hash = "sha256:b84f4f414dda8ac7f75075c1fa0b905ac0ff25361f42e6d5da681a465e0f78e5", size = 3349020 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/91/29/366be70216dba1731a00a41f2f030822b0c96c7c4f3b2c0cdce15cbace74/ruff-0.8.2-py3-none-linux_armv6l.whl", hash = "sha256:c49ab4da37e7c457105aadfd2725e24305ff9bc908487a9bf8d548c6dad8bb3d", size = 10530649 }, - { url = "https://files.pythonhosted.org/packages/63/82/a733956540bb388f00df5a3e6a02467b16c0e529132625fe44ce4c5fb9c7/ruff-0.8.2-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:ec016beb69ac16be416c435828be702ee694c0d722505f9c1f35e1b9c0cc1bf5", size = 10274069 }, - { url = "https://files.pythonhosted.org/packages/3d/12/0b3aa14d1d71546c988a28e1b412981c1b80c8a1072e977a2f30c595cc4a/ruff-0.8.2-py3-none-macosx_11_0_arm64.whl", hash = "sha256:f05cdf8d050b30e2ba55c9b09330b51f9f97d36d4673213679b965d25a785f3c", size = 9909400 }, - { url = "https://files.pythonhosted.org/packages/23/08/f9f08cefb7921784c891c4151cce6ed357ff49e84b84978440cffbc87408/ruff-0.8.2-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:60f578c11feb1d3d257b2fb043ddb47501ab4816e7e221fbb0077f0d5d4e7b6f", size = 10766782 }, - { url = "https://files.pythonhosted.org/packages/e4/71/bf50c321ec179aa420c8ec40adac5ae9cc408d4d37283a485b19a2331ceb/ruff-0.8.2-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cbd5cf9b0ae8f30eebc7b360171bd50f59ab29d39f06a670b3e4501a36ba5897", size = 10286316 }, - { url = "https://files.pythonhosted.org/packages/f2/83/c82688a2a6117539aea0ce63fdf6c08e60fe0202779361223bcd7f40bd74/ruff-0.8.2-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b402ddee3d777683de60ff76da801fa7e5e8a71038f57ee53e903afbcefdaa58", size = 11338270 }, - { url = "https://files.pythonhosted.org/packages/7f/d7/bc6a45e5a22e627640388e703160afb1d77c572b1d0fda8b4349f334fc66/ruff-0.8.2-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:705832cd7d85605cb7858d8a13d75993c8f3ef1397b0831289109e953d833d29", size = 12058579 }, - { url = "https://files.pythonhosted.org/packages/da/3b/64150c93946ec851e6f1707ff586bb460ca671581380c919698d6a9267dc/ruff-0.8.2-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:32096b41aaf7a5cc095fa45b4167b890e4c8d3fd217603f3634c92a541de7248", size = 11615172 }, - { url = "https://files.pythonhosted.org/packages/e4/9e/cf12b697ea83cfe92ec4509ae414dc4c9b38179cc681a497031f0d0d9a8e/ruff-0.8.2-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e769083da9439508833cfc7c23e351e1809e67f47c50248250ce1ac52c21fb93", size = 12882398 }, - { url = "https://files.pythonhosted.org/packages/a9/27/96d10863accf76a9c97baceac30b0a52d917eb985a8ac058bd4636aeede0/ruff-0.8.2-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5fe716592ae8a376c2673fdfc1f5c0c193a6d0411f90a496863c99cd9e2ae25d", size = 11176094 }, - { url = "https://files.pythonhosted.org/packages/eb/10/cd2fd77d4a4e7f03c29351be0f53278a393186b540b99df68beb5304fddd/ruff-0.8.2-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:81c148825277e737493242b44c5388a300584d73d5774defa9245aaef55448b0", size = 10771884 }, - { url = "https://files.pythonhosted.org/packages/71/5d/beabb2ff18870fc4add05fa3a69a4cb1b1d2d6f83f3cf3ae5ab0d52f455d/ruff-0.8.2-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:d261d7850c8367704874847d95febc698a950bf061c9475d4a8b7689adc4f7fa", size = 10382535 }, - { url = "https://files.pythonhosted.org/packages/ae/29/6b3fdf3ad3e35b28d87c25a9ff4c8222ad72485ab783936b2b267250d7a7/ruff-0.8.2-py3-none-musllinux_1_2_i686.whl", hash = "sha256:1ca4e3a87496dc07d2427b7dd7ffa88a1e597c28dad65ae6433ecb9f2e4f022f", size = 10886995 }, - { url = "https://files.pythonhosted.org/packages/e9/dc/859d889b4d9356a1a2cdbc1e4a0dda94052bc5b5300098647e51a58c430b/ruff-0.8.2-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:729850feed82ef2440aa27946ab39c18cb4a8889c1128a6d589ffa028ddcfc22", size = 11220750 }, - { url = "https://files.pythonhosted.org/packages/0b/08/e8f519f61f1d624264bfd6b8829e4c5f31c3c61193bc3cff1f19dbe7626a/ruff-0.8.2-py3-none-win32.whl", hash = "sha256:ac42caaa0411d6a7d9594363294416e0e48fc1279e1b0e948391695db2b3d5b1", size = 8729396 }, - { url = "https://files.pythonhosted.org/packages/f8/d4/ba1c7ab72aba37a2b71fe48ab95b80546dbad7a7f35ea28cf66fc5cea5f6/ruff-0.8.2-py3-none-win_amd64.whl", hash = "sha256:2aae99ec70abf43372612a838d97bfe77d45146254568d94926e8ed5bbb409ea", size = 9594729 }, - { url = "https://files.pythonhosted.org/packages/23/34/db20e12d3db11b8a2a8874258f0f6d96a9a4d631659d54575840557164c8/ruff-0.8.2-py3-none-win_arm64.whl", hash = "sha256:fb88e2a506b70cfbc2de6fae6681c4f944f7dd5f2fe87233a7233d888bad73e8", size = 9035131 }, -] - [[package]] name = "selfie-lib" version = "0.1.0" source = { editable = "../selfie-lib" } -[package.metadata] - -[package.metadata.requires-dev] -dev = [ - { name = "pyright", specifier = ">=1.1.350" }, - { name = "pytest", specifier = ">=8.0.0" }, - { name = "ruff", specifier = ">=0.5.0" }, -] - [[package]] name = "tomli" version = "2.2.1" @@ -191,12 +121,3 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/c7/32/b0963458706accd9afcfeb867c0f9175a741bf7b19cd424230714d722198/tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69", size = 109383 }, { url = "https://files.pythonhosted.org/packages/6e/c2/61d3e0f47e2b74ef40a68b9e6ad5984f6241a942f7cd3bbfbdbd03861ea9/tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc", size = 14257 }, ] - -[[package]] -name = "typing-extensions" -version = "4.12.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438 }, -] diff --git a/python/selfie-lib/uv.lock b/python/selfie-lib/uv.lock index 31db4b95..b76d6dc0 100644 --- a/python/selfie-lib/uv.lock +++ b/python/selfie-lib/uv.lock @@ -1,180 +1,7 @@ version = 1 requires-python = ">=3.9" -[[package]] -name = "colorama" -version = "0.4.6" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 }, -] - -[[package]] -name = "exceptiongroup" -version = "1.2.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/09/35/2495c4ac46b980e4ca1f6ad6db102322ef3ad2410b79fdde159a4b0f3b92/exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc", size = 28883 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/02/cc/b7e31358aac6ed1ef2bb790a9746ac2c69bcb3c8588b41616914eb106eaf/exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b", size = 16453 }, -] - -[[package]] -name = "iniconfig" -version = "2.0.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d7/4b/cbd8e699e64a6f16ca3a8220661b5f83792b3017d0f79807cb8708d33913/iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3", size = 4646 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/ef/a6/62565a6e1cf69e10f5727360368e451d4b7f58beeac6173dc9db836a5b46/iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374", size = 5892 }, -] - -[[package]] -name = "nodeenv" -version = "1.9.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/43/16/fc88b08840de0e0a72a2f9d8c6bae36be573e475a6326ae854bcc549fc45/nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f", size = 47437 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d2/1d/1b658dbd2b9fa9c4c9f32accbfc0205d532c8c6194dc0f2a4c0428e7128a/nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9", size = 22314 }, -] - -[[package]] -name = "packaging" -version = "24.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451 }, -] - -[[package]] -name = "pluggy" -version = "1.5.0" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/96/2d/02d4312c973c6050a18b314a5ad0b3210edb65a906f868e31c111dede4a6/pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1", size = 67955 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669", size = 20556 }, -] - -[[package]] -name = "pyright" -version = "1.1.390" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "nodeenv" }, - { name = "typing-extensions" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/ba/42/1e0392f35dd275f9f775baf7c86407cef7f6a0d9b8e099a93e5422a7e571/pyright-1.1.390.tar.gz", hash = "sha256:aad7f160c49e0fbf8209507a15e17b781f63a86a1facb69ca877c71ef2e9538d", size = 21950 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/43/20/3f492ca789fb17962ad23619959c7fa642082621751514296c58de3bb801/pyright-1.1.390-py3-none-any.whl", hash = "sha256:ecebfba5b6b50af7c1a44c2ba144ba2ab542c227eb49bc1f16984ff714e0e110", size = 18579 }, -] - -[[package]] -name = "pytest" -version = "8.3.4" -source = { registry = "https://pypi.org/simple" } -dependencies = [ - { name = "colorama", marker = "sys_platform == 'win32'" }, - { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, - { name = "iniconfig" }, - { name = "packaging" }, - { name = "pluggy" }, - { name = "tomli", marker = "python_full_version < '3.11'" }, -] -sdist = { url = "https://files.pythonhosted.org/packages/05/35/30e0d83068951d90a01852cb1cef56e5d8a09d20c7f511634cc2f7e0372a/pytest-8.3.4.tar.gz", hash = "sha256:965370d062bce11e73868e0335abac31b4d3de0e82f4007408d242b4f8610761", size = 1445919 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/11/92/76a1c94d3afee238333bc0a42b82935dd8f9cf8ce9e336ff87ee14d9e1cf/pytest-8.3.4-py3-none-any.whl", hash = "sha256:50e16d954148559c9a74109af1eaf0c945ba2d8f30f0a3d3335edde19788b6f6", size = 343083 }, -] - -[[package]] -name = "ruff" -version = "0.8.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/5e/2b/01245f4f3a727d60bebeacd7ee6d22586c7f62380a2597ddb22c2f45d018/ruff-0.8.2.tar.gz", hash = "sha256:b84f4f414dda8ac7f75075c1fa0b905ac0ff25361f42e6d5da681a465e0f78e5", size = 3349020 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/91/29/366be70216dba1731a00a41f2f030822b0c96c7c4f3b2c0cdce15cbace74/ruff-0.8.2-py3-none-linux_armv6l.whl", hash = "sha256:c49ab4da37e7c457105aadfd2725e24305ff9bc908487a9bf8d548c6dad8bb3d", size = 10530649 }, - { url = "https://files.pythonhosted.org/packages/63/82/a733956540bb388f00df5a3e6a02467b16c0e529132625fe44ce4c5fb9c7/ruff-0.8.2-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:ec016beb69ac16be416c435828be702ee694c0d722505f9c1f35e1b9c0cc1bf5", size = 10274069 }, - { url = "https://files.pythonhosted.org/packages/3d/12/0b3aa14d1d71546c988a28e1b412981c1b80c8a1072e977a2f30c595cc4a/ruff-0.8.2-py3-none-macosx_11_0_arm64.whl", hash = "sha256:f05cdf8d050b30e2ba55c9b09330b51f9f97d36d4673213679b965d25a785f3c", size = 9909400 }, - { url = "https://files.pythonhosted.org/packages/23/08/f9f08cefb7921784c891c4151cce6ed357ff49e84b84978440cffbc87408/ruff-0.8.2-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:60f578c11feb1d3d257b2fb043ddb47501ab4816e7e221fbb0077f0d5d4e7b6f", size = 10766782 }, - { url = "https://files.pythonhosted.org/packages/e4/71/bf50c321ec179aa420c8ec40adac5ae9cc408d4d37283a485b19a2331ceb/ruff-0.8.2-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cbd5cf9b0ae8f30eebc7b360171bd50f59ab29d39f06a670b3e4501a36ba5897", size = 10286316 }, - { url = "https://files.pythonhosted.org/packages/f2/83/c82688a2a6117539aea0ce63fdf6c08e60fe0202779361223bcd7f40bd74/ruff-0.8.2-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b402ddee3d777683de60ff76da801fa7e5e8a71038f57ee53e903afbcefdaa58", size = 11338270 }, - { url = "https://files.pythonhosted.org/packages/7f/d7/bc6a45e5a22e627640388e703160afb1d77c572b1d0fda8b4349f334fc66/ruff-0.8.2-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:705832cd7d85605cb7858d8a13d75993c8f3ef1397b0831289109e953d833d29", size = 12058579 }, - { url = "https://files.pythonhosted.org/packages/da/3b/64150c93946ec851e6f1707ff586bb460ca671581380c919698d6a9267dc/ruff-0.8.2-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:32096b41aaf7a5cc095fa45b4167b890e4c8d3fd217603f3634c92a541de7248", size = 11615172 }, - { url = "https://files.pythonhosted.org/packages/e4/9e/cf12b697ea83cfe92ec4509ae414dc4c9b38179cc681a497031f0d0d9a8e/ruff-0.8.2-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e769083da9439508833cfc7c23e351e1809e67f47c50248250ce1ac52c21fb93", size = 12882398 }, - { url = "https://files.pythonhosted.org/packages/a9/27/96d10863accf76a9c97baceac30b0a52d917eb985a8ac058bd4636aeede0/ruff-0.8.2-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5fe716592ae8a376c2673fdfc1f5c0c193a6d0411f90a496863c99cd9e2ae25d", size = 11176094 }, - { url = "https://files.pythonhosted.org/packages/eb/10/cd2fd77d4a4e7f03c29351be0f53278a393186b540b99df68beb5304fddd/ruff-0.8.2-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:81c148825277e737493242b44c5388a300584d73d5774defa9245aaef55448b0", size = 10771884 }, - { url = "https://files.pythonhosted.org/packages/71/5d/beabb2ff18870fc4add05fa3a69a4cb1b1d2d6f83f3cf3ae5ab0d52f455d/ruff-0.8.2-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:d261d7850c8367704874847d95febc698a950bf061c9475d4a8b7689adc4f7fa", size = 10382535 }, - { url = "https://files.pythonhosted.org/packages/ae/29/6b3fdf3ad3e35b28d87c25a9ff4c8222ad72485ab783936b2b267250d7a7/ruff-0.8.2-py3-none-musllinux_1_2_i686.whl", hash = "sha256:1ca4e3a87496dc07d2427b7dd7ffa88a1e597c28dad65ae6433ecb9f2e4f022f", size = 10886995 }, - { url = "https://files.pythonhosted.org/packages/e9/dc/859d889b4d9356a1a2cdbc1e4a0dda94052bc5b5300098647e51a58c430b/ruff-0.8.2-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:729850feed82ef2440aa27946ab39c18cb4a8889c1128a6d589ffa028ddcfc22", size = 11220750 }, - { url = "https://files.pythonhosted.org/packages/0b/08/e8f519f61f1d624264bfd6b8829e4c5f31c3c61193bc3cff1f19dbe7626a/ruff-0.8.2-py3-none-win32.whl", hash = "sha256:ac42caaa0411d6a7d9594363294416e0e48fc1279e1b0e948391695db2b3d5b1", size = 8729396 }, - { url = "https://files.pythonhosted.org/packages/f8/d4/ba1c7ab72aba37a2b71fe48ab95b80546dbad7a7f35ea28cf66fc5cea5f6/ruff-0.8.2-py3-none-win_amd64.whl", hash = "sha256:2aae99ec70abf43372612a838d97bfe77d45146254568d94926e8ed5bbb409ea", size = 9594729 }, - { url = "https://files.pythonhosted.org/packages/23/34/db20e12d3db11b8a2a8874258f0f6d96a9a4d631659d54575840557164c8/ruff-0.8.2-py3-none-win_arm64.whl", hash = "sha256:fb88e2a506b70cfbc2de6fae6681c4f944f7dd5f2fe87233a7233d888bad73e8", size = 9035131 }, -] - [[package]] name = "selfie-lib" version = "0.1.0" source = { virtual = "." } - -[package.dev-dependencies] -dev = [ - { name = "pyright" }, - { name = "pytest" }, - { name = "ruff" }, -] - -[package.metadata] - -[package.metadata.requires-dev] -dev = [ - { name = "pyright", specifier = ">=1.1.350" }, - { name = "pytest", specifier = ">=8.0.0" }, - { name = "ruff", specifier = ">=0.5.0" }, -] - -[[package]] -name = "tomli" -version = "2.2.1" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/18/87/302344fed471e44a87289cf4967697d07e532f2421fdaf868a303cbae4ff/tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff", size = 17175 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/43/ca/75707e6efa2b37c77dadb324ae7d9571cb424e61ea73fad7c56c2d14527f/tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249", size = 131077 }, - { url = "https://files.pythonhosted.org/packages/c7/16/51ae563a8615d472fdbffc43a3f3d46588c264ac4f024f63f01283becfbb/tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6", size = 123429 }, - { url = "https://files.pythonhosted.org/packages/f1/dd/4f6cd1e7b160041db83c694abc78e100473c15d54620083dbd5aae7b990e/tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a", size = 226067 }, - { url = "https://files.pythonhosted.org/packages/a9/6b/c54ede5dc70d648cc6361eaf429304b02f2871a345bbdd51e993d6cdf550/tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee", size = 236030 }, - { url = "https://files.pythonhosted.org/packages/1f/47/999514fa49cfaf7a92c805a86c3c43f4215621855d151b61c602abb38091/tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e", size = 240898 }, - { url = "https://files.pythonhosted.org/packages/73/41/0a01279a7ae09ee1573b423318e7934674ce06eb33f50936655071d81a24/tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4", size = 229894 }, - { url = "https://files.pythonhosted.org/packages/55/18/5d8bc5b0a0362311ce4d18830a5d28943667599a60d20118074ea1b01bb7/tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106", size = 245319 }, - { url = "https://files.pythonhosted.org/packages/92/a3/7ade0576d17f3cdf5ff44d61390d4b3febb8a9fc2b480c75c47ea048c646/tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8", size = 238273 }, - { url = "https://files.pythonhosted.org/packages/72/6f/fa64ef058ac1446a1e51110c375339b3ec6be245af9d14c87c4a6412dd32/tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff", size = 98310 }, - { url = "https://files.pythonhosted.org/packages/6a/1c/4a2dcde4a51b81be3530565e92eda625d94dafb46dbeb15069df4caffc34/tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b", size = 108309 }, - { url = "https://files.pythonhosted.org/packages/52/e1/f8af4c2fcde17500422858155aeb0d7e93477a0d59a98e56cbfe75070fd0/tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea", size = 132762 }, - { url = "https://files.pythonhosted.org/packages/03/b8/152c68bb84fc00396b83e7bbddd5ec0bd3dd409db4195e2a9b3e398ad2e3/tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8", size = 123453 }, - { url = "https://files.pythonhosted.org/packages/c8/d6/fc9267af9166f79ac528ff7e8c55c8181ded34eb4b0e93daa767b8841573/tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192", size = 233486 }, - { url = "https://files.pythonhosted.org/packages/5c/51/51c3f2884d7bab89af25f678447ea7d297b53b5a3b5730a7cb2ef6069f07/tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222", size = 242349 }, - { url = "https://files.pythonhosted.org/packages/ab/df/bfa89627d13a5cc22402e441e8a931ef2108403db390ff3345c05253935e/tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77", size = 252159 }, - { url = "https://files.pythonhosted.org/packages/9e/6e/fa2b916dced65763a5168c6ccb91066f7639bdc88b48adda990db10c8c0b/tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6", size = 237243 }, - { url = "https://files.pythonhosted.org/packages/b4/04/885d3b1f650e1153cbb93a6a9782c58a972b94ea4483ae4ac5cedd5e4a09/tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd", size = 259645 }, - { url = "https://files.pythonhosted.org/packages/9c/de/6b432d66e986e501586da298e28ebeefd3edc2c780f3ad73d22566034239/tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e", size = 244584 }, - { url = "https://files.pythonhosted.org/packages/1c/9a/47c0449b98e6e7d1be6cbac02f93dd79003234ddc4aaab6ba07a9a7482e2/tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98", size = 98875 }, - { url = "https://files.pythonhosted.org/packages/ef/60/9b9638f081c6f1261e2688bd487625cd1e660d0a85bd469e91d8db969734/tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4", size = 109418 }, - { url = "https://files.pythonhosted.org/packages/04/90/2ee5f2e0362cb8a0b6499dc44f4d7d48f8fff06d28ba46e6f1eaa61a1388/tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7", size = 132708 }, - { url = "https://files.pythonhosted.org/packages/c0/ec/46b4108816de6b385141f082ba99e315501ccd0a2ea23db4a100dd3990ea/tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c", size = 123582 }, - { url = "https://files.pythonhosted.org/packages/a0/bd/b470466d0137b37b68d24556c38a0cc819e8febe392d5b199dcd7f578365/tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13", size = 232543 }, - { url = "https://files.pythonhosted.org/packages/d9/e5/82e80ff3b751373f7cead2815bcbe2d51c895b3c990686741a8e56ec42ab/tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281", size = 241691 }, - { url = "https://files.pythonhosted.org/packages/05/7e/2a110bc2713557d6a1bfb06af23dd01e7dde52b6ee7dadc589868f9abfac/tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272", size = 251170 }, - { url = "https://files.pythonhosted.org/packages/64/7b/22d713946efe00e0adbcdfd6d1aa119ae03fd0b60ebed51ebb3fa9f5a2e5/tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140", size = 236530 }, - { url = "https://files.pythonhosted.org/packages/38/31/3a76f67da4b0cf37b742ca76beaf819dca0ebef26d78fc794a576e08accf/tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2", size = 258666 }, - { url = "https://files.pythonhosted.org/packages/07/10/5af1293da642aded87e8a988753945d0cf7e00a9452d3911dd3bb354c9e2/tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744", size = 243954 }, - { url = "https://files.pythonhosted.org/packages/5b/b9/1ed31d167be802da0fc95020d04cd27b7d7065cc6fbefdd2f9186f60d7bd/tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec", size = 98724 }, - { url = "https://files.pythonhosted.org/packages/c7/32/b0963458706accd9afcfeb867c0f9175a741bf7b19cd424230714d722198/tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69", size = 109383 }, - { url = "https://files.pythonhosted.org/packages/6e/c2/61d3e0f47e2b74ef40a68b9e6ad5984f6241a942f7cd3bbfbdbd03861ea9/tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc", size = 14257 }, -] - -[[package]] -name = "typing-extensions" -version = "4.12.2" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321 } -wheels = [ - { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438 }, -] From b603d257656f51941900f0b6cf97479643c6556a Mon Sep 17 00:00:00 2001 From: Ned Twigg Date: Fri, 13 Dec 2024 02:25:14 -0800 Subject: [PATCH 29/30] Even a bit better. --- python/example-pytest-selfie/tests/binary_test.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/python/example-pytest-selfie/tests/binary_test.py b/python/example-pytest-selfie/tests/binary_test.py index fe000d5a..052642e0 100644 --- a/python/example-pytest-selfie/tests/binary_test.py +++ b/python/example-pytest-selfie/tests/binary_test.py @@ -31,6 +31,20 @@ def test_binary_file_duplicate_equal(): ) +def test_binary_file_duplicate_equal(): + """Test writing same binary data to a file multiple times""" + with pytest.raises(Exception) as exc_info: + expect_selfie(b"a").to_be_file( + "tests/binary_test__test_binary_file_duplicate_unequal.bin" + ) + expect_selfie(b"b").to_be_file( + "tests/binary_test__test_binary_file_duplicate_unequal.bin" + ) + expect_selfie(safify(str(exc_info.value))).to_be( + "Snapshot mismatch, TODO: string comparison" + ) + + def test_binary_file_mismatch(): """Test error handling for mismatched binary data""" with pytest.raises(AssertionError): From 24a8029a2b0b161d605e97512fd62d9fbe79690d Mon Sep 17 00:00:00 2001 From: Ned Twigg Date: Fri, 13 Dec 2024 02:27:31 -0800 Subject: [PATCH 30/30] Another fix. --- python/example-pytest-selfie/tests/binary_test.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/python/example-pytest-selfie/tests/binary_test.py b/python/example-pytest-selfie/tests/binary_test.py index 052642e0..b4b563ed 100644 --- a/python/example-pytest-selfie/tests/binary_test.py +++ b/python/example-pytest-selfie/tests/binary_test.py @@ -31,7 +31,7 @@ def test_binary_file_duplicate_equal(): ) -def test_binary_file_duplicate_equal(): +def test_binary_file_duplicate_unequal(): """Test writing same binary data to a file multiple times""" with pytest.raises(Exception) as exc_info: expect_selfie(b"a").to_be_file(