Class CacheMetaEx

mypy/cache.py:244–295

Class representing "implementation-specific" part of cache metadata for a module.

class CacheMetaEx:
    """Class representing "implementation-specific" part of cache metadata for a module."""

    def __init__(
        self,
        dependencies: list[str],
        suppressed: list[str],
        dep_hashes: list[bytes],
        error_lines: list[ErrorTuple],
    ) -> None:
        self.dependencies = dependencies
        self.suppressed = suppressed
        self.dep_hashes = dep_hashes
        self.error_lines = error_lines

    def serialize(self) -> dict[str, Any]:
        return {
            "dependencies": self.dependencies,
            "suppressed": self.suppressed,
            "dep_hashes": [dep.hex() for dep in self.dep_hashes],
            "error_lines": self.error_lines,
        }

    @classmethod
    def deserialize(cls, meta: dict[str, Any]) -> CacheMetaEx | None:
        try:
            return CacheMetaEx(
                dependencies=meta["dependencies"],
                suppressed=meta["suppressed"],
                dep_hashes=[bytes.fromhex(dep) for dep in meta["dep_hashes"]],
                error_lines=[tuple(err) for err in meta["error_lines"]],
            )
        except (KeyError, ValueError):
            return None

    def write(self, data: WriteBuffer) -> None:
        write_str_list(data, self.dependencies)
        write_str_list(data, self.suppressed)
        write_bytes_list(data, self.dep_hashes)
        write_errors(data, self.error_lines)

    @classmethod
    def read(cls, data: ReadBuffer) -> CacheMetaEx | None:
        try:
            return CacheMetaEx(
                dependencies=read_str_list(data),
                suppressed=read_str_list(data),
                dep_hashes=read_bytes_list(data),
                error_lines=read_errors(data),
            )
        except (ValueError, AssertionError):
            return None


# Always use this type alias to refer to type tags.