Class ByteSize

src/crawlee/_utils/byte_size.py:13–128

Represents a byte size.

@dataclass(frozen=True)
class ByteSize:
    """Represents a byte size."""

    bytes: int

    def __post_init__(self) -> None:
        if self.bytes < 0:
            raise ValueError('ByteSize cannot be negative')

    @classmethod
    def validate(cls, value: Any) -> ByteSize:
        if isinstance(value, ByteSize):
            return value

        if not isinstance(value, (float, int)):
            raise TypeError('Value must be numeric')

        return cls(int(value))

    @classmethod
    def from_kb(cls, kb: float) -> ByteSize:
        return cls(int(kb * _BYTES_PER_KB))

    @classmethod
    def from_mb(cls, mb: float) -> ByteSize:
        return cls(int(mb * _BYTES_PER_MB))

    @classmethod
    def from_gb(cls, gb: float) -> ByteSize:
        return cls(int(gb * _BYTES_PER_GB))

    @classmethod
    def from_tb(cls, tb: float) -> ByteSize:
        return cls(int(tb * _BYTES_PER_TB))

    def to_kb(self) -> float:
        return self.bytes / _BYTES_PER_KB

    def to_mb(self) -> float:
        return self.bytes / _BYTES_PER_MB

    def to_gb(self) -> float:
        return self.bytes / _BYTES_PER_GB

    def to_tb(self) -> float:
        return self.bytes / _BYTES_PER_TB

    def __str__(self) -> str:
        if self.bytes >= _BYTES_PER_TB:
            return f'{self.to_tb():.2f} TB'
        if self.bytes >= _BYTES_PER_GB:
            return f'{self.to_gb():.2f} GB'
        if self.bytes >= _BYTES_PER_MB:
            return f'{self.to_mb():.2f} MB'
        if self.bytes >= _BYTES_PER_KB:
            return f'{self.to_kb():.2f} KB'
        return f'{self.bytes} B'