File Manager

X7ROOT File Manager

Current Path: /usr/lib/python2.7/site-packages/blivet

usr / lib / python2.7 / site-packages / blivet /

📁 ..
📄 __init__.py(117.33 KB)
📄 __init__.pyc(100.39 KB)
📄 __init__.pyo(100.39 KB)
📄 arch.py(9.45 KB)
📄 arch.pyc(8.63 KB)
📄 arch.pyo(8.63 KB)
📄 callbacks.py(3.55 KB)
📄 callbacks.pyc(1.85 KB)
📄 callbacks.pyo(1.85 KB)
📄 deviceaction.py(32.05 KB)
📄 deviceaction.pyc(33.21 KB)
📄 deviceaction.pyo(33.21 KB)
📄 devicefactory.py(63.97 KB)
📄 devicefactory.pyc(54.57 KB)
📄 devicefactory.pyo(54.57 KB)
📁 devicelibs
📁 devices
📄 devicetree.py(117.74 KB)
📄 devicetree.pyc(82.74 KB)
📄 devicetree.pyo(82.74 KB)
📄 errors.py(5.25 KB)
📄 errors.pyc(12.1 KB)
📄 errors.pyo(12.1 KB)
📄 fcoe.py(7.91 KB)
📄 fcoe.pyc(7.27 KB)
📄 fcoe.pyo(7.27 KB)
📄 flags.py(3.89 KB)
📄 flags.pyc(2.53 KB)
📄 flags.pyo(2.53 KB)
📁 formats
📄 i18n.py(1.21 KB)
📄 i18n.pyc(756 B)
📄 i18n.pyo(756 B)
📄 iscsi.py(19.29 KB)
📄 iscsi.pyc(16.36 KB)
📄 iscsi.pyo(16.36 KB)
📄 nvdimm.py(6.24 KB)
📄 nvdimm.pyc(6.16 KB)
📄 nvdimm.pyo(6.16 KB)
📄 partitioning.py(95.65 KB)
📄 partitioning.pyc(66.5 KB)
📄 partitioning.pyo(66.5 KB)
📄 partspec.py(4.05 KB)
📄 partspec.pyc(3.34 KB)
📄 partspec.pyo(3.34 KB)
📄 platform.py(17.38 KB)
📄 platform.pyc(18.52 KB)
📄 platform.pyo(18.52 KB)
📄 size.py(13.47 KB)
📄 size.pyc(11.4 KB)
📄 size.pyo(11.4 KB)
📄 storage_log.py(2.56 KB)
📄 storage_log.pyc(3.32 KB)
📄 storage_log.pyo(3.32 KB)
📄 tsort.py(3.37 KB)
📄 tsort.pyc(2.38 KB)
📄 tsort.pyo(2.38 KB)
📄 udev.py(28.34 KB)
📄 udev.pyc(30.19 KB)
📄 udev.pyo(30.19 KB)
📄 util.py(15.94 KB)
📄 util.pyc(19.52 KB)
📄 util.pyo(19.52 KB)
📄 zfcp.py(16.01 KB)
📄 zfcp.pyc(13 KB)
📄 zfcp.pyo(13 KB)

Editing: size.py

# size.py
# Python module to represent storage sizes
#
# Copyright (C) 2010  Red Hat, Inc.
#
# This copyrighted material is made available to anyone wishing to use,
# modify, copy, or redistribute it subject to the terms and conditions of
# the GNU General Public License v.2, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY expressed or implied, including the implied warranties of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
# Public License for more details.  You should have received a copy of the
# GNU General Public License along with this program; if not, write to the
# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301, USA.  Any Red Hat trademarks that are incorporated in the
# source code or documentation are not subject to the GNU General Public
# License and may only be used or replicated with the express permission of
# Red Hat, Inc.
#
# Red Hat Author(s): David Cantrell <dcantrell@redhat.com>

import re
import string
import locale
from collections import namedtuple

from decimal import Decimal
from decimal import InvalidOperation
from decimal import ROUND_DOWN, ROUND_UP, ROUND_HALF_UP

