module ptwm

class CompressionConfig:

def __init__(self, method: Method = Method.AUTO, input_format: Format = Format.BYTE, bytearray_dtype: str = 'bfloat16', is_monotonic: int = 0, threads: int | None = None, compression_threshold: float = 0.95, check_th_after_percent: int = 10, reorder_signbit: int = 0, delta_compressed_type: str | None = None, lossy_compressed_type: Lossy = Lossy.NONE, lossy_compressed_factor: int = 27, compression_chunk: int = 256 * 1024, is_streaming: bool = False, streaming_chunk: int = 1024 * 1024, input_file: str | None = None, compressed_file: str | None = None, decompressed_file: str | None = None, zstd_level: int = 3, lz4_compression_level: int = 0, codec_menu: list[CodecId] | None = None) -> None

bytearray_dtype: str = 'bfloat16'

check_th_after_percent: int = 10

codec_menu: list[CodecId] | None = None

compressed_file: str | None = None

compression_chunk: int = 256 * 1024

compression_threshold: float = 0.95

decompressed_file: str | None = None

delta_compressed_type: str | None = None

def from_resolved_policy(cls, rp: ResolvedPolicy, base: CompressionConfig | None = None) -> CompressionConfig

input_file: str | None = None

input_format: Format = Format.BYTE

is_monotonic: int = 0

is_streaming: bool = False

lossy_compressed_factor: int = 27

lossy_compressed_type: Lossy = Lossy.NONE

lz4_compression_level: int = 0

method: Method = Method.AUTO

reorder_signbit: int = 0

streaming_chunk: int = 1024 * 1024

threads: int | None = None

zstd_level: int = 3

class CompressionMethodNotSupportedError(Error):

class Compressor:

def __init__(self, config: CompressionConfig) -> None

def compress(self, data: bytes | bytearray | np.ndarray | torch.Tensor, delta_second_data: bytes | bytearray | np.ndarray | torch.Tensor | None = None) -> bytes

config = config

class DecompressionConfig:

def __init__(self, threads: int | None = None, delta_second_data: bytes | None = None, skip_missing: bool = False) -> None

delta_second_data: bytes | None = None

skip_missing: bool = False

threads: int | None = None

class Decompressor:

def __init__(self, config: DecompressionConfig | None = None) -> None

config = config or DecompressionConfig()

def decompress(self, data: bytes | memoryview) -> bytes | np.ndarray | torch.Tensor

def decompress_container_to_state_dict(self, blob: bytes) -> dict[str, bytes]

def decompress_file(self, path: str) -> bytes | np.ndarray | torch.Tensor

class Error(Exception):

class Format(Enum):

BYTE = 1

FILE = 4

NUMPY = 3

TORCH = 2

class HeaderParseError(Error):

class InvalidDTypeError(Error):

class Lossy(Enum):

INTEGER = 1

NONE = 0

UNSIGN = 2

def materialize_hf_cache(snapshot_dir: str | os.PathLike[str], remove_source: bool = False) -> list[Path]

class Method(Enum):

AUTO = 0

HUFFMAN = 1

IDENTITY = 3

MICROSCALE = 5

RANS = 4

ZSTD = 2