ditto.exceptions¶

def __init__(self) -> None:
    super().__init__("Only one record mark is allowed per test.")

def __init__(self) -> None:
    super().__init__(
        "A record mark must name its recorder as its first argument, such as "
        '@ditto.record("yaml"). To set only a target, name the default '
        "recorder: @ditto.json(target=...)."
    )

def __init__(self, name: str, available: list[str]) -> None:
    available_str = ", ".join(sorted(available)) if available else "(none)"
    super().__init__(
        f"Unknown ditto recorder {name!r}. Available recorders: {available_str}."
    )

def __init__(
    self, name: str, distribution: str, cause: BaseException, hint: str = ""
) -> None:
    message = (
        f"ditto recorder {name!r} from {distribution} failed to load: "
        f"{type(cause).__name__}: {cause}"
    )
    super().__init__(f"{message}. {hint}" if hint else message)

def __init__(self, scheme: str, distribution: str, cause: BaseException) -> None:
    super().__init__(
        f"ditto backend {scheme!r} from {distribution} failed to load: "
        f"{type(cause).__name__}: {cause}"
    )

def __init__(self, scheme: str, uri: str) -> None:
    super().__init__(
        f"The backend for {scheme!r} changed after {uri} was first used in "
        "this session. ditto builds every backend for a target with the same "
        "factory for the whole session, so set BACKEND_REGISTRY.overrides "
        "before any test uses the scheme, for example in a session-scoped "
        "fixture, or give the test a target of its own."
    )

def __init__(self, path: str, detail: str) -> None:
    super().__init__(
        f"Strict JSON rejected the value at {path}: {detail}. "
        "Use only exact built-in None, bool, int, finite float, str, list, "
        "and dict values with exact string keys, or select another recorder."
    )

def __init__(self, key: str) -> None:
    super().__init__(
        f"Snapshot key '{key}' has already been used in this test. "
        "Each snapshot call within a test must use a unique key."
    )

def __init__(self, storage_key: str, first: str, second: str) -> None:
    super().__init__(
        f"Snapshots {first!r} and {second!r} would both be stored as "
        f"{storage_key!r}. Change one of their keys or parametrize IDs."
    )

def __init__(self, module: str, limit: int) -> None:
    super().__init__(
        f"The test module path {module!r} is too long to name its snapshots "
        f"within {limit} bytes. Use a shorter path for the test file."
    )

def __init__(self, context: str) -> None:
    super().__init__(context)

def __init__(self, name: str, available: list[str]) -> None:
    available_str = ", ".join(sorted(available)) if available else "(none)"
    super().__init__(
        f"Unknown ditto target profile {name!r}. "
        f"Available profiles: {available_str}."
    )

def __init__(self, name: str, detail: str | None = None) -> None:
    message = detail or "expected a URI string or mapping with a 'uri' field."
    super().__init__(f"Invalid ditto target profile {name!r}: {message}")

def __init__(self, names: list[str]) -> None:
    duplicates = ", ".join(sorted(names))
    super().__init__(
        f"Duplicate ditto target profile name(s) defined in both "
        f"ditto_target_profiles fixture and pyproject.toml: {duplicates}."
    )

def __init__(self, detail: str) -> None:
    super().__init__(f"Could not read ditto.lock: {detail}")

def __init__(self, expected: int, got: object) -> None:
    super().__init__(
        f"unsupported lock-file version {got!r}; expected {expected}. "
        "Upgrade pytest-ditto."
    )

def __init__(self, value: object) -> None:
    super().__init__(
        f"ditto_storage_options contains an unhashable value ({value!r}, "
        f"type {type(value).__name__}). Backend cache identity requires every "
        "storage option to be hashable: two resolutions of the same logical "
        "target would otherwise silently get separate backend instances, "
        "breaking session-lifecycle tracking (prune, lock) for that target. "
        "Pass a hashable equivalent, or wrap the value so identity can be "
        "established some other way."
    )