from .errors import SizePlacesError
from .i18n import _, P_, N_

ROUND_DEFAULT = ROUND_HALF_UP

# Container for size unit prefix information
_Prefix = namedtuple("Prefix", ["factor", "prefix", "abbr"])

# Decimal prefixes for different size increments, along with the name
# and accepted abbreviation for the prefix.  These prefixes are all
# for 'bytes'.
_decimalPrefixes = [_Prefix(1000, N_(b"kilo"), N_(b"k")),
                    _Prefix(1000**2, N_(b"mega"), N_(b"M")),
                    _Prefix(1000**3, N_(b"giga"), N_(b"G")),
                    _Prefix(1000**4, N_(b"tera"), N_(b"T")),
                    _Prefix(1000**5, N_(b"peta"), N_(b"P")),
                    _Prefix(1000**6, N_(b"exa"), N_(b"E")),
                    _Prefix(1000**7, N_(b"zetta"), N_(b"Z")),
                    _Prefix(1000**8, N_(b"yotta"), N_(b"Y"))]

# Binary prefixes for the different size increments.  Same structure
# as the above list.
_binaryPrefixes = [_Prefix(1024, N_(b"kibi"), N_(b"Ki")),
                   _Prefix(1024**2, N_(b"mebi"), N_(b"Mi")),
                   _Prefix(1024**3, N_(b"gibi"), N_(b"Gi")),
                   _Prefix(1024**4, N_(b"tebi"), N_(b"Ti")),
                   _Prefix(1024**5, N_(b"pebi"), N_(b"Pi")),
                   _Prefix(1024**6, N_(b"exbi"), N_(b"Ei")),
                   _Prefix(1024**7, N_(b"zebi"), N_(b"Zi")),
                   _Prefix(1024**8, N_(b"yobi"), N_(b"Yi"))]

# Handle 'B' separately so that it can be localized without translating
# both 'B' and 'b'
_bytes_letter = N_(b'B')
_bytes_words = [N_(b'byte'), N_(b'bytes')]
_prefixes = _binaryPrefixes + _decimalPrefixes

_ASCIIlower_table = string.maketrans(string.ascii_uppercase, string.ascii_lowercase)
def _lowerASCII(s):
    """Convert a string to lowercase using only ASCII character definitions."""
    return string.translate(s, _ASCIIlower_table)

_bytes = [_bytes_letter, _lowerASCII(_bytes_letter)] + _bytes_words

# Translated versions of the byte and prefix arrays
# All strings are decoded as utf-8 so that locale-specific upper/lower functions work
def _xlated_bytes():
    """Return a translated version of the bytes list as a list of unicode strings"""
    return [_(_bytes_letter).decode("utf-8") + _(_bytes_letter).decode("utf-8").lower()] + \
            [_(b).decode("utf-8") for b in _bytes_words]

def _xlated_binary_prefixes():
    return (_Prefix(p.factor, _(p.prefix).decode("utf-8"), _(p.abbr).decode("utf-8")) \
            for p in _binaryPrefixes)

def _xlated_prefixes():
    """Return translated prefixes as unicode strings"""
    xlated_binary = list(_xlated_binary_prefixes())
    xlated_decimal = [_Prefix(p.factor, _(p.prefix).decode("utf-8"), _(p.abbr).decode("utf-8")) \
                      for p in _decimalPrefixes]

return xlated_binary + xlated_decimal

def _makeSpecs(prefix, abbr, xlate):
    """ Internal method used to generate a list of specifiers. """
    specs = []

if prefix:
        if xlate:
            specs.append(prefix.lower() + _(b"byte").decode("utf-8"))
            specs.append(prefix.lower() + _(b"bytes").decode("utf-8"))
        else:
            specs.append(_lowerASCII(prefix) + "byte")
            specs.append(_lowerASCII(prefix) + "bytes")

if abbr:
        if xlate:
            specs.append(abbr.lower() + _(_bytes_letter).decode("utf-8").lower())
            specs.append(abbr.lower())
        else:
            specs.append(_lowerASCII(abbr) + _lowerASCII(_bytes_letter))
            specs.append(_lowerASCII(abbr))

