selfie_lib.SelfieImplementations Namespace Reference

Classes
class	BinaryFacet
class	BinarySelfie
class	DiskSelfie
class	FluentFacet
class	ReprSelfie
class	StringFacet
class	StringSelfie

Functions
T	_check_src (T value)
T	_to_be_didnt_match (Optional[T] expected, T actual, LiteralFormat[T] fmt)
	_assert_equal (Optional[Snapshot] expected, Snapshot actual, SnapshotSystem storage)
str	_serialize_only_facets (Snapshot snapshot, list[str] keys)

Variables
	T = TypeVar("T")

Function Documentation

_assert_equal()

selfie_lib.SelfieImplementations._assert_equal ( Optional[Snapshot]  expected, Snapshot  actual, SnapshotSystem   storage  )

protected

Definition at line 289 of file SelfieImplementations.py.

):
    if expected is None:
        raise storage.fs.assert_failed(message=storage.mode.msg_snapshot_not_found())
    elif expected == actual:
        return
    else:
        mismatched_keys = sorted(
            filter(
                lambda facet: expected.subject_or_facet_maybe(facet)
                != actual.subject_or_facet_maybe(facet),
                chain(
                    [""],
                    expected.facets.keys(),
                    (facet for facet in actual.facets if facet not in expected.facets),
                ),
            )
        )
        expectedFacets = _serialize_only_facets(expected, mismatched_keys)
        actualFacets = _serialize_only_facets(actual, mismatched_keys)
        raise storage.fs.assert_failed(
            message=storage.mode.msg_snapshot_mismatch(
                expected=expectedFacets, actual=actualFacets
            ),
            expected=expectedFacets,
            actual=actualFacets,
        )
 
 

_check_src()

T selfie_lib.SelfieImplementations._check_src ( T  value )

protected

Definition at line 256 of file SelfieImplementations.py.

def _check_src(value: T) -> T:
    _selfieSystem().mode.can_write(False, recordCall(True), _selfieSystem())
    return value
 
 

_serialize_only_facets()

str selfie_lib.SelfieImplementations._serialize_only_facets ( Snapshot  snapshot, list[str]  keys  )

protected

Definition at line 319 of file SelfieImplementations.py.

def _serialize_only_facets(snapshot: Snapshot, keys: list[str]) -> str:
    writer = []
    for key in keys:
        if not key:
            SnapshotFile.writeEntry(writer, "", None, snapshot.subject_or_facet(key))
        else:
            value = snapshot.subject_or_facet(key)
            if value is not None:
                SnapshotFile.writeEntry(writer, "", key, value)
 
    EMPTY_KEY_AND_FACET = "╔═  ═╗\n"
    writer_str = "".join(writer)
 
    if writer_str.startswith(EMPTY_KEY_AND_FACET):
        # this codepath is triggered by the `key.isEmpty()` line above
        return writer_str[len(EMPTY_KEY_AND_FACET) : -1]
    else:
        return writer_str[:-1]

_to_be_didnt_match()

T selfie_lib.SelfieImplementations._to_be_didnt_match ( Optional[T]  expected, T  actual, LiteralFormat[T]  fmt  )

protected

Definition at line 261 of file SelfieImplementations.py.

def _to_be_didnt_match(expected: Optional[T], actual: T, fmt: LiteralFormat[T]) -> T:
    call = recordCall(False)
    writable = _selfieSystem().mode.can_write(expected is None, call, _selfieSystem())
    if writable:
        _selfieSystem().write_inline(LiteralValue(expected, actual, fmt), call)
        return actual
    else:
        if expected is None:
            raise _selfieSystem().fs.assert_failed(
                f"Can't call `to_be_TODO` in {Mode.readonly} mode!"
            )
        else:
            expectedStr = repr(expected)
            actualStr = repr(actual)
            if expectedStr == actualStr:
                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(
                        expected=expectedStr, actual=actualStr
                    ),
                    expected=expected,
                    actual=actual,
                )
 
 

Variable Documentation

T

selfie_lib.SelfieImplementations.T = TypeVar("T")

Definition at line 18 of file SelfieImplementations.py.