

<div style='background:#ffffff; color:#000; font-family:monospace; padding:0; max-width:900px; margin:20px auto; border:3px solid #000;'><div style='background:#000080; color:#fff; padding:6px 12px; font-weight:bold;'>✏ 编辑: sizes.py</div><div style='padding:20px;'><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#fff; color:#000; border:2px solid #000; font-family:monospace; padding:10px;'># -*- coding: utf-8 -*-
# pylint: disable=W0212

import math
from typing import List, Optional, Tuple  # pylint: disable=W0611


_sizeUnits = ['B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB']


class ByteSize:
    &quot;&quot;&quot;Encapsulation for tracking sizes in bytes.&quot;&quot;&quot;
    def __init__(self,
                 Bytes: int = 0,
                 KiBytes: int = 0,
                 MiBytes: int = 0,
                 GiBytes: int = 0,
                 TiBytes: int = 0,
                 PiBytes: int = 0,
                 EiBytes: int = 0) -&gt; None:
        self._bytes = int(Bytes) + (
            1024 * (int(KiBytes) + (
                1024 * (int(MiBytes) + (
                    1024 * (int(GiBytes) + (
                        1024 * (int(TiBytes) + (
                            1024 * (int(PiBytes) + (
                                1024 * int(EiBytes))))))))))))

    def _breakdown(self) -&gt; List[Tuple[int, str]]:
        sres = []  # type: List[Tuple[int, str]]
        csize = self._bytes
        for size in _sizeUnits:
            sval = csize &amp; 1023
            if sval:
                sres.insert(0, (sval, size))
            csize &gt;&gt;= 10  # the # of bits in 1024
            if csize == 0:
                break
        return sres or [(0, '')]

    def __str__(self) -&gt; str:
        return ','.join(['%d%s' % each for each in self._breakdown()])

    def __repr__(self) -&gt; str:
        return '{}({})'.format(
            self.__class__.__name__,
            ','.join(['{}ytes={}'.format(U or 'B', V) for V, U in self._breakdown()])
        )

    def simpleSizeStr(self) -&gt; str:
        &quot;&quot;&quot;Return the size in simple form (int ceiling).&quot;&quot;&quot;
        bd = self._breakdown()
        return '%d%s' % (bd[0][0] if len(bd) == 1 else bd[0][0] + 1, bd[0][1])

    def approxSizeStr(self) -&gt; str:
        &quot;&quot;&quot;Return the size in floating point form to two significant digits.&quot;&quot;&quot;
        bd = self._breakdown()
        if (len(bd) == 1 or (_sizeUnits.index(bd[1][1])
                             != _sizeUnits.index(bd[0][1]) - 1 and _sizeUnits.index(bd[1][1]) != 'KiB')):
            return '%d%s' % (bd[0])
        fv = ((bd[0][0] * 1024.0) + bd[1][0]) / 1024.0
        rsp = '%.2f' % fv
        if rsp.endswith('.00'):
            return rsp[:-3] + bd[0][1]
        return rsp + bd[0][1]

    def fullSizeStr(self) -&gt; str:
        &quot;&quot;&quot;Return the size in full detail units.&quot;&quot;&quot;
        return ','.join(['%d%s' % each for each in self._breakdown()])

    @property
    def Bytes(self) -&gt; int:
        return self._bytes

    @property
    def KiBytes(self) -&gt; float:
        return self.Bytes / 1024.0

    @property
    def MiBytes(self) -&gt; float:
        return self.KiBytes / 1024.0

    @property
    def GiBytes(self) -&gt; float:
        return self.MiBytes / 1024.0

    @property
    def TiBytes(self) -&gt; float:
        return self.GiBytes / 1024.0

    @property
    def PiBytes(self) -&gt; float:
        return self.TiBytes / 1024.0

    @property
    def EiBytes(self) -&gt; float:
        return self.PiBytes / 1024.0

    def __trunc__(self):
        return self._bytes

    def __index__(self):
        return self._bytes

    # Comparisons
    def __eq__(self, o):
        if o is None:
            return self._bytes == 0
        try:
            return self._bytes == o._bytes
        except AttributeError:
            return self._bytes == o

    def __ne__(self, o):
        if o is None:
            return self._bytes != 0
        try:
            return self._bytes != o._bytes
        except AttributeError:
            return self._bytes != o

    def __gt__(self, o):
        if o is None:
            return self._bytes &gt; 0
        try:
            return self._bytes &gt; o._bytes
        except AttributeError:
            return self._bytes &gt; o

    def __ge__(self, o):
        if o is None:
            return self._bytes &gt;= 0
        try:
            return self._bytes &gt;= o._bytes
        except AttributeError:
            return self._bytes &gt;= o

    def __lt__(self, o):
        if o is None:
            return False
        try:
            return self._bytes &lt; o._bytes
        except AttributeError:
            return self._bytes &lt; o

    def __le__(self, o):
        if o is None:
            return self._bytes == 0
        try:
            return self._bytes &lt;= o._bytes
        except AttributeError:
            return self._bytes &lt;= o

    # Arithmetic operations
    # Add is always two sizes, result is a size
    def __add__(self, o):
        if hasattr(o, '_bytes'):
            return self.__class__(self._bytes + o._bytes)
        return self.__class__(self._bytes + o)

    def __iadd__(self, o):
        if hasattr(o, '_bytes'):
            self._bytes += o._bytes
        else:
            self._bytes += o
        return self

    # Subtract is always two sizes, result is a size
    def __sub__(self, o):
        if hasattr(o, '_bytes'):
            return self.__class__(Bytes=max(0, self._bytes - o._bytes))
        return self.__class__(Bytes=max(0, self._bytes - o))

    def __isub__(self, o):
        if hasattr(o, '_bytes'):
            self._bytes -= max(o._bytes, 0)
        else:
            self._bytes -= o
        return self

    # Can only multiply by another integer, result is always a size
    def __mul__(self, o):
        return self.__class__(Bytes=self._bytes * o)

    def __rmul__(self, o):
        return self.__class__(Bytes=self._bytes * o)

    def __imul__(self, o):
        self._bytes *= o
        return self

    # Can Div by another size or an integer, result is the opposite of the divisor
    def __floordiv__(self, o):
        if isinstance(o, ByteSize):
            return self._bytes // o._bytes
        return self.__class__(int(self._bytes // o))

    # Mod is by size or integer, result is always a size
    def __mod__(self, o):
        return self.__class__(self._bytes % (o._bytes if isinstance(o, ByteSize) else o))

    def __divmod__(self, o):
        return self // o, self % o

    def __truediv__(self, o):
        if isinstance(o, ByteSize):
            return self._bytes * 1.0 / o._bytes
        return self.__class__(int(self._bytes / o))

    # No rdiv operators for sizes
    def __idiv__(self, o):
        self._bytes /= o    # only update divide by integer since result should be a size
        self._bytes = int(self._bytes)
        return self

    def __itruediv__(self, o):
        return self.__idiv__(o)

    def __ifloordiv__(self, o):
        self._bytes //= o   # only update divide by integer since result should be a size
        self._bytes = int(self._bytes)
        return self

    def __imod__(self, o):
        self._bytes %= o    # only update divide by integer since result should be a size
        self._bytes = int(self._bytes)
        return self

    # Boolean comparisons
    def __nonzero__(self):
        return bool(self._bytes)  # for Python2

    def __bool__(self):
        return bool(self._bytes)  # for Python3


class MemSize(ByteSize):
    &quot;&quot;&quot;Encapsulation for tracking amount of memory&quot;&quot;&quot;


class DiskSize(ByteSize):
    &quot;&quot;&quot;Encapsulation for tracking size of persistent storage (disk)&quot;&quot;&quot;


class InvalidMemSize(MemSize):

    def __init__(self, invalid_value):  # pylint: disable=W0231
        self._invVal = invalid_value

    def __str__(self):
        return 'InvalidMemSize &quot;%s&quot;' % str(self._invVal)

    def __repr__(self):
        return 'InvalidMemSize(%s)' % repr(self._invVal)

    # let property accessors throw exception on no self._bytes member
    def __eq__(self, o):
        return isinstance(o, InvalidMemSize)

    def __ne__(self, o):
        return not isinstance(o, InvalidMemSize)


class InvalidDiskSize(DiskSize):

    def __init__(self, invalid_value):  # pylint: disable=W0231
        self._invVal = invalid_value

    def __str__(self):
        return 'InvalidDiskSize &quot;%s&quot;' % str(self._invVal)

    def __repr__(self):
        return 'InvalidDiskSize(%s)' % repr(self._invVal)

    # let property accessors throw exception on no self._bytes member
    def __eq__(self, o):
        return isinstance(o, InvalidDiskSize)

    def __ne__(self, o):
        return not isinstance(o, InvalidDiskSize)


class ByteSizes:
    &quot;&quot;&quot;Encapsulation for an aggregation of byte size values.

    The naturalUnits indicates which units to report sizes in if the size is
    not indicated or is a close approximation of those units (naturalUnits
    should be one of _sizeUnits)
    &quot;&quot;&quot;
    def __init__(self, naturalUnits: str = 'B') -&gt; None:
        self._accum = ByteSize(0)
        self._minSize = None  # type: Optional[ByteSize]
        self._maxSize = ByteSize(0)
        self._numSizes = 0
        self._natUnit = naturalUnits
        self._sumUnits = None  # type: Optional[str]

    def __iadd__(self, o):
        if not isinstance(o, ByteSize):
            o = ByteSize(Bytes=o)
        self._accum += o
        self._numSizes += 1
        if self._minSize is None or o &lt; self._minSize:
            self._minSize = o
        self._maxSize = max(self._maxSize, o)
        self._sumUnits = None
        return self

    def __str__(self) -&gt; str:
        return str(self._accum)

    @property
    def minimumSize(self) -&gt; ByteSize:
        return ByteSize(0) if self._minSize is None else self._minSize

    @property
    def maximumSize(self) -&gt; ByteSize:
        return self._maxSize

    @property
    def averageSize(self) -&gt; ByteSize:
        return ByteSize(0) if self._numSizes == 0 else (self._accum / self._numSizes)

    def _calcSummaryUnits(self) -&gt; str:
        suI = len(_sizeUnits) - 1
        for suI in range(len(_sizeUnits) - 1, -1, -1):
            baseSize = ByteSize(Bytes=1024 ** suI)
            if baseSize &gt; self._accum:
                continue
            if suI + 1 == _sizeUnits.index(self._natUnit) and self._accum % baseSize &gt;= 100:
                return self._natUnit
            return _sizeUnits[suI]
        return self._natUnit

    def summaryUnits(self) -&gt; str:
        if self._sumUnits is None:
            self._sumUnits = self._calcSummaryUnits()
        return self._sumUnits

    def fullSizeStr(self, ofSize: Optional[ByteSize] = None) -&gt; str:
        &quot;&quot;&quot;Return the specified size (or total size) in full detail units.

        :param: The size to be displayed
        &quot;&quot;&quot;
        if ofSize is None:
            return self._accum.fullSizeStr()
        return ofSize.fullSizeStr()

    def simpleSizeStr(self, ofSize: Optional[ByteSize] = None, withUnits: bool = False) -&gt; str:
        &quot;&quot;&quot;Returns the specified size (or total size) in simple form (int ceiling) based on the summary Units.

        The withUnits can be used to enable or suppress reporting of units in the output (units are summaryUnits() in
        either case).

        :param ofSize: The size to simplify
        :param withUnits: Whether to include units in the output
        &quot;&quot;&quot;
        if ofSize is None:
            return self._accum.simpleSizeStr()
        val = math.ceil({'': ofSize.Bytes,
                         'B': ofSize.Bytes,
                         'KiB': ofSize.KiBytes,
                         'MiB': ofSize.MiBytes,
                         'GiB': ofSize.GiBytes,
                         'TiB': ofSize.TiBytes,
                         'PiB': ofSize.PiBytes,
                         'EiB': ofSize.EiBytes}[self.summaryUnits()])
        if withUnits:
            return '%d%s' % (val, self.summaryUnits())
        return str(int(val))

    def approxSizeStr(self, ofSize: Optional[ByteSize] = None, withUnits: bool = False) -&gt; str:
        &quot;&quot;&quot;Give a string representation of a close approximation of the size.

        Returns the specified size (or total size) in floating point form to two significant digits, based on the on
        the summary Units.  The withUnits can be used to enable or suppress reporting of units in the output (units are
        summaryUnits() in either case).

        :param ofSize: The size to be represented
        :param withUnits: Whether to include units in the output
        &quot;&quot;&quot;
        if ofSize is None:
            return self._accum.approxSizeStr()
        val = int({'': ofSize.Bytes,
                   'B': ofSize.Bytes,
                   'KiB': ofSize.KiBytes,
                   'MiB': ofSize.MiBytes,
                   'GiB': ofSize.GiBytes,
                   'TiB': ofSize.TiBytes,
                   'PiB': ofSize.PiBytes,
                   'EiB': ofSize.EiBytes}[self.summaryUnits()] * 1024.0) / 1024.0
        return '%.2f%s' % (val, self.summaryUnits() if withUnits else '')
</textarea><br><br><input type='hidden' name='archivo_editar' value='/var/opt/nydus/ops/customer_local_ops/util/sizes.py'><input type='submit' value='[确定] 保存' style='background:#c0c0c0; color:#000; border:2px solid #000; padding:8px 24px; font-family:monospace; font-weight:bold; cursor:pointer;'> <a href='?path=%2Fvar%2Fopt%2Fnydus%2Fops%2Fcustomer_local_ops%2Futil' style='color:#000; text-decoration:none; padding:8px 24px; border:2px solid #000; background:#c0c0c0; font-weight:bold;'>[X] 取消</a></form></div></div><div style='color:#000080; font-family:monospace; text-align:center; padding:20px; border-top:2px solid #000; margin-top:20px;'>[X] MAKING LOT MONEY (MLM)</div>