return specs

def _parseSpec(spec):
    """ Parse string representation of size. """
    if not spec:
        raise ValueError("invalid size specification", spec)

# Replace the localized radix character with a .
    radix = locale.nl_langinfo(locale.RADIXCHAR)
    if radix != '.':
        spec = spec.replace(radix, '.')

# Match the string using only digit/space/not-space, since the
    # string might be non-English and contain non-letter characters
    # that Python doesn't understand as parts of words.
    m = re.match(r'(-?\s*[0-9.]+)\s*([^\s]*)$', spec.strip())
    if not m:
        raise ValueError("invalid size specification", spec)

try:
        size = Decimal(m.groups()[0])
    except InvalidOperation:
        raise ValueError("invalid size specification", spec)

specifier = m.groups()[1]

# Only attempt to parse as English if all characters are ASCII
    try:
        # This will raise UnicodeDecodeError if specifier contains non-ascii
        # characters
        spec_ascii = specifier.decode("ascii")
        # Convert back to a str type to match the _bytes and _prefixes arrays
        spec_ascii = str(spec_ascii)

# Use the ASCII-only lowercase mapping
        spec_ascii = _lowerASCII(spec_ascii)
    except (UnicodeDecodeError, UnicodeEncodeError):
        pass
    else:
        if spec_ascii and not spec_ascii.endswith("b"):
            spec_ascii += "ib"

if spec_ascii in _bytes or not spec_ascii:
            return size

for factor, prefix, abbr in _prefixes:
            check = _makeSpecs(prefix, abbr, False)

if spec_ascii in check:
                return size * factor

# No English match found, try localized size specs. Accept any utf-8
    # character and leave the result as a (unicode object.
    spec_local = specifier.decode("utf-8")

# Use the locale-specific lowercasing
    spec_local = spec_local.lower()

if spec_local in _xlated_bytes():
        return size

for factor, prefix, abbr in _xlated_prefixes():
        check  = _makeSpecs(prefix, abbr, True)

if spec_local in check:
            return size * factor

raise ValueError("invalid size specification", spec)

class Size(Decimal):
    """ Common class to represent storage device and filesystem sizes.
        Can handle parsing strings such as 45MB or 6.7GB to initialize
        itself, or can be initialized with a numerical size in bytes.
        Also generates human readable strings to a specified number of
        decimal places.
    """

def __new__(cls, value=0, context=None):
        """ Initialize a new Size object.  Must pass a bytes or a spec value
            for size. The bytes value is a numerical value for the size
            this object represents, in bytes.  The spec value is a string
            specification of the size using any of the size specifiers in the
            _decimalPrefixes or _binaryPrefixes lists combined with a 'b' or
            'B'.  For example, to specify 640 kilobytes, you could pass any of
            these spec parameters:

"640kb"
                "640 kb"
                "640KB"
                "640 KB"
                "640 kilobytes"

If you want to use a spec value to represent a bytes value,
            you can use the letter 'b' or 'B' or omit the size specifier.
        """
        if isinstance(value, str):
            size = _parseSpec(value)
        elif isinstance(value, (int, long, float, Decimal)):
            size = Decimal(value)
        elif isinstance(value, Size):
            size = Decimal(value.convertTo("b"))
        else:
            raise ValueError("invalid value %s for size" % value)

# drop any partial byte
        size = size.to_integral_value(rounding=ROUND_DOWN)
        self = Decimal.__new__(cls, value=size)
        return self

def __str__(self, eng=False, context=None):
        # Convert the result of humanReadable from unicode to str
        return self.humanReadable()

def __repr__(self):
        return "Size('%s')" % self

def __deepcopy__(self, memo):
        return Size(self.convertTo(spec="b"))

def __add__(self, other, context=None):
        return Size(Decimal.__add__(self, other, context=context))

# needed to make sum() work with Size arguments
    def __radd__(self, other, context=None):
        return Size(Decimal.__radd__(self, other, context=context))

def __sub__(self, other, context=None):
        # subtraction is implemented using __add__ and negation, so we'll
        # be getting passed a Size
        return Decimal.__sub__(self, other, context=context)

def __mul__(self, other, context=None):
        return Size(Decimal.__mul__(self, Decimal(other), context=context))
    __rmul__ = __mul__

def __div__(self, other, context=None):
        return Size(Decimal.__div__(self, other, context=context))

def __mod__(self, other, context=None):
        return Size(Decimal.__mod__(self, other, context=context))

def convertTo(self, spec="b"):
        """ Return the size in the units indicated by the specifier.  The
            specifier can be prefixes from the _decimalPrefixes and
            _binaryPrefixes lists combined with 'b' or 'B' for abbreviations) or
            'bytes' (for prefixes like kilo or mega).  The size is returned as a
            Decimal.
        """
        spec = spec.lower()

if spec in _bytes:
            return Decimal(self)

for factor, prefix, abbr in _prefixes:
            check = _makeSpecs(prefix, abbr, False)

if spec in check:
                return Decimal(self) / Decimal(factor)

return None

def humanReadable(self, places=None, max_places=2):
        """ Return a string representation of this size with appropriate
            size specifier and in the specified number of decimal places
            (i.e. the maximal precision is only achieved by setting both places
            and max_places to None).
        """
        if places is not None and places < 0:
            raise SizePlacesError("places= must be >=0 or None")

if max_places is not None and max_places < 0:
            raise SizePlacesError("max_places= must be >=0 or None")

in_bytes = int(Decimal(self))
        if abs(in_bytes) < 1000:
            return "%d %s" % (in_bytes, _(_bytes_letter))

prev_prefix = None
        for prefix_item in _xlated_prefixes():
            factor, prefix, abbr = prefix_item
            newcheck = super(Size, self).__div__(Decimal(factor))

if abs(newcheck) < 1000:
                # nice value, use this factor, prefix and abbr
                break
            prev_prefix = prefix_item
        else:
            # no nice value found, just return size in bytes
            return "%s %s" % (in_bytes, _(_bytes_letter))

if abs(newcheck) < 10:
            if prev_prefix is not None:
                factor, prefix, abbr = prev_prefix # pylint: disable=unpacking-non-sequence
                newcheck = super(Size, self).__div__(Decimal(factor))
            else:
                # less than 10 KiB
                return "%s %s" % (in_bytes, _(_bytes_letter))

retval = newcheck
        if places is not None:
            retval = round(newcheck, places)

if max_places is not None:
            if places is not None:
                limit = min((places, max_places))
            else:
                limit = max_places
            retval = round(newcheck, limit)

if retval == int(retval):
            # integer value, no point in showing ".0" at the end
            retval = int(retval)

# Format the value with '.' as the decimal separator
        # If necessary, substitute with a localized separator before returning
        retval_str = str(retval)
        radix = locale.nl_langinfo(locale.RADIXCHAR)
        if radix != '.':
            retval_str = retval_str.replace('.', radix)

# abbr and prefix are unicode objects so that lower/upper work correctly
        # Convert them to str before concatenating so that the return type is
        # str.
        # pylint: disable=undefined-loop-variable
        if abbr:
            return retval_str + " " + abbr.encode("utf-8") + _(_bytes_letter)
        else:
            return retval_str + " " + prefix.encode("utf-8") + P_("byte", "bytes", newcheck)

def roundToNearest(self, unit, rounding=ROUND_DEFAULT):
        """
            :param str unit: a unit specifier
            :keyword rounding: which direction to round
            :type rounding: one of ROUND_UP, ROUND_DOWN, or ROUND_DEFAULT
            :returns: Size rounded to nearest whole specified unit
            :rtype: :class:`Size`
        """
        if rounding not in (ROUND_UP, ROUND_DOWN, ROUND_DEFAULT):
            raise ValueError("invalid rounding specifier")

rounded = self.convertTo(unit).to_integral_value(rounding=rounding)
        return Size("%s %s" % (rounded, unit))

X7ROOT File Manager

Editing: size.py

Upload File

Create Folder