File _service:obs_scm:pyparted-1466619794.7a0f829.ob... of Package python3-pyparted

Overview Repositories Revisions Requests Users Attributes Meta

File _service:obs_scm:pyparted-1466619794.7a0f829.obscpio of Package python3-pyparted

07070100115821000081A40000FFFE0000FFFD0000000157CD697A000011D0000000FC0000001000000000000000000000004300000000pyparted-1466619794.7a0f829/examples/make_one_primary_partition.py# coding=utf-8
#
# Copyright 2015 John Florian <jflorian@doubledog.org>
#
# This example script is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by the Free
# Software Foundation, either version 3 of the License, or (at your option) any
# later version so long as this copyright notice remains intact.
#
# This example script is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty 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 example script.  If not, see <http://www.gnu.org/licenses/>.

"""
An example program that creates a single, bootable primary partition on a disk.
"""
from glob import glob
from logging import getLogger
import logging

import parted

class _ConsoleHandler(logging.StreamHandler):
    def __init__(self):
        super().__init__()
        self.setFormatter(
            logging.Formatter('{levelname} - {message}', style='{')
        )

class ExampleDevice(object):
    """
    A simple model of a block storage device that wraps up some examples of
    pyparted capabilities.
    """

def __init__(self, path):
        """
        Initialize the ExampleDevice object.
        """
        self.path = path
        self.logger = getLogger(__name__)

@property
    def partition_names(self):
        """
        @return:    A list of partition device names on the block device.
        @rtype:     str
        """
        names = glob('{}[0-9]*'.format(self.path))
        self.logger.debug('has partitions %s', names)
        return names

def partition(self):
        """
        Create a partition table on the block device.

The newly created partition will have the following characteristics:
            - a primary partition using 100% of the device capacity
            - optimal alignment given the disk topology information
            - a MS-DOS disk label for simple BIOS booting on PC-type hardware
            - marked as bootable
        """
        self.logger.info('creating primary partition')
        device = parted.getDevice(self.path)
        self.logger.debug('created %s', device)
        disk = parted.freshDisk(device, 'msdos')
        self.logger.debug('created %s', disk)
        geometry = parted.Geometry(device=device, start=1,
                                   length=device.getLength() - 1)
        self.logger.debug('created %s', geometry)
        filesystem = parted.FileSystem(type='ext3', geometry=geometry)
        self.logger.debug('created %s', filesystem)
        partition = parted.Partition(disk=disk, type=parted.PARTITION_NORMAL,
                                     fs=filesystem, geometry=geometry)
        self.logger.debug('created %s', partition)
        disk.addPartition(partition=partition,
                          constraint=device.optimalAlignedConstraint)
        partition.setFlag(parted.PARTITION_BOOT)
        disk.commit()

def wipe_dev(self, dev_path):
        """
        Wipe a device (partition or otherwise) of meta-data, be it file system,
        LVM, etc.

@param dev_path:    Device path of the partition to be wiped.
        @type dev_path:     str
        """
        self.logger.debug('wiping %s', dev_path)
        with open(dev_path, 'wb') as p:
            p.write(bytearray(1024))

def wipe(self):
        """
        Wipe the block device of meta-data, be it file system, LVM, etc.

This is not intended to be secure, but rather to ensure that
        auto-discovery tools don't recognize anything here.
        """
        self.logger.info('wiping partitions and other meta-data')
        for partition in self.partition_names:
            self.wipe_dev(partition)
        self.wipe_dev(self.path)

if __name__ == '__main__':
    # It should be plenty obvious what needs to be done here.  If it's not
    # obvious to you, please don't run this!!!
    my_unimportant_test_disk = '/dev/sdX__FIXME'

# Set up a logger for nice visibility.
    logger = getLogger(__name__)
    logger.setLevel(logging.DEBUG)
    logger.addHandler(_ConsoleHandler())

# Ok, now for the good stuff, the actual example.
    guinea_pig = ExampleDevice(my_unimportant_test_disk)
    guinea_pig.wipe()
    guinea_pig.partition()
07070100115828000081A40000FFFE0000FFFD0000000157CD697A0000404A000000FC0000001000000000000000000000003300000000pyparted-1466619794.7a0f829/src/parted/__init__.py#
# __init__.py
# Python bindings for libparted (built on top of the _ped Python module).
#
# Copyright (C) 2007-2015 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.
#
# Author(s): David Cantrell <dcantrell@redhat.com>
#            Chris Lumens <clumens@redhat.com>
#            Alex Skinner <alex@lx.lc>
#

from __future__ import division

import platform
import re
import sys
import warnings
import _ped

__all__ = ['Alignment', 'Constraint', 'Device', 'Disk',
           'FileSystem', 'Geometry', 'Partition']

from _ped import AlignmentException
from _ped import CreateException
from _ped import ConstraintException
from _ped import DeviceException
from _ped import DiskException
from _ped import DiskLabelException
from _ped import FileSystemException
from _ped import GeometryException
from _ped import IOException
from _ped import NotNeededException
from _ped import PartedException
from _ped import PartitionException
from _ped import TimerException
from _ped import UnknownDeviceException
from _ped import UnknownTypeException

from _ped import register_exn_handler
from _ped import clear_exn_handler

from parted.alignment import Alignment
from parted.constraint import Constraint
from parted.device import Device
from parted.disk import Disk
from parted.disk import diskType
from parted.disk import diskFlag
from parted.filesystem import FileSystem
from parted.filesystem import fileSystemType
from parted.geometry import Geometry
from parted.partition import Partition
from parted.partition import partitionFlag

# the enumerated types in _ped need to be available from here too
from _ped import UNIT_SECTOR
from _ped import UNIT_BYTE
from _ped import UNIT_KILOBYTE
from _ped import UNIT_MEGABYTE
from _ped import UNIT_GIGABYTE
from _ped import UNIT_TERABYTE
from _ped import UNIT_COMPACT
from _ped import UNIT_CYLINDER
from _ped import UNIT_CHS
from _ped import UNIT_PERCENT
from _ped import UNIT_KIBIBYTE
from _ped import UNIT_MEBIBYTE
from _ped import UNIT_GIBIBYTE
from _ped import UNIT_TEBIBYTE

from _ped import DEVICE_UNKNOWN
from _ped import DEVICE_SCSI
from _ped import DEVICE_IDE
from _ped import DEVICE_DAC960
from _ped import DEVICE_CPQARRAY
from _ped import DEVICE_FILE
from _ped import DEVICE_ATARAID
from _ped import DEVICE_I2O
from _ped import DEVICE_UBD
from _ped import DEVICE_DASD
from _ped import DEVICE_VIODASD
from _ped import DEVICE_SX8
from _ped import DEVICE_DM
from _ped import DEVICE_XVD
from _ped import DEVICE_SDMMC
from _ped import DEVICE_VIRTBLK

from _ped import PARTITION_NORMAL
from _ped import PARTITION_LOGICAL
from _ped import PARTITION_EXTENDED
from _ped import PARTITION_FREESPACE
from _ped import PARTITION_METADATA
from _ped import PARTITION_PROTECTED

from _ped import PARTITION_BOOT
from _ped import PARTITION_ROOT
from _ped import PARTITION_SWAP
from _ped import PARTITION_HIDDEN
from _ped import PARTITION_RAID
from _ped import PARTITION_LVM
from _ped import PARTITION_LBA
from _ped import PARTITION_HPSERVICE
from _ped import PARTITION_PALO
from _ped import PARTITION_PREP
from _ped import PARTITION_MSFT_RESERVED
from _ped import PARTITION_APPLE_TV_RECOVERY
from _ped import PARTITION_BIOS_GRUB
from _ped import PARTITION_DIAG
from _ped import PARTITION_LEGACY_BOOT
if hasattr(_ped, 'PARTITION_MSFT_DATA'):
    # pylint: disable=E0611
    from _ped import PARTITION_MSFT_DATA
if hasattr(_ped, 'PARTITION_IRST'):
    # pylint: disable=E0611
    from _ped import PARTITION_IRST
if hasattr(_ped, 'PARTITION_ESP'):
    # pylint: disable=E0611
    from _ped import PARTITION_ESP
if hasattr(_ped, 'PARTITION_NONFS'):
    # pylint: disable=E0611
    from _ped import PARTITION_NONFS

from _ped import DISK_CYLINDER_ALIGNMENT
from _ped import DISK_GPT_PMBR_BOOT

from _ped import DISK_TYPE_EXTENDED
from _ped import DISK_TYPE_PARTITION_NAME

from _ped import EXCEPTION_TYPE_INFORMATION
from _ped import EXCEPTION_TYPE_WARNING
from _ped import EXCEPTION_TYPE_ERROR
from _ped import EXCEPTION_TYPE_FATAL
from _ped import EXCEPTION_TYPE_BUG
from _ped import EXCEPTION_TYPE_NO_FEATURE

from _ped import EXCEPTION_RESOLVE_UNHANDLED
from _ped import EXCEPTION_RESOLVE_FIX
from _ped import EXCEPTION_RESOLVE_YES
from _ped import EXCEPTION_RESOLVE_NO
from _ped import EXCEPTION_RESOLVE_OK
from _ped import EXCEPTION_RESOLVE_RETRY
from _ped import EXCEPTION_RESOLVE_IGNORE
from _ped import EXCEPTION_RESOLVE_CANCEL

from _ped import EXCEPTION_OPT_OK_CANCEL
from _ped import EXCEPTION_OPT_YES_NO
from _ped import EXCEPTION_OPT_YES_NO_CANCEL
from _ped import EXCEPTION_OPT_IGNORE_CANCEL
from _ped import EXCEPTION_OPT_RETRY_CANCEL
from _ped import EXCEPTION_OPT_RETRY_IGNORE_CANCEL

from parted.decorators import localeC

if sys.version_info >= (3,):
    string_types = str
else:
    string_types = basestring # pylint: disable=undefined-variable

partitionTypesDict = {
    0x00: "Empty",
    0x01: "DOS 12-bit FAT",
    0x02: "XENIX root",
    0x03: "XENIX usr",
    0x04: "DOS 16-bit <32M",
    0x05: "Extended",
    0x06: "DOS 16-bit >=32M",
    0x07: "NTFS/HPFS",
    0x08: "AIX",
    0x09: "AIX bootable",
    0x0a: "OS/2 Boot Manager",
    0x0b: "Win95 FAT32",
    0x0c: "Win95 FAT32",
    0x0e: "Win95 FAT16",
    0x0f: "Win95 Ext'd",
    0x10: "OPUS",
    0x11: "Hidden FAT12",
    0x12: "Compaq Setup",
    0x14: "Hidden FAT16 <32M",
    0x16: "Hidden FAT16",
    0x17: "Hidden HPFS/NTFS",
    0x18: "AST SmartSleep",
    0x1b: "Hidden Win95 FAT32",
    0x1c: "Hidden Win95 FAT32 (LBA)",
    0x1e: "Hidden Win95 FAT16 (LBA)",
    0x24: "NEC_DOS",
    0x39: "Plan 9",
    0x40: "Venix 80286",
    0x41: "PPC_PReP Boot",
    0x42: "SFS",
    0x4d: "QNX4.x",
    0x4e: "QNX4.x 2nd part",
    0x4f: "QNX4.x 2nd part",
    0x51: "Novell?",
    0x52: "Microport",
    0x63: "GNU HURD",
    0x64: "Novell Netware 286",
    0x65: "Novell Netware 386",
    0x75: "PC/IX",
    0x80: "Old MINIX",
    0x81: "Linux/MINIX",
    0x82: "Linux swap",
    0x83: "Linux native",
    0x84: "OS/2 hidden C:",
    0x85: "Linux Extended",
    0x86: "NTFS volume set",
    0x87: "NTFS volume set",
    0x8e: "Linux LVM",
    0x93: "Amoeba",
    0x94: "Amoeba BBT",
    0x9f: "BSD/OS",
    0xa0: "IBM Thinkpad hibernation",
    0xa5: "BSD/386",
    0xa6: "OpenBSD",
    0xb7: "BSDI fs",
    0xb8: "BSDI swap",
    0xbf: "Solaris",
    0xc7: "Syrinx",
    0xdb: "CP/M",
    0xde: "Dell Utility",
    0xe1: "DOS access",
    0xe3: "DOS R/O",
    0xeb: "BEOS",
    0xee: "EFI GPT",
    0xef: "EFI (FAT-12/16/32)",
    0xf2: "DOS secondary",
    0xfd: "Linux RAID",
    0xff: "BBT"
}

# Exponents for 1024 used when converting sizes to byte-sized
# units for display.  The keys are:
#   b     bytes       1024^0 = 1
#   kb    kilobytes   1024^1 = 1024
#   mb    megabytes   1024^2 = 1048576
#   gb    gigabytes   1024^3 = 1073741824
#   tb    terabytes   1024^4 = 1099511627776
#   pb    petabytes   1024^5 = 1125899906842624
#   eb    exabytes    1024^6 = 1152921504606846976
#   zb    zettabytes  1024^7 = 1180591620717411303424
#   yb    yottabytes  1024^8 = 1208925819614629174706176
# The resulting value for 1024 raised to the power is used as
# the divisor for conversion functions.
_exponent = {'b': 0, 'kb': 1, 'mb': 2, 'gb': 3, 'tb': 4,
             'pb': 5, 'eb': 6, 'zb': 7, 'yb': 8}

# Refercences:
#
# 1. NIST Special Publication 330, 2008 Edition, Barry N. Taylor and Ambler
#    Thompson, Editors
#    The International System of Units (SI)
#    Available from: http://physics.nist.gov/cuu/pdf/sp811.pdf
#
# 2. International standard IEC 60027-2, third edition,
#    Letter symbols to be used in electrical technology --
#    Part 2: Telecommunications and electronics.
#
# See the links below for quick online summaries:
#
# SI units:  http://physics.nist.gov/cuu/Units/prefixes.html
# IEC units: http://physics.nist.gov/cuu/Units/binary.html
__exponents = {
    "B":    1,       # byte
    "kB":   1000**1, # kilobyte
    "MB":   1000**2, # megabyte
    "GB":   1000**3, # gigabyte
    "TB":   1000**4, # terabyte
    "PB":   1000**5, # petabyte
    "EB":   1000**6, # exabyte
    "ZB":   1000**7, # zettabyte
    "YB":   1000**8, # yottabyte

"KiB":  1024**1, # kibibyte
    "MiB":  1024**2, # mebibyte
    "GiB":  1024**3, # gibibyte
    "TiB":  1024**4, # tebibyte
    "PiB":  1024**5, # pebibyte
    "EiB":  1024**6, # exbibyte
    "ZiB":  1024**7, # zebibyte
    "YiB":  1024**8  # yobibyte
}

def formatBytes(bytes_, unit):
    """Convert bytes_ using an SI or IEC prefix. Note that unit is a
       case sensitive string that must exactly match one of the IEC or SI
       prefixes followed by 'B' (e.g. 'GB')."""

if unit not in __exponents.keys():
        raise SyntaxError("{:} is not a valid SI or IEC byte unit".format(unit))
    else:
        return (bytes_ / __exponents[unit])

def sizeToSectors(bytes_, unit, sector_size):
    """Convert bytes_ of unit to a number of sectors. Note that unit is a
       case sensitive string that must exactly match one of the IEC or SI
       prefixes followed by 'B' (e.g. 'GB')."""

if unit not in __exponents.keys():
        raise SyntaxError("{:} is not a valid SI or IEC byte unit".format(unit))
    else:
        return bytes_ * __exponents[unit] // sector_size

# Valid disk labels per architecture type.  The list of label
# names map to keys in the parted.diskType hash table.
archLabels = {'i386': ['msdos', 'gpt'],
              's390': ['dasd', 'msdos'],
              'alpha': ['bsd', 'msdos'],
              'sparc': ['sun'],
              'ia64': ['msdos', 'gpt'],
              'ppc': ['msdos', 'mac', 'amiga', 'gpt'],
              'ppc64': ['msdos', 'mac', 'amiga', 'gpt'],
              'ppc64le': ['msdos', 'gpt'],
              'x86_64': ['msdos', 'gpt'],
              'aarch64': ['msdos', 'gpt'],
              'armv7l': ['msdos', 'gpt']}

# Adapted from:
# http://stackoverflow.com/questions/922550/how-to-mark-a-global-as-deprecated-in-python
#
# Remember that DeprecationWarnings are ignored by default as they are not really
# useful to users.  Developers can turn on DeprecationWarning notices by passing
# the -Wd option to python or by setting PYTHONWARNINGS=d in the environment.
def Deprecated(mod, deprecated=None):
    """ Return a wrapped object that warns about deprecated accesses. """

if not deprecated:
        deprecated = {}

class Wrapper(object):
        warnmsg = "%s is deprecated and will be removed in a future release."

def __getattr__(self, attr):
            if attr in deprecated.keys():
                msg = self.warnmsg + " " + deprecated[attr]
                warnings.warn(msg % attr, DeprecationWarning)

return getattr(mod, attr)

def __setattr__(self, attr, value):
            if attr in deprecated.keys():
                msg = self.warnmsg + " " + deprecated[attr]
                warnings.warn(msg % attr, DeprecationWarning)
            setattr(mod, attr, value)

return Wrapper()

# Valid disk labels and their applicable architectures.  The label names map
# to keys in the parted.diskType hash table.
__archLabels = (('amiga', 'ppc(64)?$'),
                ('bsd', 'alpha$'),
                ('dasd', 's390x?$'),
                ('gpt', 'i[3-6]86$|x86_64$|ia64$|ppc(64|64le)?$|aarch64$|armv7l$'),
                ('mac', 'ppc(64)?$'),
                ('msdos', 'i[3-6]86$|x86_64$|s390x?$|alpha$|ia64$|ppc(64|64le)?$|aarch64$|armv7l$'),
                ('sun', 'sparc(64)?$'))

def getLabels(arch=None):
    """Return a set containing the disk labels compatible with the
       architecture of the computer calling this function. If an architecture
       is passed, return the labels compatible with that architecture."""
    labels = set()
    if arch is None:
        arch = platform.machine()

for label, regex in __archLabels:
        if re.match(regex, arch):
            labels.add(label)

return labels

class ReadOnlyProperty(Exception):
    """Exception raised when a write operation occurs on a read-only property."""

# pylint: disable=W0231
    def __init__(self, prop=''):
        self.message = "%s is a read-only property" % (prop,)

class WriteOnlyProperty(Exception):
    """Exception raised when a read operation occurs on a write-only property."""

# pylint: disable=W0231
    def __init__(self, prop=''):
        self.message = "%s is a write-only property" % (prop,)

@localeC
def getDevice(path):
    """Given the operating system level path to a device node, return
       a Device object for that disk.  Raises DeviceException if an invalid
       path is given."""
    return Device(path=path)

@localeC
def getAllDevices():
    """Return a list of Device objects for all devices in the system."""
    from _ped import device_probe_all
    from _ped import device_get_next

lst = []
    device = None

device_probe_all()

while True:
        try:
            if not device:
                device = device_get_next()
            else:
                device = device_get_next(device)

lst.append(Device(PedDevice=device))
        except IndexError:
            return lst

@localeC
def freeAllDevices():
    """Free all Device objects.  There is no reason to call this function."""
    from _ped import device_free_all
    return device_free_all()

@localeC
def probeForSpecificFileSystem(fstype, geometry):
    """Call the _ped.file_system_probe_specific() function given the
       filesystem type and geometry.  fstype must be a string
       representing a valid _ped.FileSystemType, geometry is a
       parted.Geometry."""
    from _ped import file_system_probe_specific
    geom = file_system_probe_specific(fileSystemType[fstype], geometry.getPedGeometry())
    return geometry.Geometry(PedGeometry=geom)

@localeC
def probeFileSystem(geometry):
    """Return the name of the filesystem detected on the given
       Geometry.  Returns None is no filesystem found."""
    from _ped import file_system_probe
    fstype = file_system_probe(geometry.getPedGeometry())
    return fstype.name

@localeC
def freshDisk(device, ty):
    """Return a Disk object for this Device and using this DiskType.
       The type should be a member of the parted.diskType hash,
       either a key or a value.

The new label is not written to disk until commitToDevice()
       is called on the Disk."""
    from _ped import disk_new_fresh, DiskType

if isinstance(ty, string_types):
        ty = diskType[ty]
    elif not isinstance(ty, DiskType):
        raise TypeError("type must be a key or value in parted.diskType", ty)

peddisk = disk_new_fresh(device.getPedDevice(), ty)
    return Disk(PedDisk=peddisk)

@localeC
def newDisk(device):
    """Return a Disk object for this Device. Read the partition table off
       a device (if one is found)."""
    from _ped import disk_new

peddisk = disk_new(device.getPedDevice())
    return Disk(PedDisk=peddisk)

@localeC
def version():
    """Return a dict containing the pyparted and libparted versions."""
    from _ped import libparted_version
    from _ped import pyparted_version

ver = {}
    ver['libparted'] = libparted_version()
    ver['pyparted'] = pyparted_version()
    return ver

# Mark deprecated items
_deprecated = {"partitionTypesDict": "DOS disk label types are not provided "
                                     "by libparted, so the codes are not "
                                     "useful.",
               "_exponent":          "Use __exponents instead.",
               "archLabels":         "Use getLabels() instead.",
              }
sys.modules[__name__] = Deprecated(sys.modules[__name__], _deprecated)
07070100115829000081A40000FFFE0000FFFD0000000157CD697A00003150000000FC0000001000000000000000000000003100000000pyparted-1466619794.7a0f829/src/parted/device.py#
# device.py
# Python bindings for libparted (built on top of the _ped Python module).
#
# Copyright (C) 2009-2013 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.
#
# Author(s): David Cantrell <dcantrell@redhat.com>
#            Alex Skinner <alex@lx.lc>
#

import sys
if sys.version_info >= (3, ):
    long = int

import math
import warnings

import parted
import _ped

from parted.decorators import localeC

class Device(object):
    """Device()

Device represents a phyiscal piece of hardware in the system, e.g. a
       disk.  A Device should be considered a low-level and operating system
       specific interface to the hardware.

A number of read-only properties about the Device are available.

For information on the individual methods, see help(Device.METHODNAME)"""

@localeC
    def __init__(self, path=None, PedDevice=None):
        """Create a new Device object based on the specified path or the
           already existing _ped.Device object.  You must provide either a
           path (e.g., "/dev/sda") or an existing _ped.Device object, but
           not both."""

if PedDevice:
            self.__device = PedDevice
        elif path is not None:
            self.__device = _ped.device_get(path)
        else:
            raise parted.DeviceException("no path or PedDevice specified")

def __eq__(self, other):
        return not self.__ne__(other)

def __ne__(self, other):
        if not isinstance(self, other.__class__):
            return True

return self.model != other.model or self.path != other.path or self.type != other.type or self.length != other.length

def __getCHS(self, geometry):
        return (geometry.cylinders, geometry.heads, geometry.sectors)

@property
    def model(self):
        """Model name and vendor of this device."""
        return self.__device.model

@property
    def path(self):
        """Filesystem node path of this device (e.g., /dev/sda)."""
        return self.__device.path

@property
    def type(self):
        """Type of this device.  An integer constant corresponding
           to one of the parted.DEVICE_* values.
        """
        return self.__device.type

@property
    def sectorSize(self):
        """Sector size (in bytes) for this device."""
        return self.__device.sector_size

@property
    def physicalSectorSize(self):
        """Physical sector size (in bytes) for this device.  Not always
           the same as sectorSize, but is a multiple of sectorSize.
        """
        return self.__device.phys_sector_size

@property
    def length(self):
        """The size of this device in sectors."""
        return self.__device.length

@property
    def openCount(self):
        """How many times the open() method has been called on this device."""
        return self.__device.open_count

@property
    def readOnly(self):
        """True if the device is currently in read-only mode, False
           otherwise.
        """
        return bool(self.__device.read_only)

@property
    def externalMode(self):
        """True if external access mode is currently activated on this
           device, False otherwise.  External access mode has to be used
           if you want to use an external command on the device while
           you are currently using it in pyparted.
        """
        return bool(self.__device.external_mode)

@property
    def dirty(self):
        """True if the device is marked dirty, False otherwise."""
        return bool(self.__device.dirty)

@property
    def bootDirty(self):
        """True if the device is marked boot dirty, False otherwise."""
        return bool(self.__device.boot_dirty)

@property
    def host(self):
        """The host value of this device."""
        return self.__device.host

@property
    def did(self):
        """The did value of this device."""
        return self.__device.did

@property
    def busy(self):
        """True if this device is busy, False otherwise."""
        return self.__device.is_busy()

@property
    def hardwareGeometry(self):
        """A 3-tuple representing the hardware geometry of this device.
           The tuple is in order of cylinders, heads, and sectors.
        """
        return self.__getCHS(self.__device.hw_geom)

@property
    def biosGeometry(self):
        """A 3-tuple representing the BIOS geometry of this device.
           The tuple is in order of cylinders, heads, and sectors.
        """
        return self.__getCHS(self.__device.bios_geom)

def __str__(self):
        s = ("parted.Device instance --\n"
             "  model: %(model)s  path: %(path)s  type: %(type)s\n"
             "  sectorSize: %(sectorSize)s  physicalSectorSize:  %(physSectorSize)s\n"
             "  length: %(length)s  openCount: %(openCount)s  readOnly: %(readOnly)s\n"
             "  externalMode: %(external)s  dirty: %(dirty)s  bootDirty: %(bootDirty)s\n"
             "  host: %(host)s  did: %(did)s  busy: %(busy)s\n"
             "  hardwareGeometry: %(hardwareGeom)s  biosGeometry: %(biosGeom)s\n"
             "  PedDevice: %(ped)r" %
             {"model": self.model, "path": self.path, "type": self.type,
              "sectorSize": self.sectorSize, "physSectorSize": self.physicalSectorSize,
              "length": self.length, "openCount": self.openCount, "readOnly": self.readOnly,
              "external": self.externalMode, "dirty": self.dirty, "bootDirty": self.bootDirty,
              "host": self.host, "did": self.did, "busy": self.busy,
              "hardwareGeom": self.hardwareGeometry, "biosGeom": self.biosGeometry,
              "ped": self.__device})
        return s

@localeC
    def clobber(self):
        """Remove all identifying signatures of the partition table."""
        return self.__device.clobber()

@localeC
    def open(self):
        """Open this Device for read operations."""

return self.__device.open()

@localeC
    def close(self):
        """Close this Device.  Used after open() method calls."""

return self.__device.close()

@localeC
    def destroy(self):
        """Destroy this Device.  Operating system specific."""

return self.__device.destroy()

@localeC
    def removeFromCache(self):
        """Remove this Device from the internal libparted device cache."""

return self.__device.cache_remove()

@localeC
    def beginExternalAccess(self):
        """Set up the Device for use by an external program.  Call this method
           before running an external program that uses the Device."""

return self.__device.begin_external_access()

@localeC
    def endExternalAccess(self):
        """Turn off external access mode for the Device.  Call this method once
           your external program has finished using the Device."""

return self.__device.end_external_access()

@localeC
    def read(self, start, count):
        """From the sector indentified by start, read and return count sectors
           from the Device."""

return self.__device.read(start, count)

@localeC
    def write(self, buf, start, count):
        """From the sector identified by start, write count sectors from
           buffer to the Device."""

return self.__device.write(buf, start, count)

@localeC
    def sync(self, fast=False):
        """Perform a operating-system specific sync(2) operation on the
           Device.  If fast is True, try to perform a fast sync(2)."""

if fast:
            return self.__device.sync_fast()
        else:
            return self.__device.sync()

@localeC
    def check(self, start, count):
        """From the sector identified by start, perform an operating
           system specific check on count sectors."""
        return self.__device.check(start, count)

@localeC
    def startSectorToCylinder(self, sector):
        """Return the closest cylinder (round down) to sector on
           this Device."""
        (_, heads, sectors) = self.biosGeometry
        return long(math.floor((float(sector) / (heads * sectors)) + 1))

@localeC
    def endSectorToCylinder(self, sector):
        """Return the closest cylinder (round up) to sector on
           this Device."""
        (_, heads, sectors) = self.biosGeometry
        return long(math.ceil(float((sector + 1)) / (heads * sectors)))

@localeC
    def startCylinderToSector(self, cylinder):
        """Return the sector corresponding to cylinder as a
           starting cylinder on this Device."""
        (_, heads, sectors) = self.biosGeometry
        return long((cylinder - 1) * (heads * sectors))

@localeC
    def endCylinderToSector(self, cylinder):
        """Return the sector corresponding to cylinder as an
           ending cylinder on this Device."""
        (_, heads, sectors) = self.biosGeometry
        return long(((cylinder) * (heads * sectors)) - 1)

def getSize(self, unit="MB"):
        """Return the size of the Device in the unit specified.  The unit
           is given as a string corresponding to one of the following
           abbreviations:  b (bytes), KB (kilobytes), MB (megabytes), GB
           (gigabytes), TB (terabytes).  An invalid unit string will raise a
           SyntaxError exception.  The default unit is MB."""
        warnings.warn("use the getLength method", DeprecationWarning)
        lunit = unit.lower()

if lunit not in parted._exponent.keys():
            raise SyntaxError("invalid unit %s given" % (unit))

size = float(self.__device.length)
        size /= math.pow(1024.0, parted._exponent[lunit])
        size *= self.sectorSize

return size

@localeC
    def getLength(self, unit='sectors'):
        """Return the length of the device in sectors. Optionally, a SI or
           IEC prefix followed by a 'B' may be given in order to convert the
           length into bytes. The allowed values include B, kB, MB, GB, TB, KiB,
           MiB, GiB, and TiB."""
        sectors = self.__device.length
        if unit == "sectors":
            return sectors
        return parted.formatBytes(sectors * self.sectorSize, unit)

@localeC
    def getConstraint(self):
        """Return a Constraint defining the limitations imposed by
           this Device."""
        return parted.Constraint(PedConstraint=self.__device.get_constraint())

@property
    @localeC
    def minimalAlignedConstraint(self):
        """Return a Constraint defining the limitations and minimal advisable
           alignment imposed by this Device."""
        constraint = self.__device.get_minimal_aligned_constraint()
        return parted.Constraint(PedConstraint=constraint)

@property
    @localeC
    def optimalAlignedConstraint(self):
        """Return a Constraint defining the limitations and optimal
           alignment imposed by this Device."""
        constraint = self.__device.get_optimal_aligned_constraint()
        return parted.Constraint(PedConstraint=constraint)

@property
    @localeC
    def minimumAlignment(self):
        """Return an Alignment defining the minimum alignment for this Device."""
        alignment = self.__device.get_minimum_alignment()
        return parted.Alignment(PedAlignment=alignment)

@property
    @localeC
    def optimumAlignment(self):
        """Return an Alignment defining the optimum alignment for this Device."""
        alignment = self.__device.get_optimum_alignment()
        return parted.Alignment(PedAlignment=alignment)

def getPedDevice(self):
        """Return the _ped.Device object contained in this Device.
           For internal module use only."""
        return self.__device
0707010011582A000081A40000FFFE0000FFFD0000000157CD697A000006E7000000FC0000001000000000000000000000003500000000pyparted-1466619794.7a0f829/src/parted/decorators.py#
# Python bindings for libparted (built on top of the _ped Python module).
#
# Copyright (C) 2009 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): Peter Jones <pjones@redhat.com>
#

import locale
import functools

def localeC(fn):
    # setlocale is not thread-safe, and anaconda (at least) may call this from
    # another thread.  This is just a luxury to have untranslated tracebacks,
    # so it's not worth tracebacking itself.
    def _setlocale(l):
        try:
            locale.setlocale(locale.LC_MESSAGES, l)
        # pylint: disable=bare-except
        except:
            pass

@functools.wraps(fn)
    def new(*args, **kwds):
        oldlocale = locale.getlocale(locale.LC_MESSAGES)
        _setlocale('C')
        try:
            ret = fn(*args, **kwds)
        finally:
            _setlocale(oldlocale)
        return ret
    return new
0707010011582B000081A40000FFFE0000FFFD0000000157CD697A000044F4000000FC0000001000000000000000000000002F00000000pyparted-1466619794.7a0f829/src/parted/disk.py#
# disk.py
# Python bindings for libparted (built on top of the _ped Python module).
#
# Copyright (C) 2009-2013 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.
#
# Author(s): David Cantrell <dcantrell@redhat.com>
#            Alex Skinner <alex@lx.lc>
#

import _ped
import parted

from parted.cachedlist import CachedList
from parted.decorators import localeC

class Disk(object):
    """Disk()

A Disk object describes a type of device in the system.  Disks
       can hold partitions.  A Disk is a basic operating system-specific
       object."""
    @localeC
    def __init__(self, device=None, PedDisk=None):
        """Create a new Disk object from the device and type specified.  The
           device is a Device object and type is a string matching a key in
           the diskType hash."""
        if PedDisk:
            self.__disk = PedDisk

if device is None:
                self._device = parted.Device(PedDevice=self.__disk.dev)
            else:
                self._device = device
        elif device is None:
            raise parted.DiskException("no device specified")
        else:
            self.__disk = _ped.Disk(device.getPedDevice())
            self._device = device

# pylint: disable=W0108
        self._partitions = CachedList(lambda : self.__getPartitions())

def _hasSameParts(self, other):
        import six

if len(self.partitions) != len(other.partitions):
            return False

partIter = six.moves.zip(self.partitions, other.partitions)
        while True:
            try:
                (left, right) = next(partIter)
                if left != right:
                    return False
            except StopIteration:
                return True

def __eq__(self, other):
        return not self.__ne__(other)

def __ne__(self, other):
        if not isinstance(self, other.__class__):
            return True

return self.device != other.device or not self._hasSameParts(other)

def __str__(self):
        s = ("parted.Disk instance --\n"
             "  type: %(type)s  primaryPartitionCount: %(primaryCount)s\n"
             "  lastPartitionNumber: %(last)s  maxPrimaryPartitionCount: %(max)s\n"
             "  partitions: %(partitions)s\n"
             "  device: %(device)r\n"
             "  PedDisk: %(ped)r" %
             {"type": self.type, "primaryCount": self.primaryPartitionCount,
              "last": self.lastPartitionNumber, "max": self.maxPrimaryPartitionCount,
              "partitions": self.partitions, "device": self.device,
              "ped": self.__disk})
        return s

def __getPartitions(self):
        """Construct a list of partitions on the disk.  This is called only as
           needed from the self.partitions property, which just happens to be
           a CachedList."""
        partitions = []
        partition = self.getFirstPartition()

while partition:
            if partition.type & parted.PARTITION_FREESPACE or \
               partition.type & parted.PARTITION_METADATA or \
               partition.type & parted.PARTITION_PROTECTED:
                partition = partition.nextPartition()
                continue

partitions.append(partition)
            partition = partition.nextPartition()

return partitions

@property
    @localeC
    def primaryPartitionCount(self):
        """The number of primary partitions on this disk."""
        return self.__disk.get_primary_partition_count()

@property
    @localeC
    def lastPartitionNumber(self):
        """The last assigned partition number currently on this disk."""
        return self.__disk.get_last_partition_num()

@property
    @localeC
    def maxPrimaryPartitionCount(self):
        """The maximum number of primary partitions allowed on this disk."""
        return self.__disk.get_max_primary_partition_count()

@property
    @localeC
    def maxSupportedPartitionCount(self):
        """The maximum number of partitions allowed on this disk."""
        return self.__disk.get_max_supported_partition_count()

@property
    @localeC
    def partitionAlignment(self):
        """Partition start address Alignment."""
        alignment = self.__disk.get_partition_alignment()
        return parted.Alignment(PedAlignment=alignment)

@property
    @localeC
    def maxPartitionLength(self):
        """Max Partition Length the disk's label can represent."""
        return self.__disk.max_partition_length()

@property
    @localeC
    def maxPartitionStartSector(self):
        """Max Partition Start Sector the disk's label can represent."""
        return self.__disk.max_partition_start_sector()

@localeC
    def getFlag(self, flag):
        """Get the value of a particular flag on the disk.  Valid flags
           are the _ped.DISK_* constants.  See _ped.disk_flag_get_name() and
           _ped.disk_flag_get_by_name() for more help working with disk flags.
        """
        return self.__disk.get_flag(flag)

@localeC
    def setFlag(self, flag):
        """Set the flag on this disk.  On error, an Exception will be raised.
           See getFlag() for more help on working with disk flags."""
        return self.__disk.set_flag(flag, 1)

@localeC
    def unsetFlag(self, flag):
        """Unset the flag on this disk.  On error, an Exception will be raised.
           See getFlag() for more help on working with disk flags."""
        return self.__disk.set_flag(flag, 0)

@localeC
    def isFlagAvailable(self, flag):
        """Return True if flag is available on this Disk, False
           otherwise."""
        return self.__disk.is_flag_available(flag)

@property
    def partitions(self):
        """The list of partitions currently on this disk."""
        return self._partitions

@property
    def device(self):
        """The underlying Device holding this disk and partitions."""
        return self._device

type = property(lambda s: s.__disk.type.name, lambda s, v: setattr(s.__disk, "type", parted.diskType[v]))

@localeC
    def duplicate(self):
        """Make a deep copy of this Disk."""
        return Disk(PedDisk=self.__disk.duplicate())

@localeC
    def destroy(self):
        """Closes the Disk ensuring all outstanding writes are flushed."""
        return self.__disk.destroy()

@localeC
    def commit(self):
        """Writes in-memory changes to a partition table to disk and
           informs the operating system of the changes.  Equivalent to
           calling self.commitToDevice() then self.commitToOS()."""
        self.partitions.invalidate()

return self.__disk.commit()

@localeC
    def commitToDevice(self):
        """Write the changes made to the in-memory description of a
           partition table to the device."""
        self.partitions.invalidate()

return self.__disk.commit_to_dev()

@localeC
    def commitToOS(self):
        """Tell the operating system kernel about the partition table
           layout of this Disk."""
        self.partitions.invalidate()

return self.__disk.commit_to_os()

@localeC
    def check(self):
        """Perform a sanity check on the partition table of this Disk."""
        return self.__disk.check()

@localeC
    def supportsFeature(self, feature):
        """Check that the disk type supports the provided feature."""
        return self.__disk.type.check_feature(feature)

@localeC
    def addPartition(self, partition=None, constraint=None):
        """Add a new Partition to this Disk with the given Constraint."""
        if constraint:
            result = self.__disk.add_partition(partition.getPedPartition(),
                                               constraint.getPedConstraint())
        elif not partition:
            raise parted.DiskException("no partition or constraint specified")
        else:
            result = self.__disk.add_partition(partition.getPedPartition())

if result:
            partition.geometry = parted.Geometry(PedGeometry=partition.getPedPartition().geom)
            self.partitions.invalidate()
            return True
        else:
            return False

@localeC
    def removePartition(self, partition=None):
        """Removes specified Partition from this Disk.  NOTE:  If the
           Partition is an extended partition, it must not contain any
           logical partitions.  Also note that the partition is not
           actually destroyed unless you use the deletePartition()
           method."""
        if not partition:
            raise parted.DiskException("no partition specified")

if self.__disk.remove_partition(partition.getPedPartition()):
            self.partitions.invalidate()
            return True
        else:
            return False

@localeC
    def deletePartition(self, partition):
        """Removes specified Partition from this Disk under the same
           conditions as removePartition(), but also destroy the
           removed Partition."""
        if self.__disk.delete_partition(partition.getPedPartition()):
            self.partitions.invalidate()
            return True
        else:
            return False

@localeC
    def deleteAllPartitions(self):
        """Removes and destroys all Partitions in this Disk."""
        if self.__disk.delete_all():
            self.partitions.invalidate()
            return True
        else:
            return False

@localeC
    def setPartitionGeometry(self, partition=None, constraint=None, start=None, end=None):
        """Sets the Geometry of the specified Partition using the given
           Constraint and start and end sectors.  Note that this method
           does not modify the partition contents, just the partition
           table."""
        if not partition or not constraint:
            raise parted.DiskException("no partition or constraint specified")

if not start or not end:
            raise parted.DiskException("no start or end geometry specified")

return self.__disk.set_partition_geom(partition.getPedPartition(),
                                              constraint.getPedConstraint(),
                                              start, end)

@localeC
    def maximizePartition(self, partition=None, constraint=None):
        """Grow the Partition's Geometry to the maximum possible subject
           to Constraint."""
        if not partition:
            raise parted.DiskException("no partition specified")

if constraint:
            return self.__disk.maximize_partition(partition.getPedPartition(),
                                                  constraint.getPedConstraint())
        else:
            return self.__disk.maximize_partition(partition.getPedPartition())

@localeC
    def calculateMaxPartitionGeometry(self, partition=None, constraint=None):
        """Get the maximum Geometry the Partition can be grown to,
           subject to the given Constraint."""
        if not partition:
            raise parted.DiskException("no partition specified")

if constraint:
            return parted.Geometry(PedGeometry=self.__disk.get_max_partition_geometry(partition.getPedPartition(), constraint.getPedConstraint()))
        else:
            return parted.Geometry(PedGeometry=self.__disk.get_max_partition_geometry(partition.getPedPartition()))

@localeC
    def minimizeExtendedPartition(self):
        """Reduce the size of the extended partition to a minimum while
           still wrapping its logical partitions.  If there are no logical
           partitions, remove the extended partition."""
        ret = self.__disk.minimize_extended_partition()

if ret:
            self.partitions.invalidate()

return ret

@localeC
    def getPartitionBySector(self, sector):
        """Returns the Partition that contains the sector.  If the sector
           lies within a logical partition, then the logical partition is
           returned (not the extended partition)."""
        return parted.Partition(disk=self, PedPartition=self.__disk.get_partition_by_sector(sector))

def getMaxLogicalPartitions(self):
        """Return the maximum number of logical partitions this Disk
           will hold.  Returns 0 if there is no extended partition on
           the disk, returns 11 when all else fails."""
        if not self.supportsFeature(parted.DISK_TYPE_EXTENDED):
            return 0

# maximum number of logical partitions per device type
        maxLogicalPartitionCount = {
            "hd": 59,
            "sd": 11,
            "ataraid/": 11,
            "rd/": 3,
            "cciss/": 11,
            "i2o/": 11,
            "iseries/vd": 3,
            "ida/": 11,
            "sx8/": 11,
            "xvd": 11,
            "vd": 11,
            "mmcblk": 5
        }

dev = self.device.path[5:]
        for key in maxLogicalPartitionCount.keys():
            if dev.startswith(key):
                return maxLogicalPartitionCount[key]

# XXX: if we don't know about it, should we pretend it can't have
        # logicals?  probably safer to just use something reasonable
        return 11

@localeC
    def getExtendedPartition(self):
        """Return the extended Partition, if any, on this Disk."""
        try:
            return parted.Partition(disk=self, PedPartition=self.__disk.extended_partition())
        # pylint: disable=bare-except
        except:
            return None

def __filterPartitions(self, fn):
        return [part for part in self.partitions if fn(part)]

def getLogicalPartitions(self):
        """Return a list of logical Partitions on this Disk."""
        return self.__filterPartitions(lambda p: p.active and p.type & parted.PARTITION_LOGICAL)

def getPrimaryPartitions(self):
        """Return a list of primary (or normal) Partitions on this Disk."""
        return self.__filterPartitions(lambda p: p.type == parted.PARTITION_NORMAL)

def getRaidPartitions(self):
        """Return a list of RAID (or normal) Partitions on this Disk."""
        return self.__filterPartitions(lambda p: p.active and p.getFlag(parted.PARTITION_RAID))

def getLVMPartitions(self):
        """Return a list of physical volume-type Partitions on this Disk."""
        return self.__filterPartitions(lambda p: p.active and p.getFlag(parted.PARTITION_LVM))

@localeC
    def getFreeSpaceRegions(self):
        """Return a list of Geometry objects representing the available
           free space regions on this Disk."""
        freespace = []
        part = self.__disk.next_partition()

while part:
            if part.type & parted.PARTITION_FREESPACE:
                freespace.append(parted.Geometry(PedGeometry=part.geom))

part = self.__disk.next_partition(part)

return freespace

@localeC
    def getFreeSpacePartitions(self):
        """Return a list of Partition objects representing the available
           free space regions on this Disk."""
        freespace = []
        part = self.__disk.next_partition()

while part:
            if part.type & parted.PARTITION_FREESPACE:
                freespace.append(parted.Partition(disk=self, PedPartition=part))

part = self.__disk.next_partition(part)

return freespace

@localeC
    def getFirstPartition(self):
        """Return the first Partition object on the disk or None if
           there is not one."""
        return parted.Partition(disk=self, PedPartition=self.__disk.next_partition())

@localeC
    def getPartitionByPath(self, path):
        """Return a Partition object associated with the partition device
           path, such as /dev/sda1.  Returns None if no partition is found."""
        for partition in self.partitions:
            if partition.path == path:
                return partition

return None

def getPedDisk(self):
        """Return the _ped.Disk object contained in this Disk.  For internal
           module use only."""
        return self.__disk

# collect all disk types and store them in a hash
diskType = {}
__type = _ped.disk_type_get_next()
diskType[__type.name] = __type

while True:
    try:
        __type = _ped.disk_type_get_next(__type)
        diskType[__type.name] = __type
    except (IndexError, TypeError, _ped.UnknownTypeException):
        break

# collect all disk flags and store them in a hash
diskFlag = {}
__flag = _ped.disk_flag_next(0)
diskFlag[__flag] = _ped.disk_flag_get_name(__flag)
__readFlags = True

while __readFlags:
    __flag = _ped.disk_flag_next(__flag)
    if not __flag:
        __readFlags = False
    else:
        diskFlag[__flag] = _ped.disk_flag_get_name(__flag)
0707010011582C000081A40000FFFE0000FFFD0000000157CD697A00001473000000FC0000001000000000000000000000003400000000pyparted-1466619794.7a0f829/src/parted/alignment.py#
# geometry.py
# Python bindings for libparted (built on top of the _ped Python module).
#
# Copyright (C) 2009 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.
#
# Author(s): Chris Lumens <clumens@redhat.com>
#            David Cantrell <dcantrell@redhat.com>
#            Alex Skinner <alex@lx.lc>
#

import parted
import _ped

from parted.decorators import localeC

class Alignment(object):
    """Alignment()

An Alignment object describes constraints on how sectors and Geometry
       objects are aligned.  Being aligned means that the sector be located at
       a specific sector multiple on a device, or that a geometry must start
       and end at sectors at those specific multiples.  Most methods on this
       object raise ArithmeticError if calculating alignments fails."""
    @localeC
    def __init__(self, *args, **kwargs):
        """Create a new Alignment object from the sectors offset and
           grainSize."""
        if "PedAlignment" in kwargs:
            self.__alignment = kwargs.get("PedAlignment")
        elif "offset" in kwargs and "grainSize" in kwargs:
            self.__alignment = _ped.Alignment(kwargs.get("offset"),
                                              kwargs.get("grainSize"))
        else:
            raise parted.AlignmentException("no offset+grainSize or PedAlignment specified")

offset = property(lambda s: s.__alignment.offset, lambda s, v: setattr(s.__alignment, "offset", v))
    grainSize = property(lambda s: s.__alignment.grain_size, lambda s, v: setattr(s.__alignment, "grain_size", v))

def __eq__(self, other):
        return not self.__ne__(other)

def __ne__(self, other):
        if not isinstance(self, other.__class__):
            return True

return self.offset != other.offset or self.grainSize != other.grainSize

def __str__(self):
        s = ("parted.Alignment instance --\n"
             "  offset: %(offset)s  grainSize: %(grainSize)s\n"
             "  PedAlignment: %(ped)r" %
             {"offset": self.offset, "grainSize": self.grainSize,
              "ped": self.__alignment})
        return s

@localeC
    def intersect(self, b):
        """Create and return a new Alignment that describes the intersection of
           self and alignment b.  A sector will satisfy the new alignment iff
           it satisfies both of the original alignments.  Whether a sector
           satisfies a given alignment is determined by is_aligned()."""
        return parted.Alignment(PedAlignment=self.__alignment.intersect(b.getPedAlignment()))

@localeC
    def alignUp(self, geom, sector):
        """Return the closest sector to the provided sector that lies inside
           geom and satisfies the alignment constraint self.  This method
           prefers, but does not guarantee, that the result is beyond sector.
           If no such sector can be found, an ArithmeticError is raised."""
        return self.__alignment.align_up(geom.getPedGeometry(), sector)

@localeC
    def alignDown(self, geom, sector):
        """Return the closest sector to the provided sector that lies inside
           geom and satisfies the alignment constraint self.  This method
           prefers, but does not guarantee, that the result is below sector.
           If no such sector can be found, an ArithmeticError is raised."""
        return self.__alignment.align_down(geom.getPedGeometry(), sector)

@localeC
    def alignNearest(self, geom, sector):
        """Return the closest sector to the input sector that lies inside
           geom and satisfies the alignment constraint self.  If no such sector
           can be found, an ArithmeticError is raised."""
        return self.__alignment.align_nearest(geom.getPedGeometry(), sector)

@localeC
    def isAligned(self, geom, sector):
        """Determine whether sector lies inside geom and satisfies the
           alignment constraint self."""
        if not geom:
            raise TypeError("missing parted.Geometry parameter")

if sector is None:
            raise TypeError("missing sector parameter")

return self.__alignment.is_aligned(geom.getPedGeometry(), sector)

def getPedAlignment(self):
        """Return the _ped.Alignment object contained in this Alignment.
           For internal module use only."""
        return self.__alignment
0707010011582D000081A40000FFFE0000FFFD0000000157CD697A000020C2000000FC0000001000000000000000000000003300000000pyparted-1466619794.7a0f829/src/parted/geometry.py#
# geometry.py
# Python bindings for libparted (built on top of the _ped Python module).
#
# Copyright (C) 2009-2013 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.
#
# Author(s): Chris Lumens <clumens@redhat.com>
#            David Cantrell <dcantrell@redhat.com>
#            Alex Skinner <alex@lx.lc>
#

import math
import warnings

import parted
import _ped

from parted.decorators import localeC

class Geometry(object):
    """Geometry()

Geometry represents a region on a device in the system - a disk or
       partition.  It is expressed in terms of a starting sector and a length.
       Many methods (read and write methods in particular) throughout pyparted
       take in a Geometry object as an argument."""
    @localeC
    def __init__(self, device=None, start=None, length=None, end=None,
                 PedGeometry=None):
        """Create a new Geometry object for the given _ped.Device that extends
           for length sectors from the start sector.  Optionally, an end sector
           can also be provided."""
        if PedGeometry:
            self.__geometry = PedGeometry

if device is None:
                self._device = parted.Device(PedDevice=self.__geometry.dev)
            else:
                self._device = device
        elif not end:
            self._device = device
            self.__geometry = _ped.Geometry(self.device.getPedDevice(), start, length)
        elif not length and (end > start):
            self._device = device
            self.__geometry = _ped.Geometry(self.device.getPedDevice(), start, (end - start + 1), end=end)
        elif start and length and end and (end > start):
            self._device = device
            self.__geometry = _ped.Geometry(self.device.getPedDevice(), start, length, end=end)
        else:
            raise parted.GeometryException("must specify PedGeometry or (device, start, length) or (device, start, end) or (device, start, length, end)")

def __eq__(self, other):
        return not self.__ne__(other)

def __ne__(self, other):
        if not isinstance(self, other.__class__):
            return True

return self.device != other.device or self.start != other.start or self.length != other.length

def __str__(self):
        s = ("parted.Geometry instance --\n"
             "  start: %(start)s  end: %(end)s  length: %(length)s\n"
             "  device: %(device)r  PedGeometry: %(ped)r" %
             {"start": self.start, "end": self.end, "length": self.length,
              "device": self.device, "ped": self.__geometry})
        return s

@property
    def device(self):
        """The Device this geometry describes."""
        return self._device

start = property(lambda s: s.__geometry.start, lambda s, v: s.__geometry.set_start(v))
    end = property(lambda s: s.__geometry.end, lambda s, v: s.__geometry.set_end(v))
    length = property(lambda s: s.__geometry.length, lambda s, v: s.__geometry.set(s.__geometry.start, v))

@localeC
    def check(self, offset, granularity, count, timer=None):
        """Check the region described by self for errors on the disk.
           offset -- The beginning of the region to check, in sectors from the
                     start of the geometry.
           granularity -- How sectors should be grouped together
           count -- How many sectors from the region to check."""
        if not timer:
            return self.__geometry.check(offset, granularity, count)
        else:
            return self.__geometry.check(offset, granularity, count, timer)

@localeC
    def contains(self, b):
        """Return whether Geometry b is contained entirely within self and on
           the same physical device."""
        return self.__geometry.test_inside(b.getPedGeometry())

@localeC
    def containsSector(self, sector):
        """Return whether the sectory is contained entirely within self."""
        return self.__geometry.test_sector_inside(sector)

@localeC
    def getSize(self, unit="MB"):
        """Return the size of the geometry in the unit specified.  The unit
           is given as a string corresponding to one of the following
           abbreviations:  b (bytes), KB (kilobytes), MB (megabytes), GB
           (gigabytes), TB (terabytes).  An invalid unit string will raise a
           SyntaxError exception.  The default unit is MB."""
        warnings.warn("use the getLength method", DeprecationWarning)
        lunit = unit.lower()
        size = self.length * self.device.sectorSize

if lunit not in parted._exponent.keys():
            raise SyntaxError("invalid unit %s given" % (unit))

return (size / math.pow(1024.0, parted._exponent[lunit]))

@localeC
    def getLength(self, unit='sectors'):
        """Return the length of the geometry in sectors. Optionally, a SI or
           IEC prefix followed by a 'B' may be given in order to convert the
           length into bytes. The allowed values include B, kB, MB, GB, TB, KiB,
           MiB, GiB, and TiB."""
        sectors = self.length
        if unit == "sectors":
            return sectors
        return parted.formatBytes(sectors * self.device.sectorSize, unit)

@localeC
    def intersect(self, b):
        """Return a new Geometry describing the region common to both self
           and Geometry b.  Raises ArithmeticError if the regions do not
           intersect."""
        return Geometry(PedGeometry=self.__geometry.intersect(b.getPedGeometry()))

@localeC
    def map(self, src, sector):
        """Given a Geometry src that overlaps with self and a sector inside src,
           this method translates the address of the sector into an address
           inside self.  If self does not contain sector, ArithmeticError will
           be raised."""
        return parted.Geometry(PedGeometry=self.__geometry.map(src.getPedGeometry(), sector))

@localeC
    def overlapsWith(self, b):
        """Return whether self and b are on the same device and share at least
           some of the same region."""
        try:
            self.__geometry.intersect(b.getPedGeometry())
            return True
        except ArithmeticError:
            return False

@localeC
    def read(self, offset, count):
        """Read data from the region described by self.
           offset -- The number of sectors from the beginning of the region
                     (not the beginning of the disk) to read.
           count  -- The number of sectors to read."""
        return self.__geometry.read(offset, count)

@localeC
    def sync(self, fast=False):
        """Flushes all caches on the device described by self.  If fast is
           True, the flush will be quicked by cache coherency is not
           guaranteed."""
        if fast:
            return self.__geometry.sync_fast()
        else:
            return self.__geometry.sync()

@localeC
    def write(self, buf, offset, count):
        """Write data into the region described by self.
           buf    -- The data to be written.
           offset -- Where to start writing to region, expressed as the number
                     of sectors from the start of the region (not the disk).
           count  -- How many sectors of buf to write out."""
        return self.__geometry.write(buf, offset, count)

def getPedGeometry(self):
        """Return the _ped.Geometry object contained in this Geometry.
           For internal module use only."""
        return self.__geometry
0707010011582E000081A40000FFFE0000FFFD0000000157CD697A00002704000000FC0000001000000000000000000000003400000000pyparted-1466619794.7a0f829/src/parted/partition.py#
# partition.py
# Python bindings for libparted (built on top of the _ped Python module).
#
# Copyright (C) 2009-2013 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.
#
# Author(s): Chris Lumens <clumens@redhat.com>
#            David Cantrell <dcantrell@redhat.com>
#            Alex Skinner <alex@lx.lc>
#

import math
import warnings

import _ped
import parted

from parted.decorators import localeC

# XXX: add docstrings

class Partition(object):
    # pylint: disable=W0622
    @localeC
    def __init__(self, disk=None, type=None, fs=None, geometry=None, PedPartition=None):
        if PedPartition is None:
            if disk is None:
                raise parted.PartitionException("no disk specified")
            elif type is None:
                raise parted.PartitionException("no type specified")
            elif geometry is None:
                raise parted.PartitionException("no geometry specified")

self._fileSystem = fs
            self._geometry = geometry
            self._disk = disk

if fs is None:
                self.__partition = _ped.Partition(disk.getPedDisk(), type, geometry.start, geometry.end)
            else:
                self.__partition = _ped.Partition(disk.getPedDisk(), type, geometry.start, geometry.end, parted.fileSystemType[fs.type])
        else:
            self.__partition = PedPartition
            self._geometry = parted.Geometry(PedGeometry=self.__partition.geom)

if disk is None:
                self._disk = parted.Disk(PedDisk=self.__partition.disk)
            else:
                self._disk = disk

if self.__partition.fs_type is None:
                self._fileSystem = None
            else:
                # pylint: disable=E1103
                self._fileSystem = parted.FileSystem(type=self.__partition.fs_type.name, geometry=self._geometry)

def __eq__(self, other):
        return not self.__ne__(other)

def __ne__(self, other):
        if not isinstance(self, other.__class__):
            return True

return self.path != other.path or self.type != other.type or self.geometry != other.geometry or self.fileSystem != other.fileSystem

def __str__(self):
        try:
            name = self.name
        except parted.PartitionException:
            name = None

s = ("parted.Partition instance --\n"
             "  disk: %(disk)r  fileSystem: %(fileSystem)r\n"
             "  number: %(number)s  path: %(path)s  type: %(type)s\n"
             "  name: %(name)s  active: %(active)s  busy: %(busy)s\n"
             "  geometry: %(geometry)r  PedPartition: %(ped)r" %
             {"disk": self.disk, "fileSystem": self.fileSystem, "geometry": self.geometry,
              "number": self.number, "path": self.path,
              "type": self.type, "name": name, "active": self.active,
              "busy": self.busy, "ped": self.__partition})
        return s

def __writeOnly(self, prop):
        raise parted.WriteOnlyProperty(prop)

@property
    @localeC
    def active(self):
        """True if the partition is active, False otherwise."""
        return bool(self.__partition.is_active())

@property
    @localeC
    def busy(self):
        """True if the partition is active, False otherwise."""
        return bool(self.__partition.is_busy())

@property
    def disk(self):
        """The Disk this partition belongs to."""
        return self._disk

@property
    @localeC
    def path(self):
        """The filesystem path to this partition's device node."""
        return self.__partition.get_path()

@property
    @localeC
    def name(self):
        """The name of this partition."""
        try:
            return self.__partition.get_name()
        except parted.PartitionException:
            return None

@property
    def number(self):
        """The partition number."""
        return self.__partition.num

fileSystem = property(lambda s: s._fileSystem, lambda s, v: setattr(s, "_fileSystem", v))
    geometry = property(lambda s: s._geometry, lambda s, v: setattr(s, "_geometry", v))
    system = property(lambda s: s.__writeOnly("system"), lambda s, v: s.__partition.set_system(v))
    type = property(lambda s: s.__partition.type, lambda s, v: setattr(s.__partition, "type", v))

@localeC
    def getFlag(self, flag):
        """Get the value of a particular flag on the partition.  Valid flags
           are the _ped.PARTITION_* constants.  See _ped.flag_get_name() and
           _ped.flag_get_by_name() for more help working with partition flags.
        """
        return self.__partition.get_flag(flag)

@localeC
    def setFlag(self, flag):
        """Set the flag on a partition to the provided value.  On error, a
           PartitionException will be raised.  See getFlag() for more help on
           working with partition flags."""
        return self.__partition.set_flag(flag, 1)

@localeC
    def unsetFlag(self, flag):
        """Unset the flag on this Partition.  On error, a PartitionException
           will be raised.  See getFlag() for more help on working with
           partition flags."""
        return self.__partition.set_flag(flag, 0)

@localeC
    def getMaxGeometry(self, constraint):
        """Given a constraint, return the maximum Geometry that self can be
           grown to.  Raises Partitionexception on error."""
        return parted.Geometry(PedGeometry=self.disk.getPedDisk().get_max_partition_geometry(self.__partition, constraint.getPedConstraint()))

@localeC
    def isFlagAvailable(self, flag):
        """Return True if flag is available on this Partition, False
           otherwise."""
        return self.__partition.is_flag_available(flag)

@localeC
    def nextPartition(self):
        """Return the Partition following this one on the Disk."""
        partition = self.disk.getPedDisk().next_partition(self.__partition)

if partition is None:
            return None
        else:
            return parted.Partition(disk=self.disk, PedPartition=partition)

@localeC
    def getSize(self, unit="MB"):
        """Return the size of the partition in the unit specified.  The unit
           is given as a string corresponding to one of the following
           abbreviations:  b (bytes), KB (kilobytes), MB (megabytes), GB
           (gigabytes), TB (terabytes).  An invalid unit string will raise a
           SyntaxError exception.  The default unit is MB."""
        warnings.warn("use the getLength method", DeprecationWarning)
        return self.geometry.getSize(unit)

@localeC
    def getLength(self, unit='sectors'):
        """Return the length of the partition in sectors. Optionally, a SI or
           IEC prefix followed by a 'B' may be given in order to convert the
           length into bytes. The allowed values include B, kB, MB, GB, TB, KiB,
           MiB, GiB, and TiB."""
        return self.geometry.getLength(unit)

def getFlagsAsString(self):
        """Return a comma-separated string representing the flags
           on this partition."""
        flags = []

for flag in partitionFlag.keys():
            if self.getFlag(flag):
                flags.append(partitionFlag[flag])

return ', '.join(flags)

def getMaxAvailableSize(self, unit="MB"):
        """Return the maximum size this Partition can grow to by looking
           at contiguous freespace partitions.  The size is returned in
           the unit specified (default is megabytes).  The unit is a
           string corresponding to one of the following abbreviations:
           b (bytes), KB (kilobytes), MB (megabytes), GB (gigabytes),
           TB (terabytes).  An invalid unit string will raise a
           SyntaxError exception."""
        lunit = unit.lower()

if lunit not in parted._exponent.keys():
            raise SyntaxError("invalid unit %s given" % (unit))

maxLength = self.geometry.length
        sectorSize = self.geometry.device.sectorSize

for partition in self.disk.partitions:
            if partition.type & parted.PARTITION_FREESPACE:
                maxLength += partition.geometry.length
            else:
                break

return math.floor(maxLength * math.pow(sectorSize, parted._exponent[lunit]))

def getDeviceNodeName(self):
        """Return the device name for this Partition."""
        return self.path[5:]

def getPedPartition(self):
        """Return the _ped.Partition object contained in this Partition.
           For internal module use only."""
        return self.__partition

def resetNumber(self):
        """Reset the partition's number to default"""
        return self.__partition.reset_num()

# collect all partition flags and store them in a hash
partitionFlag = {}
__flag = _ped.partition_flag_next(0)
partitionFlag[__flag] = _ped.partition_flag_get_name(__flag)
__readFlags = True

while __readFlags:
    __flag = _ped.partition_flag_next(__flag)
    if not __flag:
        __readFlags = False
    else:
        partitionFlag[__flag] = _ped.partition_flag_get_name(__flag)
0707010011582F000081A40000FFFE0000FFFD0000000157CD697A00001EB8000000FC0000001000000000000000000000003500000000pyparted-1466619794.7a0f829/src/parted/constraint.py#
# constraint.py
# Python bindings for libparted (built on top of the _ped Python module).
#
# Copyright (C) 2009 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.
#
# Author(s): Chris Lumens <clumens@redhat.com>
#            David Cantrell <dcantrell@redhat.com>
#            Alex Skinner <alex@lx.lc>
#

import parted
import _ped

from parted.decorators import localeC

class Constraint(object):
    """Constraint()

A Constraint object describes a set of restrictions on other pyparted
       operations.  Constraints can restrict the location and alignment of the
       start and end of a partition, and its minimum and maximum size.  Most
       constraint operations can raise CreateException if creating temporary
       objects fails, or ArithmeticError if an error occurs during
       calculations."""
    @localeC
    def __init__(self, *args, **kwargs):
        """Create a new Constraint object.  There are many different ways to
           create a Constraint, all depending on the parameters passed to
           __init__.  If minGeom and maxGeom are supplied, the constraint will
           be created to satisfy both.  If only one of minGeom or maxGeom are
           supplied, the constraint is only guaranteed to solve the given
           paramter.  If exactGeom is given, the constraint will only be
           satisfied by the given geometry.  If device is given, any region
           on that device will satisfy the constraint.

If none of the previously mentioned parameters are supplied, all of
           startAlign, EndAlign, startRange, endRange, minSize, and maxSize
           must be given."""
        if "PedConstraint" in kwargs:
            self.__constraint = kwargs.get("PedConstraint")
        elif "minGeom" in kwargs and "maxGeom" in kwargs:
            ming = kwargs.get("minGeom").getPedGeometry()
            maxg = kwargs.get("maxGeom").getPedGeometry()
            self.__constraint = _ped.constraint_new_from_min_max(ming, maxg)
        elif "minGeom" in kwargs:
            ming = kwargs.get("minGeom").getPedGeometry()
            self.__constraint = _ped.constraint_new_from_min(ming)
        elif "maxGeom" in kwargs:
            maxg = kwargs.get("maxGeom").getPedGeometry()
            self.__constraint = _ped.constraint_new_from_max(maxg)
        elif "exactGeom" in kwargs:
            exact = kwargs.get("exactGeom").getPedGeometry()
            self.__constraint = _ped.constraint_exact(exact)
        elif "device" in kwargs:
            dev = kwargs.get("device").getPedDevice()
            self.__constraint = _ped.constraint_any(dev)
        elif "startAlign" in kwargs and "endAlign" in kwargs and \
             "startRange" in kwargs and "endRange" in kwargs and \
             "minSize" in kwargs and "maxSize" in kwargs:
            starta = kwargs.get("startAlign").getPedAlignment()
            enda = kwargs.get("endAlign").getPedAlignment()
            startr = kwargs.get("startRange").getPedGeometry()
            endr = kwargs.get("endRange").getPedGeometry()
            mins = kwargs.get("minSize")
            maxs = kwargs.get("maxSize")
            self.__constraint = _ped.Constraint(starta, enda, startr, endr,
                                                mins, maxs)
        else:
            raise parted.ConstraintException("missing initialization parameters")

def __eq__(self, other):
        return not self.__ne__(other)

def __ne__(self, other):
        if hash(self) == hash(other):
            return False

if not isinstance(self, other.__class__):
            return True

c1 = self.getPedConstraint()
        c2 = other.getPedConstraint()

return self.minSize != other.minSize \
                or self.maxSize != other.maxSize \
                or c1.start_align != c2.start_align \
                or c1.end_align != c2.end_align \
                or c1.start_range != c2.start_range \
                or c1.end_range != c2.end_range

startAlign = property(
            lambda s: parted.Alignment(PedAlignment=s.__constraint.start_align),
            lambda s, v: setattr(s.__constraint, "start_align", v.getPedAlignment()))

endAlign = property(
            lambda s: parted.Alignment(PedAlignment=s.__constraint.end_align),
            lambda s, v: setattr(s.__constraint, "end_align", v.getPedAlignment()))

startRange = property(
            lambda s: parted.Geometry(PedGeometry=s.__constraint.start_range),
            lambda s, v: setattr(s.__constraint, "start_range", v.getPedGeometry()))

endRange = property(
            lambda s: parted.Geometry(PedGeometry=s.__constraint.end_range),
            lambda s, v: setattr(s.__constraint, "end_range", v.getPedGeometry()))

minSize = property(
            lambda s: s.__constraint.min_size,
            lambda s, v: setattr(s.__constraint, "min_size", v))

maxSize = property(
            lambda s: s.__constraint.max_size,
            lambda s, v: setattr(s.__constraint, "max_size", v))

def __str__(self):
        s = ("parted.Constraint instance --\n"
             "  startAlign: %(startAlign)r  endAlign: %(endAlign)r\n"
             "  startRange: %(startRange)r  endRange: %(endRange)r\n"
             "  minSize: %(minSize)s  maxSize: %(maxSize)s\n"
             "  PedConstraint: %(ped)r" %
             {"startAlign": self.startAlign, "endAlign": self.endAlign,
              "startRange": self.startRange, "endRange": self.endRange,
              "minSize": self.minSize, "maxSize": self.maxSize,
              "ped": self.__constraint})
        return s

@localeC
    def intersect(self, b):
        """Return a new constraint that is the intersection of self and the
           provided constraint b.  The returned constraint will therefore be
           more restrictive than either input as it will have to satisfy
           both."""
        return parted.Constraint(PedConstraint=self.__constraint.intersect(b.getPedConstraint()))

@localeC
    def solveMax(self):
        """Return a new geometry that is the largest region satisfying self.
           There may be more than one solution, and there are no guarantees as
           to which solution will be returned."""
        return parted.Geometry(PedGeometry=self.__constraint.solve_max())

@localeC
    def solveNearest(self, geom):
        """Return a new geometry that is the nearest region to geom that
           satisfies self.  This function does not guarantee any specific
           meaning of 'nearest'."""
        return parted.Geometry(PedGeometry=self.__constraint.solve_nearest(geom.getPedGeometry()))

@localeC
    def isSolution(self, geom):
        """Does geom satisfy this constraint?"""
        return self.__constraint.is_solution(geom.getPedGeometry())

def getPedConstraint(self):
        """Return the _ped.Constraint object contained in this Constraint.
           For internal module use only."""
        return self.__constraint
07070100115830000081A40000FFFE0000FFFD0000000157CD697A00000DC7000000FC0000001000000000000000000000003500000000pyparted-1466619794.7a0f829/src/parted/cachedlist.py#
# Python bindings for libparted (built on top of the _ped Python module).
#
# Copyright (C) 2009 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): Chris Lumens <clumens@redhat.com>
#

from collections import Sequence

class CachedList(Sequence):
    """CachedList()

Provides an immutable list that is constructed from a function that
       could take a while to run.  This is basically the same concept as
       memoization, except that the function does not take any parameters
       and therefore there is nothing to use as a memo.

The constructor function is provided to __init__, must not take any
       parameters, and must return a list.  The invalidate() method indicates
       that the list is no longer valid and should be reconstucted by
       calling the function again.  It is up to client code to call invalidate.
       The rest of the procedure is handled by this class.

In all ways, this should appear to be just like a list."""
    def __init__(self, lstFn):
        """Construct a new CachedList.  The lstFn is a function that takes
           no parameters and returns a list.  It will be called lazily - the
           list is not constructed until the first access, which could be
           quite a while after this method is called."""
        self._invalid = True
        self._lst = []
        self._lstFn = lstFn

def __rebuildList(self):
        if self._invalid:
            self._lst = self._lstFn()
            self._invalid = False

def __contains__(self, value):
        self.__rebuildList()
        return self._lst.__contains__(value)

def __getitem__(self, index):
        self.__rebuildList()
        return self._lst.__getitem__(index)

def __iter__(self):
        self.__rebuildList()
        return self._lst.__iter__()

def __len__(self):
        self.__rebuildList()
        return len(self._lst)

def __repr__(self):
        self.__rebuildList()
        return repr(self._lst)

def __str__(self):
        self.__rebuildList()
        return str(self._lst)

def __hash__(self):
        return hash(str(self))

def count(self, value):
        self.__rebuildList()
        return self._lst.count(value)

def index(self, value, *args, **kwargs):
        self.__rebuildList()
        return self._lst.index(value, *args, **kwargs)

def invalidate(self):
        """Indicate that the list is no longer valid, due to some external
           changes.  The next access to the list will result in the provided
           list construction function being called to build a new list."""
        self._invalid = True
07070100115831000081A40000FFFE0000FFFD0000000157CD697A00000EBA000000FC0000001000000000000000000000003500000000pyparted-1466619794.7a0f829/src/parted/filesystem.py#
# filesystem.py
# Python bindings for libparted (built on top of the _ped Python module).
#
# Copyright (C) 2009-2013 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.
#
# Author(s): David Cantrell <dcantrell@redhat.com>
#            Alex Skinner <alex@lx.lc>
#

import _ped
import parted

from parted.decorators import localeC

# XXX: add docstrings!

class FileSystem(object):
    # pylint: disable=W0622
    @localeC
    def __init__(self, type=None, geometry=None, checked=False, PedFileSystem=None):
        if checked:
            c = 1
        else:
            c = 0

if PedFileSystem is None:
            if type is None:
                raise parted.FileSystemException("no type specified")
            elif geometry is None:
                raise parted.FileSystemException("no geometry specified")

self._type = type
            self._geometry = geometry
            self._checked = checked
            self.__fileSystem = _ped.FileSystem(type=fileSystemType[type], geom=geometry.getPedGeometry(), checked=c)
        else:
            self.__fileSystem = PedFileSystem
            self._type = self.__fileSystem.type.name
            self._geometry = parted.Geometry(PedGeometry=self.__fileSystem.geom)

if self.__fileSystem.checked:
                self._checked = True
            else:
                self._checked = False

def __eq__(self, other):
        return not self.__ne__(other)

def __ne__(self, other):
        if not isinstance(self, other.__class__):
            return True

return self.type != other.type or self.geometry != other.geometry

def __str__(self):
        s = ("parted.FileSystem instance --\n"
             "  type: %(type)s  geometry: %(geometry)r  checked: %(checked)s\n"
             "  PedFileSystem: %(ped)r" %
             {"type": self.type, "geometry": self.geometry,
              "checked": self.checked, "ped": self.__fileSystem})
        return s

@property
    def type(self):
        """The type of this filesystem, e.g. ext3."""
        return self._type

@property
    def geometry(self):
        """The Geometry object describing this filesystem."""
        return self._geometry

@property
    def checked(self):
        """True if this filesystem has been checked, False otherwise."""
        return bool(self._checked)

def getPedFileSystem(self):
        """Return the _ped.FileSystem object contained in this FileSystem.
           For internal module use only."""
        return self.__fileSystem

# collect all filesystem types and store them in a hash
fileSystemType = {}
__type = _ped.file_system_type_get_next()
fileSystemType[__type.name] = __type

while True:
    try:
        __type = _ped.file_system_type_get_next(__type)
        fileSystemType[__type.name] = __type
    except (IndexError, TypeError, _ped.UnknownTypeException):
        break
07070100115837000081A40000FFFE0000FFFD0000000157CD697A00001CBD000000FC0000001000000000000000000000002F00000000pyparted-1466619794.7a0f829/src/fdisk/fdisk.py#
# fdisk.py
# Partitioning utility with an fdisk-style interface, but written in
# Python and using the pyparted Python module.
#
# Copyright (C) 2009  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 getopt
import os
import parted
import sys

def usage(cmd):
    sys.stdout.write("Usage: %s [-b SSZ] [-u] DISK       Change partition table\n" % (cmd,))
    sys.stdout.write("       %s [-l] [-b SSZ] [-u] DISK  List partition table(s)\n" % (cmd,))
    sys.stdout.write("       %s -s PARTITION             Give partition size(s) in blocks\n\n" % (cmd,))
    sys.stdout.write("Here DISK is something like /dev/hdb or /dev/sda\n")
    sys.stdout.write("and PARTITION is something like /dev/hda7\n\n")
    sys.stdout.write("Options:\n")
    sys.stdout.write("   -b=SSZ, --sectorsize=SSZ    Sector size (in bytes) to use\n")
    sys.stdout.write("   -l, --list                  List partition table(s)\n")
    sys.stdout.write("   -u, --showsectors           Give Start and End in sector units\n")
    sys.stdout.write("   -s, --showblocks            Give Start and End in block units\n")
    sys.stdout.write("   -V, --version               Show fdisk version\n")
    sys.stdout.write("   -?, --help                  Display fdisk usage screen\n")

def displayVersion(cmd):
    ver = parted.version()

sys.stdout.write("%s:\n" % (cmd,))
    sys.stdout.write("pyparted version: %s.%s.%s\n" % (ver["pyparted"][0], ver["pyparted"][1], ver["pyparted"][2]))
    sys.stdout.write("libparted version: %s\n" % ver["libparted"])

def listPartitionTable(path, sectorsize, showsectors, showblocks):
    device = parted.getDevice(path)
    (cylinders, heads, sectors) = device.biosGeometry
    sizeInBytes = device.length * device.sectorSize
    disk = parted.Disk(device)

partlist = []
    for partition in disk.partitions:
        if partition.type == parted.PARTITION_PROTECTED or \
           partition.type == parted.PARTITION_METADATA or \
           partition.type == parted.PARTITION_FREESPACE:
            continue

partlist.append((partition,
                         partition.path,
                         partition.getFlag(parted.PARTITION_BOOT),
                         partition.geometry.start,
                         partition.geometry.end,
                         partition.geometry.length,
                         partition.type,
                         partition.fileSystem))

colLength = 0
    for parts in partlist:
        path = parts[1]
        if len(path) > colLength:
            colLength = len(path)

sys.stdout.write("Disk %s: %%d %%s, %d bytes\n" % (disk.device.path, sizeInBytes))
    sys.stdout.write("%d heads, %d sectors/track, %d cylinders\n" % (heads, sectors, cylinders,))
    sys.stdout.write("Units = FIXME\n")
    sys.stdout.write("Disk identifier: FIXME\n\n")

sys.stdout.write("%-11s %-4s %-11s %-11s %-12s %-4s %s\n" % ("Device", "Boot", "Start", "End", "Blocks", "Id", "System",))

for parts in partlist:
        (partition, path, bootable, start, end, length, ty, fs) = parts

if bootable:
            bootflag = '*'
        else:
            bootflag = ''

sys.stdout.write("%-11s %-4s %-11d %-11d %-12d %-4s" % (path, bootflag, start, end, length, ty,))

if fs is None:
            # no filesystem, check flags
            if partition.getFlag(parted.PARTITION_SWAP):
                sys.stdout.write(" Linux swap\n")
            elif partition.getFlag(parted.PARTITION_RAID):
                sys.stdout.write(" RAID\n")
            elif partition.getFlag(parted.PARTITION_LVM):
                sys.stdout.write(" Linux LVM\n")
            elif partition.getFlag(parted.PARTITION_HPSERVICE):
                sys.stdout.write(" HP Service\n")
            elif partition.getFlag(parted.PARTITION_PALO):
                sys.stdout.write(" PALO\n")
            elif partition.getFlag(parted.PARTITION_PREP):
                sys.stdout.write(" PReP\n")
            elif partition.getFlag(parted.MSFT_RESERVED):
                sys.stdout.write(" MSFT Reserved\n")
            else:
                sys.stdout.write(" unknown\n")
        else:
            sys.stdout.write(" %s\n" % (fs.type,))

#Disk /dev/sda: 250.0 GB, 250059350016 bytes
#255 heads, 63 sectors/track, 30401 cylinders
#Units = cylinders of 16065 * 512 = 8225280 bytes
#Disk identifier: 0x00000000
#
#   Device Boot      Start         End      Blocks   Id  System
#/dev/sda1               1          26      204819+  ee  GPT
#/dev/sda2              26        4203    33554432   af  Unknown
#/dev/sda3   *        4203        4229      204800   83  Linux
#/dev/sda4            4229       30402   210234515+  8e  Linux LVM

def main(argv):
    cmd = os.path.basename(sys.argv[0])
    opts, args = [], []
    showhelp, showlist, showsectors, showblocks = False, False, False, False

# These three are unused for now so I'm marking them with an underscore
    # to make pylint happy.
    sectorsize, _cylinders, _heads, _sectors = None, None, None, None

if len(sys.argv) == 1:
        showhelp = True

try:
        opts, args = getopt.getopt(sys.argv[1:], "lb:C:H:S:usV?",
                                   ["list", "sectorsize=", "cylinders=",
                                    "heads=", "sectors=", "showsectors",
                                    "showblocks", "version", "help"])
    except getopt.GetoptError:
        showhelp = True

for o, a in opts:
        if o in ('-l', '--list'):
            showlist = True
        elif o in ('-b', '--sectorsize'):
            sectorsize = a
        elif o in ('-C', '--cylinders'):
            _cylinders = a
        elif o in ('-H', '--heads'):
            _heads = a
        elif o in ('-S', '--sectors'):
            _sectors = a
        elif o in ('-u', '--showsectors'):
            showsectors = True
        elif o in ('-s', '--showblocks'):
            showblocks = True
        elif o in ('-V', '--version'):
            displayVersion(cmd)
            sys.exit(0)
        elif o in ('-?', '--help'):
            usage(cmd)
            sys.exit(0)
        else:
            sys.stderr.write("Invalid option: %s\n\n" % (o,))
            showhelp = True

if showhelp:
        usage(cmd)
        sys.exit(1)

for arg in args:
        if showlist:
            listPartitionTable(arg, sectorsize, showsectors, showblocks)

if __name__ == "__main__":
    main(sys.argv)
07070100115838000081ED0000FFFE0000FFFD0000000157CD697A00000049000000FC0000001000000000000000000000003000000000pyparted-1466619794.7a0f829/src/fdisk/localtest#!/bin/sh
export PYTHONPATH=$(pwd)/..:$(pwd)/../.libs
python fdisk.py $*
07070100115827000041ED0000FFFE0000FFFD0000000257CD697A00000000000000FC0000001000000000000000000000002700000000pyparted-1466619794.7a0f829/src/parted07070100115836000041ED0000FFFE0000FFFD0000000257CD697A00000000000000FC0000001000000000000000000000002600000000pyparted-1466619794.7a0f829/src/fdisk07070100115825000081A40000FFFE0000FFFD0000000157CD697A00001E81000000FC0000001000000000000000000000002900000000pyparted-1466619794.7a0f829/src/pyunit.c/*
 * pyunit.c
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Chris Lumens <clumens@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#include <Python.h>

#include "convert.h"
#include "exceptions.h"
#include "pydevice.h"
#include "pyunit.h"

/* 1:1 function mappings for unit.h in libparted */
PyObject *py_ped_unit_set_default(PyObject *s, PyObject *args) {
    int unit;

if (!PyArg_ParseTuple(args, "i", &unit)) {
        return NULL;
    }

if (unit < PED_UNIT_FIRST || unit > PED_UNIT_LAST) {
        PyErr_SetString(PyExc_ValueError, "Invalid unit provided.");
        return NULL;
    }

ped_unit_set_default(unit);

Py_INCREF(Py_None);
    return Py_None;
}

PyObject *py_ped_unit_get_default(PyObject *s, PyObject *args) {
    return PyLong_FromLong(ped_unit_get_default());
}

PyObject *py_ped_unit_get_size(PyObject *s, PyObject *args) {
    long long ret = -1;
    PedDevice *dev = NULL;
    int unit;

if (!PyArg_ParseTuple(args, "i", &unit))
        return NULL;

if (unit < PED_UNIT_FIRST || unit > PED_UNIT_LAST) {
        PyErr_SetString(PyExc_ValueError, "Invalid unit provided.");
        return NULL;
    }

dev = _ped_Device2PedDevice(s);
    if (dev == NULL) {
        return NULL;
    }

ret = ped_unit_get_size(dev, unit);
    if (ret == 0) {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_Occurred()) {
                PyErr_SetString(PyExc_ValueError, partedExnMessage);
            }
        } else {
            PyErr_SetString(PyExc_ValueError, "Could not get size");
        }

return NULL;
    }

return PyLong_FromLongLong(ret);
}

PyObject *py_ped_unit_get_name(PyObject *s, PyObject *args) {
    const char *name;
    int unit;

if (!PyArg_ParseTuple(args, "i", &unit)) {
        return NULL;
    }

if (unit < PED_UNIT_FIRST || unit > PED_UNIT_LAST) {
        PyErr_SetString(PyExc_ValueError, "Invalid unit provided.");
        return NULL;
    }

/*
     * DO NOT free the result from ped_unit_get_name(), it's a pointer to
     * a value in the static unit_names[] array in libparted.
     */
    name = ped_unit_get_name(unit);
    if (name != NULL) {
        return PyUnicode_FromString(name);
    } else {
        return PyUnicode_FromString("");
    }
}

PyObject *py_ped_unit_get_by_name(PyObject *s, PyObject *args) {
    int ret;
    char *name = NULL;

if (!PyArg_ParseTuple(args, "z", &name)) {
        return NULL;
    }

ret = ped_unit_get_by_name(name);
    if (ret < PED_UNIT_FIRST || ret > PED_UNIT_LAST) {
        PyErr_SetString(UnknownTypeException, name);
        return NULL;
    }

return Py_BuildValue("i", ret);
}

PyObject *py_ped_unit_format_custom_byte(PyObject *s, PyObject *args) {
    PyObject *ret = NULL;
    char *pedret = NULL;
    PedSector sector;
    int unit;
    PedDevice *out_dev = NULL;

if (!PyArg_ParseTuple(args, "Li", &sector, &unit)) {
        return NULL;
    }

if (unit < PED_UNIT_FIRST || unit > PED_UNIT_LAST) {
        PyErr_SetString(PyExc_ValueError, "Invalid unit provided.");
        return NULL;
    }

out_dev = _ped_Device2PedDevice(s);
    if (out_dev == NULL) {
        return NULL;
    }

pedret = ped_unit_format_custom_byte(out_dev, sector, unit);
    if (pedret != NULL) {
        ret = PyUnicode_FromString(pedret);
        free(pedret);
    } else {
        ret = PyUnicode_FromString("");
    }

return ret;
}

PyObject *py_ped_unit_format_byte(PyObject *s, PyObject *args) {
    PyObject *ret = NULL;
    char *pedret = NULL;
    PedSector sector;
    PedDevice *out_dev = NULL;

if (!PyArg_ParseTuple(args, "L", &sector)) {
        return NULL;
    }

out_dev = _ped_Device2PedDevice(s);
    if (out_dev == NULL) {
        return NULL;
    }

pedret = ped_unit_format_byte(out_dev, sector);
    if (pedret != NULL) {
        ret = PyUnicode_FromString(pedret);
        free(pedret);
    } else {
        ret = PyUnicode_FromString("");
    }

return ret;
}

PyObject *py_ped_unit_format_custom(PyObject *s, PyObject *args) {
    PyObject *ret = NULL;
    char *pedret = NULL;
    PedDevice *out_dev = NULL;
    PedSector sector;
    int unit;

if (!PyArg_ParseTuple(args, "Li", &sector, &unit)) {
        return NULL;
    }

out_dev = _ped_Device2PedDevice(s);
    if (out_dev == NULL) {
        return NULL;
    }

pedret = ped_unit_format_custom(out_dev, sector, unit);
    if (pedret != NULL) {
        ret = PyUnicode_FromString(pedret);
        free(pedret);
    } else {
        ret = PyUnicode_FromString("");
    }

return ret;
}

PyObject *py_ped_unit_format(PyObject *s, PyObject *args) {
    PyObject *ret = NULL;
    char *pedret = NULL;
    PedDevice *out_dev = NULL;
    PedSector sector;

if (!PyArg_ParseTuple(args, "L", &sector)) {
        return NULL;
    }

out_dev = _ped_Device2PedDevice(s);
    if (out_dev == NULL) {
        return NULL;
    }

pedret = ped_unit_format(out_dev, sector);
    if (pedret != NULL) {
        ret = PyUnicode_FromString(pedret);
        free(pedret);
    } else {
        ret = PyUnicode_FromString("");
    }

return ret;
}

PyObject *py_ped_unit_parse(PyObject *s, PyObject *args) {
    int ret;
    char *str = NULL;
    PedDevice *out_dev = NULL;
    PedSector sector;
    PyObject *in_geom = NULL;
    PedGeometry *out_geom = NULL;

if (!PyArg_ParseTuple(args, "zLO!", &str, &sector,
                          &_ped_Geometry_Type_obj, &in_geom)) {
        return NULL;
    }

out_dev = _ped_Device2PedDevice(s);
    if (out_dev == NULL) {
        return NULL;
    }

out_geom = _ped_Geometry2PedGeometry(in_geom);
    if (out_geom == NULL) {
        return NULL;
    }

ret = ped_unit_parse(str, out_dev, &sector, &out_geom);

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_unit_parse_custom(PyObject *s, PyObject *args) {
    int ret;
    char *str = NULL;
    PedDevice *out_dev = NULL;
    int unit;
    PedSector sector;
    PyObject *in_geom = NULL;
    PedGeometry *out_geom = NULL;

if (!PyArg_ParseTuple(args, "ziLO!", &str, &unit, &sector,
                          &_ped_Geometry_Type_obj, &in_geom)) {
        return NULL;
    }

if (unit < PED_UNIT_FIRST || unit > PED_UNIT_LAST) {
        PyErr_SetString(PyExc_ValueError, "Invalid unit provided.");
        return NULL;
    }

out_dev = _ped_Device2PedDevice(s);
    if (out_dev == NULL) {
        return NULL;
    }

out_geom = _ped_Geometry2PedGeometry(in_geom);
    if (out_geom == NULL) {
        return NULL;
    }

ret = ped_unit_parse_custom(str, out_dev, unit, &sector, &out_geom);

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

/* vim:tw=78:ts=4:et:sw=4
 */
07070100115826000081A40000FFFE0000FFFD0000000157CD697A00004D43000000FC0000001000000000000000000000002900000000pyparted-1466619794.7a0f829/src/pygeom.c/*
 * pygeom.c
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Chris Lumens <clumens@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#include <Python.h>

#include "convert.h"
#include "exceptions.h"
#include "pygeom.h"
#include "pynatmath.h"
#include "docstrings/pygeom.h"
#include "typeobjects/pygeom.h"

/* _ped.Geometry functions */
void _ped_Geometry_dealloc(_ped_Geometry *self) {
    if (self->ped_geometry)
        ped_geometry_destroy(self->ped_geometry);

PyObject_GC_UnTrack(self);

Py_CLEAR(self->dev);
    self->dev = NULL;

PyObject_GC_Del(self);
}

int _ped_Geometry_compare(_ped_Geometry *self, PyObject *obj) {
    _ped_Geometry *comp = NULL;
    int check = PyObject_IsInstance(obj, (PyObject *) &_ped_Geometry_Type_obj);

if (PyErr_Occurred()) {
        return -1;
    }

if (!check) {
        PyErr_SetString(PyExc_ValueError, "object comparing to must be a _ped.Geometry");
        return -1;
    }

comp = (_ped_Geometry *) obj;
    if (PyObject_RichCompareBool(self->dev, comp->dev, Py_EQ) &&
        (self->ped_geometry->start == comp->ped_geometry->start) &&
        (self->ped_geometry->length == comp->ped_geometry->length) &&
        (self->ped_geometry->end == comp->ped_geometry->end)) {
        return 0;
    } else {
        return 1;
    }
}

PyObject *_ped_Geometry_richcompare(_ped_Geometry *a, PyObject *b, int op) {
    if (op == Py_EQ || op == Py_NE) {
        int rv = _ped_Geometry_compare(a, b);
        if (PyErr_Occurred())
            return NULL;
        return PyBool_FromLong(op == Py_EQ ? rv == 0 : rv != 0);
    } else if ((op == Py_LT) || (op == Py_LE) ||
               (op == Py_GT) || (op == Py_GE)) {
        PyErr_SetString(PyExc_TypeError, "comparison operator not supported for _ped.Geometry");
        return NULL;
    } else {
        PyErr_SetString(PyExc_ValueError, "unknown richcompare op");
        return NULL;
    }
}

PyObject *_ped_Geometry_str(_ped_Geometry *self) {
    char *ret = NULL;
    char *dev = NULL;

dev = PyUnicode_AsUTF8(_ped_Device_Type_obj.tp_repr(self->dev));
    if (dev == NULL) {
        return NULL;
    }

if (asprintf(&ret, "_ped.Geometry instance --\n"
                       "  start: %lld  end: %lld  length: %lld\n"
                       "  device: %s",
                 self->ped_geometry->start, self->ped_geometry->end,
                 self->ped_geometry->length, dev) == -1) {
        return PyErr_NoMemory();
    }

return Py_BuildValue("s", ret);
}

int _ped_Geometry_traverse(_ped_Geometry *self, visitproc visit, void *arg) {
    int err;

if (self->dev) {
        if ((err = visit(self->dev, arg))) {
            return err;
        }
    }

return 0;
}

int _ped_Geometry_clear(_ped_Geometry *self) {
    Py_CLEAR(self->dev);
    self->dev = NULL;

return 0;
}

int _ped_Geometry_init(_ped_Geometry *self, PyObject *args, PyObject *kwds) {
    static char *kwlist[] = {"dev", "start", "length", "end", NULL};
    PedDevice *device = NULL;
    long long start, length, end;

self->dev = NULL;
    self->ped_geometry = NULL;

if (kwds == NULL) {
        if (!PyArg_ParseTuple(args, "O!LL|L", &_ped_Device_Type_obj, &self->dev,
                              &start, &length, &end)) {
            self->dev = NULL;
            return -1;
        }
    } else {
        if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!LL|L", kwlist,
                                         &_ped_Device_Type_obj, &self->dev,
                                         &start, &length, &end)) {
            self->dev = NULL;
            return -2;
        }
    }

device = _ped_Device2PedDevice(self->dev);
    if (device == NULL) {
        self->dev = NULL;
        return -3;
    }
    self->ped_geometry = ped_geometry_new(device, start, length);

if (self->ped_geometry == NULL) {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                !PyErr_ExceptionMatches(PyExc_NotImplementedError)) {
                PyErr_SetString(CreateException, partedExnMessage);
            }
        } else {
            PyErr_SetString(CreateException, "Could not create new geometry");
        }

self->dev = NULL;
        return -3;
    }

Py_INCREF(self->dev);

return 0;
}

PyObject *_ped_Geometry_get(_ped_Geometry *self, void *closure) {
    char *member = (char *) closure;

if (member == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.Geometry()");
        return NULL;
    }

if (!strcmp(member, "start")) {
        return PyLong_FromLongLong(self->ped_geometry->start);
    } else if (!strcmp(member, "length")) {
        return PyLong_FromLongLong(self->ped_geometry->length);
    } else if (!strcmp(member, "end")) {
        return PyLong_FromLongLong(self->ped_geometry->end);
    } else {
        PyErr_Format(PyExc_AttributeError, "_ped.Geometry object has no attribute %s", member);
        return NULL;
    }
}

int _ped_Geometry_set(_ped_Geometry *self, PyObject *value, void *closure) {
    char *member = (char *) closure;
    long long val;
    int ret;

if (member == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.Geometry()");
        return -1;
    }

if (!strcmp(member, "start")) {
        val = PyLong_AsLongLong(value);
        if (PyErr_Occurred()) {
            return -1;
        }
        ret = ped_geometry_set_start(self->ped_geometry, val);
    } else if (!strcmp(member, "length")) {
        val = PyLong_AsLongLong(value);
        if (PyErr_Occurred()) {
            return -1;
        }
        ret = ped_geometry_set(self->ped_geometry, self->ped_geometry->start,
                               val);
    } else if (!strcmp(member, "end")) {
        val = PyLong_AsLongLong(value);
        if (PyErr_Occurred()) {
            return -1;
        }
        ret = ped_geometry_set_end(self->ped_geometry, val);
    } else {
        PyErr_Format(PyExc_AttributeError, "_ped.Geometry object has no attribute %s", member);
        return -1;
    }

if (ret == 0) {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_Occurred()) {
                PyErr_SetString(PyExc_ValueError, partedExnMessage);
            }
        } else {
            PyErr_SetString(PyExc_ValueError, "Could not set geometry");
        }
        return -1;
    }

return 0;
}

/* 1:1 function mappings for geom.h in libparted */
PyObject *py_ped_geometry_duplicate(PyObject *s, PyObject *args) {
    PedGeometry *geometry = NULL, *geom = NULL;
    _ped_Geometry *ret = NULL;

geometry = _ped_Geometry2PedGeometry(s);
    if (geometry == NULL) {
        return NULL;
    }

geom = ped_geometry_duplicate(geometry);
    if (geom) {
        ret = PedGeometry2_ped_Geometry(geom);
    }
    else {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                PyErr_SetString(CreateException, partedExnMessage);
        }
        else
            PyErr_SetString(CreateException, "Could not duplicate geometry");

return NULL;
    }

return (PyObject *) ret;
}

PyObject *py_ped_geometry_intersect(PyObject *s, PyObject *args) {
    PyObject *in_b = NULL;
    PedGeometry *out_a = NULL, *out_b = NULL, *geom = NULL;
    _ped_Geometry *ret = NULL;

if (!PyArg_ParseTuple(args, "O!", &_ped_Geometry_Type_obj, &in_b)) {
        return NULL;
    }

out_a = _ped_Geometry2PedGeometry(s);
    if (out_a == NULL) {
        return NULL;
    }

out_b = _ped_Geometry2PedGeometry(in_b);
    if (out_b == NULL) {
        return NULL;
    }

geom = ped_geometry_intersect (out_a, out_b);
    if (geom) {
        ret = PedGeometry2_ped_Geometry(geom);
    }
    else {
        if (partedExnRaised) {
            partedExnRaised = 0;

return NULL;
    }

return (PyObject *) ret;
}

PyObject *py_ped_geometry_set(PyObject *s, PyObject *args) {
    int ret = -1;
    PedGeometry *geom = NULL;
    PedSector start, length;

if (!PyArg_ParseTuple(args, "LL", &start, &length)) {
        return NULL;
    }

geom = _ped_Geometry2PedGeometry(s);
    if (geom == NULL) {
        return NULL;
    }

ret = ped_geometry_set(geom, start, length);
    if (ret == 0) {
        if (partedExnRaised) {
            partedExnRaised = 0;

return NULL;
    }

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_geometry_set_start(PyObject *s, PyObject *args) {
    int ret = -1;
    PedGeometry *geom = NULL;
    PedSector start;

if (!PyArg_ParseTuple(args, "L", &start)) {
        return NULL;
    }

geom = _ped_Geometry2PedGeometry(s);
    if (geom == NULL) {
        return NULL;
    }

ret = ped_geometry_set_start(geom, start);
    if (ret == 0) {
        if (partedExnRaised) {
            partedExnRaised = 0;

return NULL;
    }

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_geometry_set_end(PyObject *s, PyObject *args) {
    int ret = -1;
    PedGeometry *geom = NULL;
    PedSector end;

if (!PyArg_ParseTuple(args, "L", &end)) {
        return NULL;
    }

geom = _ped_Geometry2PedGeometry(s);
    if (geom == NULL) {
        return NULL;
    }

ret = ped_geometry_set_end(geom, end);
    if (ret == 0) {
        if (partedExnRaised) {
            partedExnRaised = 0;

return NULL;
    }

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_geometry_test_overlap(PyObject *s, PyObject *args) {
    int ret = -1;
    PyObject *in_b = NULL;
    PedGeometry *out_a = NULL, *out_b = NULL;

if (!PyArg_ParseTuple(args, "O!", &_ped_Geometry_Type_obj, &in_b)) {
        return NULL;
    }

out_a = _ped_Geometry2PedGeometry(s);
    if (out_a == NULL) {
        return NULL;
    }

out_b = _ped_Geometry2PedGeometry(in_b);
    if (out_b == NULL) {
        return NULL;
    }

ret = ped_geometry_test_overlap(out_a, out_b);

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_geometry_test_inside(PyObject *s, PyObject *args) {
    int ret = -1;
    PyObject *in_b = NULL;
    PedGeometry *out_a = NULL, *out_b = NULL;

if (!PyArg_ParseTuple(args, "O!", &_ped_Geometry_Type_obj, &in_b)) {
        return NULL;
    }

out_a = _ped_Geometry2PedGeometry(s);
    if (out_a == NULL) {
        return NULL;
    }

out_b = _ped_Geometry2PedGeometry(in_b);
    if (out_b == NULL) {
        return NULL;
    }

ret = ped_geometry_test_inside(out_a, out_b);

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_geometry_test_equal(PyObject *s, PyObject *args) {
    int ret = -1;
    PyObject *in_b = NULL;
    PedGeometry *out_a = NULL, *out_b = NULL;

if (!PyArg_ParseTuple(args, "O!", &_ped_Geometry_Type_obj, &in_b)) {
        return NULL;
    }

out_a = _ped_Geometry2PedGeometry(s);
    if (out_a == NULL) {
        return NULL;
    }

out_b = _ped_Geometry2PedGeometry(in_b);
    if (out_b == NULL) {
        return NULL;
    }

ret = ped_geometry_test_equal(out_a, out_b);

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_geometry_test_sector_inside(PyObject *s, PyObject *args) {
    int ret = -1;
    PedGeometry *geom = NULL;
    PedSector sector;

if (!PyArg_ParseTuple(args, "L", &sector)) {
        return NULL;
    }

geom = _ped_Geometry2PedGeometry(s);
    if (geom == NULL) {
        return NULL;
    }

ret = ped_geometry_test_sector_inside(geom, sector);

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_geometry_read(PyObject *s, PyObject *args) {
    PyObject *ret = NULL;
    PedGeometry *geom = NULL;
    char *out_buf = NULL;
    PedSector offset, count;

if (!PyArg_ParseTuple(args, "LL", &offset, &count)) {
        return NULL;
    }

geom = _ped_Geometry2PedGeometry(s);
    if (geom == NULL) {
        return NULL;
    }

/* py_device_read will ASSERT if the device isn't open yet. */
    if (geom->dev->open_count <= 0) {
        PyErr_SetString(IOException, "Attempting to read from a unopened device");
        return NULL;
    }

/* And then py_geometry_read will ASSERT on these things too. */
    if (offset < 0 || count < 0) {
        PyErr_SetString(IOException, "offset and count cannot be negative.");
        return NULL;
    }

if ((out_buf = malloc(geom->dev->sector_size * count)) == NULL) {
        return PyErr_NoMemory();
    }

if (ped_geometry_read(geom, out_buf, offset, count) == 0) {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                PyErr_SetString(IOException, partedExnMessage);
        }
        else
            PyErr_SetString(IOException, "Could not read from given region");

free(out_buf);
        return NULL;
    }

ret = PyUnicode_FromString(out_buf);
    free(out_buf);

return ret;
}

PyObject *py_ped_geometry_sync(PyObject *s, PyObject *args) {
    int ret = -1;
    PedGeometry *geom = NULL;

geom = _ped_Geometry2PedGeometry(s);
    if (geom == NULL) {
        return NULL;
    }

ret = ped_geometry_sync(geom);
    if (ret == 0) {
        PyErr_SetString(IOException, "Could not sync");
        return NULL;
    }

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_geometry_sync_fast(PyObject *s, PyObject *args) {
    int ret = -1;
    PedGeometry *geom = NULL;

geom = _ped_Geometry2PedGeometry(s);
    if (geom == NULL) {
        return NULL;
    }

ret = ped_geometry_sync_fast(geom);
    if (ret == 0) {
        PyErr_SetString(IOException, "Could not sync");
        return NULL;
    }

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_geometry_write(PyObject *s, PyObject *args) {
    int ret = -1;
    char *in_buf = NULL;
    PedGeometry *geom = NULL;
    PedSector offset, count;

if (!PyArg_ParseTuple(args, "sLL", &in_buf, &offset, &count)) {
        return NULL;
    }

geom = _ped_Geometry2PedGeometry(s);
    if (geom == NULL) {
        return NULL;
    }

/* py_device_write will ASSERT if the device isn't open yet. */
    if (geom->dev->open_count <= 0) {
        PyErr_SetString(IOException, "Attempting to write to a unopened device");
        return NULL;
    }

/* And then py_geometry_wriet will ASSERT on these things too. */
    if (offset < 0 || count < 0) {
        PyErr_SetString(IOException, "offset and count cannot be negative.");
        return NULL;
    }

ret = ped_geometry_write(geom, in_buf, offset, count);
    if (ret == 0) {
        if (partedExnRaised) {
            partedExnRaised = 0;

return NULL;
    }

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_geometry_check(PyObject *s, PyObject *args) {
    PyObject *in_timer = NULL;
    PedGeometry *geom = NULL;
    PedSector offset, granularity, count, ret;
    PedTimer *out_timer = NULL;
    char *out_buf = NULL;

if (!PyArg_ParseTuple(args, "LLL|O!", &offset, &granularity, &count,
                          &_ped_Timer_Type_obj, &in_timer)) {
        return NULL;
    }

geom = _ped_Geometry2PedGeometry(s);
    if (geom == NULL) {
        return NULL;
    }

if (!geom->dev->open_count) {
        PyErr_Format(IOException, "Device %s is not open.", geom->dev->path);
        return NULL;
    }

if (geom->dev->external_mode) {
        PyErr_Format(IOException, "Device %s is already open for external access.", geom->dev->path);
        return NULL;
    }

if (in_timer)
       out_timer = _ped_Timer2PedTimer(in_timer);
    else
       out_timer = NULL;

if ((out_buf = malloc(geom->dev->sector_size * 32)) == NULL) {
        ped_timer_destroy(out_timer);
        return PyErr_NoMemory();
    }

ret = ped_geometry_check(geom, out_buf, 32, offset,
                             granularity, count, out_timer);
    ped_timer_destroy(out_timer);
    free(out_buf);

return PyLong_FromLongLong(ret);
}

PyObject *py_ped_geometry_map(PyObject *s, PyObject *args) {
    int ret = -1;
    PyObject *in_dst = NULL;
    PedGeometry *out_dst = NULL, *src = NULL;
    PedSector sector;

if (!PyArg_ParseTuple(args, "O!L", &_ped_Geometry_Type_obj, &in_dst,
                          &sector)) {
        return NULL;
    }

src = _ped_Geometry2PedGeometry(s);
    if (src == NULL) {
        return NULL;
    }

out_dst = _ped_Geometry2PedGeometry(in_dst);
    if (out_dst == NULL) {
        return NULL;
    }

ret = ped_geometry_map(out_dst, src, sector);
    if (ret == -1) {
        PyErr_SetString(PyExc_ArithmeticError, "Sector must exist within region given by geometry");
        return NULL;
    }

return Py_BuildValue("i", ret);
}

/* vim:tw=78:ts=4:et:sw=4
 */
07070100115832000081A40000FFFE0000FFFD0000000157CD697A00002C29000000FC0000001000000000000000000000002C00000000pyparted-1466619794.7a0f829/src/pyfilesys.c/*
 * pyfilesys.c
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Chris Lumens <clumens@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#include <Python.h>

#include "convert.h"
#include "exceptions.h"
#include "pydevice.h"
#include "pyfilesys.h"
#include "pygeom.h"
#include "docstrings/pyfilesys.h"
#include "typeobjects/pyfilesys.h"

/* _ped.FileSystemType functions */
void _ped_FileSystemType_dealloc(_ped_FileSystemType *self) {
    PyObject_GC_UnTrack(self);
    free(self->name);
    PyObject_GC_Del(self);
}

int _ped_FileSystemType_compare(_ped_FileSystemType *self, PyObject *obj) {
    _ped_FileSystemType *comp = NULL;
    int check = PyObject_IsInstance(obj, (PyObject *) &_ped_FileSystemType_Type_obj);

if (PyErr_Occurred()) {
        return -1;
    }

if (!check) {
        PyErr_SetString(PyExc_ValueError, "object comparing to must be a _ped.FileSystemType");
        return -1;
    }

comp = (_ped_FileSystemType *) obj;
    if (!strcmp(self->name, comp->name)) {
        return 0;
    } else {
        return 1;
    }
}

PyObject *_ped_FileSystemType_richcompare(_ped_FileSystemType *a, PyObject *b,
                                          int op) {
    if (op == Py_EQ || op == Py_NE) {
        int rv = _ped_FileSystemType_compare(a, b);
        if (PyErr_Occurred())
            return NULL;
        return PyBool_FromLong(op == Py_EQ ? rv == 0 : rv != 0);
    } else if ((op == Py_LT) || (op == Py_LE) ||
               (op == Py_GT) || (op == Py_GE)) {
        PyErr_SetString(PyExc_TypeError, "comparison operator not supported for _ped.FileSystemType");
        return NULL;
    } else {
        PyErr_SetString(PyExc_ValueError, "unknown richcompare op");
        return NULL;
    }
}

PyObject *_ped_FileSystemType_str(_ped_FileSystemType *self) {
    char *ret = NULL;

if (asprintf(&ret, "_ped.FileSystemType instance --\n"
                       "  name: %s",
                 self->name) == -1) {
        return PyErr_NoMemory();
    }

return Py_BuildValue("s", ret);
}

int _ped_FileSystemType_traverse(_ped_FileSystemType *self, visitproc visit, void *arg) {
    return 0;
}

int _ped_FileSystemType_clear(_ped_FileSystemType *self) {
    return 0;
}

PyObject *_ped_FileSystemType_get(_ped_FileSystemType *self, void *closure) {
    char *member = (char *) closure;

if (member == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.FileSystemType()");
        return NULL;
    }

if (!strcmp(member, "name")) {
        if (self->name != NULL)
            return PyUnicode_FromString(self->name);
        else
            return PyUnicode_FromString("");
    } else {
        PyErr_Format(PyExc_AttributeError, "_ped.FileSystemType object has no attribute %s", member);
        return NULL;
    }
}

/* _ped.FileSystem functions */
void _ped_FileSystem_dealloc(_ped_FileSystem *self) {
    PyObject_GC_UnTrack(self);

Py_CLEAR(self->type);
    self->type = NULL;

Py_CLEAR(self->geom);
    self->geom = NULL;

PyObject_GC_Del(self);
}

int _ped_FileSystem_compare(_ped_FileSystem *self, PyObject *obj) {
    _ped_FileSystem *comp = NULL;
    int check = PyObject_IsInstance(obj, (PyObject *) &_ped_FileSystem_Type_obj);

if (PyErr_Occurred()) {
        return -1;
    }

if (!check) {
        PyErr_SetString(PyExc_ValueError, "object comparing to must be a _ped.FileSystem");
        return -1;
    }

comp = (_ped_FileSystem *) obj;
    if ((_ped_FileSystemType_Type_obj.tp_richcompare(self->type, comp->type, Py_EQ)) &&
        (_ped_Geometry_Type_obj.tp_richcompare(self->geom, comp->geom, Py_EQ)) &&
        (self->checked == comp->checked)) {
        return 0;
    } else {
        return 1;
    }

}

PyObject *_ped_FileSystem_richcompare(_ped_FileSystem *a, PyObject *b, int op) {
    if (op == Py_EQ || op == Py_NE) {
        int rv = _ped_FileSystem_compare(a, b);
        if (PyErr_Occurred())
            return NULL;
        return PyBool_FromLong(op == Py_EQ ? rv == 0 : rv != 0);
    } else if ((op == Py_LT) || (op == Py_LE) ||
               (op == Py_GT) || (op == Py_GE)) {
        PyErr_SetString(PyExc_TypeError, "comparison operator not supported for _ped.FileSystem");
        return NULL;
    } else {
        PyErr_SetString(PyExc_ValueError, "unknown richcompare op");
        return NULL;
    }
}

PyObject *_ped_FileSystem_str(_ped_FileSystem *self) {
    char *ret = NULL;
    char *type = NULL, *geom = NULL;

type = PyUnicode_AsUTF8(_ped_FileSystem_Type_obj.tp_repr(self->type));
    if (type == NULL) {
        return NULL;
    }

geom = PyUnicode_AsUTF8(_ped_Geometry_Type_obj.tp_repr(self->geom));
    if (geom == NULL) {
        return NULL;
    }

if (asprintf(&ret, "_ped.FileSystem instance --\n"
                       "  type: %s  geom: %s\n"
                       "  checked: %d",
                 type, geom, self->checked) == -1) {
        return PyErr_NoMemory();
    }

return Py_BuildValue("s", ret);
}

int _ped_FileSystem_traverse(_ped_FileSystem *self, visitproc visit, void *arg) {
    int err;

if (self->type) {
        if ((err = visit(self->type, arg))) {
            return err;
        }
    }

if (self->geom) {
        if ((err = visit(self->geom, arg))) {
            return err;
        }
    }

return 0;
}

int _ped_FileSystem_clear(_ped_FileSystem *self) {
    Py_CLEAR(self->type);
    self->type = NULL;

Py_CLEAR(self->geom);
    self->geom = NULL;

return 0;
}

int _ped_FileSystem_init(_ped_FileSystem *self, PyObject *args,
                         PyObject *kwds) {
    static char *kwlist[] = {"type", "geom", "checked", NULL};

self->checked = 0;

if (kwds == NULL) {
        if (!PyArg_ParseTuple(args, "O!O!|i",
                              &_ped_FileSystemType_Type_obj, &self->type,
                              &_ped_Geometry_Type_obj, &self->geom,
                              &self->checked)) {
            self->type = self->geom = NULL;
            return -1;
        }
    } else {
        if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!O!|i", kwlist,
                                         &_ped_FileSystemType_Type_obj, &self->type,
                                         &_ped_Geometry_Type_obj, &self->geom,
                                         &self->checked)) {
            self->type = self->geom = NULL;
            return -2;
        }
    }

Py_INCREF(self->type);
    Py_INCREF(self->geom);
    self->ped_filesystem = NULL;
    return 0;
}

PyObject *_ped_FileSystem_get(_ped_FileSystem *self, void *closure) {
    char *member = (char *) closure;

if (member == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.FileSystem()");
        return NULL;
    }

if (!strcmp(member, "checked")) {
        return PyLong_FromLong(self->checked);
    } else {
        PyErr_Format(PyExc_AttributeError, "_ped.FileSystem object has no attribute %s", member);
        return NULL;
    }
}

/* 1:1 function mappings for filesys.h in libparted */
PyObject *py_ped_file_system_type_get(PyObject *s, PyObject *args) {
    PedFileSystemType *fstype = NULL;
    _ped_FileSystemType *ret = NULL;
    char *name = NULL;

if (!PyArg_ParseTuple(args, "s", &name)) {
        return NULL;
    }

fstype = ped_file_system_type_get(name);
    if (fstype) {
        ret = PedFileSystemType2_ped_FileSystemType(fstype);
        return (PyObject *) ret;
    }
    else {
        PyErr_SetString(UnknownTypeException, name);
        return NULL;
    }
}

PyObject *py_ped_file_system_type_get_next(PyObject *s, PyObject *args) {
    PyObject *in_fstype = NULL;
    PedFileSystemType *cur = NULL, *next = NULL;
    _ped_FileSystemType *ret = NULL;

if (!PyArg_ParseTuple(args, "|O!", &_ped_FileSystemType_Type_obj, &in_fstype)) {
        return NULL;
    }

if (in_fstype) {
        cur = _ped_FileSystemType2PedFileSystemType(in_fstype);
        if (!cur) {
            return NULL;
        }
    }

next = ped_file_system_type_get_next(cur);
    if (next) {
        ret = PedFileSystemType2_ped_FileSystemType(next);
        return (PyObject *) ret;
    } else {
        PyErr_SetNone(PyExc_IndexError);
        return NULL;
    }
}

PyObject *py_ped_file_system_probe_specific(PyObject *s, PyObject *args) {
    PyObject *in_geom = NULL, *in_fstype = NULL;
    PedFileSystemType *fstype = NULL;
    PedGeometry *out_geom = NULL, *geom = NULL;
    _ped_Geometry *ret = NULL;

if (!PyArg_ParseTuple(args, "O!O!", &_ped_FileSystemType_Type_obj,
                          &in_fstype, &_ped_Geometry_Type_obj, &in_geom)) {
        return NULL;
    }

fstype = _ped_FileSystemType2PedFileSystemType(in_fstype);
    if (!fstype) {
        return NULL;
    }

out_geom = _ped_Geometry2PedGeometry(in_geom);
    if (!out_geom) {
        return NULL;
    }

geom = ped_file_system_probe_specific(fstype, out_geom);
    if (geom) {
        ret = PedGeometry2_ped_Geometry(geom);
    } else {
        /* libparted swallows exceptions here (I think) and just returns
         * NULL if the match is not made.  Reset exception flag and return
         * None.
         */
        if (partedExnRaised) {
            partedExnRaised = 0;
        }

Py_INCREF(Py_None);
        return Py_None;
    }

return (PyObject *) ret;
}

PyObject *py_ped_file_system_probe(PyObject *s, PyObject *args) {
    PyObject *in_geom = NULL;
    PedGeometry *out_geom = NULL;
    PedFileSystemType *fstype = NULL;
    _ped_FileSystemType *ret = NULL;

if (!PyArg_ParseTuple(args, "O!", &_ped_Geometry_Type_obj, &in_geom)) {
        return NULL;
    }

out_geom = _ped_Geometry2PedGeometry(in_geom);
    if (!out_geom) {
        return NULL;
    }

fstype = ped_file_system_probe(out_geom);
    if (fstype) {
        ret = PedFileSystemType2_ped_FileSystemType(fstype);
    }
    else {
        if (partedExnRaised) {
            partedExnRaised = 0;

return NULL;
    }

return (PyObject *) ret;
}
07070100115833000081A40000FFFE0000FFFD0000000157CD697A00004BAF000000FC0000001000000000000000000000002A00000000pyparted-1466619794.7a0f829/src/convert.c/*
 * convert.c
 * Convert _ped Python types to libparted typedefs.  Only typedef structs
 * need to be converted.  When a typedef in libparted is a primitive type,
 * we can just use it directly.
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Chris Lumens <clumens@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#include <Python.h>

#include "convert.h"
#include "exceptions.h"
#include "pyconstraint.h"
#include "pydevice.h"
#include "pygeom.h"
#include "pynatmath.h"
#include "pytimer.h"
#include "pyunit.h"

/*
 * These functions convert between pyparted Python types and libparted types.
 * Some are structures, some are simply C primitives.  Important notes:
 *
 * 1) When using a _ped_X2Y() function, you are converting a pyparted Python
 *    type to a libparted type.  If the function returns a pointer, you need
 *    to free it when you are done using it.
 * 2) When using a PedX2_ped_Y() function, you are converting a libparted
 *    type to a pyparted Python type.  You will get a pointer to a PyObject
 *    back, but don't free this variable.  Python will handle clean up of
 *    these variables through reference counts.
 * 3) Some functions return C primitives, so no memory management needs to
 *    be done.
 *
 * Error handling notes:
 *
 * 1) When converting from a PyObject, first check for NULL and raise a
 *    PyExc_Type error.
 * 2) When converting from a Ped*, first check for NULL and raise a
 *    PyExc_Type error.
 * 3) Check the return value of all calls to other convert.c functions and
 *    return NULL on error, but do not raise an exception.
 * 4) Check the return value of PyObject_new, malloc, strdup, and any other
 *    functions that allocate memory and call PyErr_NoMemory on error.
 * 5) When calling a libparted function, check for error conditions and
 *    raise the appropriate exceptions.  Create new exceptions if needed.
 * 6) At the end of a conversion function, make sure the return value is
 *    not NULL.  Raise the appropriate exception if it is.
 */

/* _ped_Alignment -> PedAlignment functions */
PedAlignment *_ped_Alignment2PedAlignment(PyObject *s) {
    PedAlignment *ret = NULL;
    _ped_Alignment *alignment = (_ped_Alignment *) s;

if (alignment == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.Alignment()");
        return NULL;
    }

ret = ped_alignment_new(alignment->offset, alignment->grain_size);
    if (ret == NULL)
        return (PedAlignment *) PyErr_NoMemory();

return ret;
}

_ped_Alignment *PedAlignment2_ped_Alignment(PedAlignment *alignment) {
    _ped_Alignment *ret = NULL;
    PyObject *args = NULL;

if (alignment == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty PedAlignment()");
        return NULL;
    }

ret = (_ped_Alignment *) _ped_Alignment_Type_obj.tp_new(&_ped_Alignment_Type_obj, NULL, NULL);
    if (!ret)
        return (_ped_Alignment *) PyErr_NoMemory();

args = Py_BuildValue("LL", alignment->offset, alignment->grain_size);
    if (args == NULL) {
        goto error;
    }

if (_ped_Alignment_Type_obj.tp_init((PyObject *) ret, args, NULL)) {
        goto error;
    }

Py_DECREF(args);

return ret;

error:
    Py_XDECREF(args);
    Py_DECREF(ret);
    return NULL;
}

/* _ped_Constraint -> PedConstraint functions */
PedConstraint *_ped_Constraint2PedConstraint(PyObject *s) {
    PedConstraint *ret = NULL;
    PedAlignment *start_align = NULL, *end_align = NULL;
    PedGeometry *start_range = NULL, *end_range = NULL;
    _ped_Constraint *constraint = (_ped_Constraint *) s;

if (constraint == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.Constraint()");
        return NULL;
    }

start_align = _ped_Alignment2PedAlignment(constraint->start_align);
    if (start_align == NULL) {
        return NULL;
    }

end_align = _ped_Alignment2PedAlignment(constraint->end_align);
    if (end_align == NULL) {
        ped_alignment_destroy(start_align);
        return NULL;
    }

start_range = _ped_Geometry2PedGeometry(constraint->start_range);
    if (start_range == NULL) {
        ped_alignment_destroy(start_align);
        ped_alignment_destroy(end_align);
        return NULL;
    }

end_range = _ped_Geometry2PedGeometry(constraint->end_range);
    if (end_range == NULL) {
        ped_alignment_destroy(start_align);
        ped_alignment_destroy(end_align);
        return NULL;
    }

ret = ped_constraint_new(start_align, end_align, start_range, end_range,
                             constraint->min_size, constraint->max_size);
    if (ret == NULL) {
        /* Fall through to clean up memory, but set the error condition now. */
        PyErr_NoMemory();
    }

ped_alignment_destroy(start_align);
    ped_alignment_destroy(end_align);

return ret;
}

_ped_Constraint *PedConstraint2_ped_Constraint(PedConstraint *constraint) {
    _ped_Constraint *ret = NULL;
    _ped_Alignment *start_align = NULL;
    _ped_Alignment *end_align = NULL;
    _ped_Geometry *start_range = NULL;
    _ped_Geometry *end_range = NULL;
    PyObject *args = NULL;

if (constraint == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty PedConstraint()");
        return NULL;
    }

ret = (_ped_Constraint *) _ped_Constraint_Type_obj.tp_new(&_ped_Constraint_Type_obj, NULL, NULL);
    if (!ret)
        return (_ped_Constraint *) PyErr_NoMemory();

if ((start_align = PedAlignment2_ped_Alignment(constraint->start_align)) == NULL)
        goto error;

if ((end_align = PedAlignment2_ped_Alignment(constraint->end_align)) == NULL)
        goto error;

if ((start_range = PedGeometry2_ped_Geometry(constraint->start_range)) == NULL)
        goto error;

if ((end_range = PedGeometry2_ped_Geometry(constraint->end_range)) == NULL)
        goto error;

args = Py_BuildValue("OOOOLL", start_align, end_align, start_range, end_range, constraint->min_size, constraint->max_size);
    if (args == NULL) {
        goto error;
    }

if (_ped_Constraint_Type_obj.tp_init((PyObject *) ret, args, NULL)) {
        goto error;
    }

Py_DECREF(args);
    Py_DECREF(start_align);
    Py_DECREF(end_align);
    Py_DECREF(start_range);
    Py_DECREF(end_range);

return ret;

error:
    Py_XDECREF(args);
    Py_XDECREF(start_align);
    Py_XDECREF(end_align);
    Py_XDECREF(start_range);
    Py_XDECREF(end_range);
    Py_DECREF(ret);
    return NULL;
}

/* _ped_Device -> PedDevice functions */
PedDevice *_ped_Device2PedDevice(PyObject *s) {
    _ped_Device *dev = (_ped_Device *) s;
    PedDevice *ret;

if (dev == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.Device()");
        return NULL;
    }

ret = ped_device_get(dev->path);
    if (ret == NULL) {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                PyErr_SetString(DeviceException, partedExnMessage);
        }
        else
            PyErr_Format(DeviceException, "Could not find device for path %s", dev->path);
    }
    return ret;
}

/* PedDevice -> _ped_Device functions */
_ped_Device *PedDevice2_ped_Device(PedDevice *device) {
    _ped_Device *ret = NULL;

if (device == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty PedDevice");
        return NULL;
    }

ret = (_ped_Device *) _ped_Device_Type_obj.tp_alloc(&_ped_Device_Type_obj, 1);
    if (!ret)
        return (_ped_Device *) PyErr_NoMemory();

ret->model = strdup(device->model);
    if (ret->model == NULL) {
        PyErr_NoMemory();
        goto error;
    }

ret->path = strdup(device->path);
    if (ret->path == NULL) {
        PyErr_NoMemory();
        goto error;
    }

ret->type = device->type;
    ret->sector_size = device->sector_size;
    ret->phys_sector_size = device->phys_sector_size;
    ret->open_count = device->open_count;
    ret->read_only = device->read_only;
    ret->external_mode = device->external_mode;
    ret->dirty = device->dirty;
    ret->boot_dirty = device->boot_dirty;
    ret->host = device->host;
    ret->did = device->did;
    ret->length = device->length;

ret->hw_geom = (PyObject *) PedCHSGeometry2_ped_CHSGeometry(&device->hw_geom);
    if (ret->hw_geom == NULL)
        goto error;

ret->bios_geom = (PyObject *) PedCHSGeometry2_ped_CHSGeometry(&device->bios_geom);
    if (ret->bios_geom == NULL)
        goto error;

return ret;

error:
    Py_DECREF(ret);
    return NULL;
}

PedDisk *_ped_Disk2PedDisk(PyObject *s) {
    _ped_Disk *disk = (_ped_Disk *) s;

if (disk == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.Disk()");
        return NULL;
    }

return disk->ped_disk;
}

_ped_Disk *PedDisk2_ped_Disk(PedDisk *disk) {
    _ped_Disk *ret = NULL;

if (disk == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty PedDisk()");
        return NULL;
    }

ret = (_ped_Disk *) _ped_Disk_Type_obj.tp_new(&_ped_Disk_Type_obj, NULL, NULL);
    if (!ret) {
        ped_disk_destroy(disk);
        return (_ped_Disk *) PyErr_NoMemory();
    }
    ret->ped_disk = disk;

ret->dev = (PyObject *) PedDevice2_ped_Device(disk->dev);
    if (!ret->dev)
        goto error;

ret->type = (PyObject *) PedDiskType2_ped_DiskType(disk->type);
    if (!ret->type)
        goto error;

return ret;

error:
    Py_DECREF(ret);
    return NULL;
}

PedDiskType *_ped_DiskType2PedDiskType(PyObject *s) {
    PedDiskType *ret = NULL;
    _ped_DiskType *type = (_ped_DiskType *) s;

if (type == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.DiskType()");
        return NULL;
    }

ret = ped_disk_type_get(type->name);
    if (ret == NULL) {
        PyErr_SetString(UnknownTypeException, type->name);
        return NULL;
    }

return ret;
}

_ped_DiskType *PedDiskType2_ped_DiskType(const PedDiskType *type) {
    _ped_DiskType *ret = NULL;

if (type == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty PedDiskType()");
        return NULL;
    }

ret = (_ped_DiskType *) _ped_DiskType_Type_obj.tp_alloc(&_ped_DiskType_Type_obj, 1);
    if (!ret)
        return (_ped_DiskType *) PyErr_NoMemory();

ret->name = strdup(type->name);
    if (ret->name == NULL) {
        Py_DECREF(ret);
        return (_ped_DiskType *) PyErr_NoMemory();
    }

ret->features = type->features;

return ret;
}

/* _ped_FileSystem -> PedFileSystem functions */
PedFileSystem *_ped_FileSystem2PedFileSystem(PyObject *s) {
    _ped_FileSystem *fs = (_ped_FileSystem *) s;

if (fs == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.FileSystem");
        return NULL;
    }

if (fs->ped_filesystem == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.FileSystem.ped_filesystem");
        return NULL;
    } else {
        return fs->ped_filesystem;
    }
}

_ped_FileSystem *PedFileSystem2_ped_FileSystem(PedFileSystem *fs) {
    _ped_FileSystem *ret = NULL;
    _ped_FileSystemType *type = NULL;
    _ped_Geometry *geom = NULL;
    PyObject *args = NULL;

if (fs == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty PedFileSystem()");
        return NULL;
    }

ret = (_ped_FileSystem *) _ped_FileSystem_Type_obj.tp_new(&_ped_FileSystem_Type_obj, NULL, NULL);
    if (!ret)
        return (_ped_FileSystem *) PyErr_NoMemory();

if ((type = PedFileSystemType2_ped_FileSystemType(fs->type)) == NULL)
        goto error;

if ((geom = PedGeometry2_ped_Geometry(fs->geom)) == NULL)
        goto error;

args = Py_BuildValue("OOi", type, geom, fs->checked);
    if (args == NULL) {
        goto error;
    }

if (_ped_FileSystem_Type_obj.tp_init((PyObject *) ret, args, NULL)) {
        goto error;
    }

Py_DECREF(args);
    Py_DECREF(type);
    Py_DECREF(geom);

return ret;

error:
    Py_XDECREF(args);
    Py_XDECREF(type);
    Py_XDECREF(geom);
    Py_DECREF(ret);
    return NULL;
}

/* _ped_FileSystemType -> PedFileSystemType functions */
PedFileSystemType *_ped_FileSystemType2PedFileSystemType(PyObject *s) {
    PedFileSystemType *ret = NULL;
    _ped_FileSystemType *type = (_ped_FileSystemType *) s;

if (type == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.FileSystemType");
        return NULL;
    }

if ((ret = ped_file_system_type_get(type->name)) == NULL) {
        PyErr_SetString(UnknownTypeException, type->name);
        return NULL;
    }

return ret;
}

_ped_FileSystemType *PedFileSystemType2_ped_FileSystemType(const PedFileSystemType *fstype) {
    _ped_FileSystemType *ret = NULL;

if (fstype == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty PedFileSystemType()");
        return NULL;
    }

ret = (_ped_FileSystemType *) _ped_FileSystemType_Type_obj.tp_alloc(&_ped_FileSystemType_Type_obj, 1);
    if (!ret)
       return (_ped_FileSystemType *) PyErr_NoMemory();

ret->name = strdup(fstype->name);
    if (ret->name == NULL) {
        Py_DECREF(ret);
        return (_ped_FileSystemType *) PyErr_NoMemory();
    }

return ret;
}

/* _ped_Geometry -> PedGeometry functions */
PedGeometry *_ped_Geometry2PedGeometry(PyObject *s) {
    _ped_Geometry *geometry = (_ped_Geometry *) s;

if (geometry == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.Geometry()");
        return NULL;
    }

return geometry->ped_geometry;
}

_ped_Geometry *PedGeometry2_ped_Geometry(PedGeometry *geometry) {
    _ped_Geometry *ret = NULL;
    _ped_Device *dev = NULL;
    PyObject *args = NULL;

if (geometry == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty PedGeometry()");
        return NULL;
    }

ret = (_ped_Geometry *) _ped_Geometry_Type_obj.tp_new(&_ped_Geometry_Type_obj, NULL, NULL);
    if (!ret)
        return (_ped_Geometry *) PyErr_NoMemory();

if ((dev = PedDevice2_ped_Device(geometry->dev)) == NULL)
        goto error;

args = Py_BuildValue("OLLL", dev, geometry->start, geometry->length, geometry->end);
    if (args == NULL) {
        goto error;
    }

if (_ped_Geometry_Type_obj.tp_init((PyObject *) ret, args, NULL)) {
        goto error;
    }

Py_DECREF(args);
    Py_DECREF(dev);

return ret;

error:
    Py_XDECREF(args);
    Py_XDECREF(dev);
    Py_DECREF(ret);
    return NULL;
}

/* _ped_CHSGeometry -> PedCHSGeometry functions */
PedCHSGeometry *_ped_CHSGeometry2PedCHSGeometry(PyObject *s) {
    PedCHSGeometry *ret = NULL;
    _ped_CHSGeometry *srcgeom = (_ped_CHSGeometry *) s;

if (srcgeom == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.CHSGeometry()");
        return NULL;
    }

if ((ret = malloc(sizeof(PedCHSGeometry))) == NULL)
        return (PedCHSGeometry *) PyErr_NoMemory();

ret->cylinders = srcgeom->cylinders;
    ret->heads = srcgeom->heads;
    ret->sectors = srcgeom->sectors;

return ret;
}

/* PedCHSGeometry -> _ped_CHSGeometry functions */
_ped_CHSGeometry *PedCHSGeometry2_ped_CHSGeometry(PedCHSGeometry *geom) {
    _ped_CHSGeometry *ret = NULL;

if (geom == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty PedCHSGeometry()");
        return NULL;
    }

ret = (_ped_CHSGeometry *) _ped_CHSGeometry_Type_obj.tp_alloc(&_ped_CHSGeometry_Type_obj, 1);
    if (!ret)
        return (_ped_CHSGeometry *) PyErr_NoMemory();

ret->cylinders = geom->cylinders;
    ret->heads = geom->heads;
    ret->sectors = geom->sectors;

return ret;
}

PedPartition *_ped_Partition2PedPartition(_ped_Partition *s) {
    if (s == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.Partition()");
        return NULL;
    }

return s->ped_partition;
}

_ped_Partition *PedPartition2_ped_Partition(PedPartition *part,
                                            _ped_Disk *pydisk) {
    _ped_Partition *ret = NULL;

if (part == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty PedPartition()");
        return NULL;
    }

if (pydisk == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped_Disk()");
        return NULL;
    }

ret = (_ped_Partition *) _ped_Partition_Type_obj.tp_new(&_ped_Partition_Type_obj, NULL, NULL);
    if (!ret)
        return (_ped_Partition *) PyErr_NoMemory();

ret->disk = (PyObject *)pydisk;
    Py_INCREF(ret->disk);

ret->geom = (PyObject *)PedGeometry2_ped_Geometry(&part->geom);
    if (!ret->geom)
        goto error;

if (part->fs_type == NULL) {
        ret->fs_type = Py_None;
        Py_INCREF(ret->fs_type);
    } else {
        ret->fs_type = (PyObject *)PedFileSystemType2_ped_FileSystemType(part->fs_type);
        if (!ret->fs_type)
            goto error;
    }

ret->type = part->type;
    ret->ped_partition = part;

return ret;

error:
    Py_DECREF(ret);
    return NULL;
}

/* _ped_Timer -> PedTimer functions */
PedTimer *_ped_Timer2PedTimer(PyObject *s) {
    PedTimer *ret = NULL;
    _ped_Timer *timer = (_ped_Timer *) s;

if (timer == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.Timer()");
        return NULL;
    }

if ((ret = malloc(sizeof(PedTimer))) == NULL)
        return (PedTimer *) PyErr_NoMemory();

ret->frac = timer->frac;
    ret->start = timer->start;
    ret->now = timer->now;
    ret->predicted_end = timer->predicted_end;
    ret->handler = timer->handler;
    ret->context = timer->context;

ret->state_name = strdup(timer->state_name);
    if (ret->state_name == NULL) {
        free(ret);
        return (PedTimer *) PyErr_NoMemory();
    }

return ret;
}

/* PedTimer -> _ped_Timer functions */
_ped_Timer *PedTimer2_ped_Timer(PedTimer *timer) {
    _ped_Timer *ret = NULL;

if (timer == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty PedTimer()");
        return NULL;
    }

ret = (_ped_Timer *) _ped_Timer_Type_obj.tp_new(&_ped_Timer_Type_obj, NULL, NULL);
    if (!ret)
        return (_ped_Timer *) PyErr_NoMemory();

ret->frac = timer->frac;
    ret->start = timer->start;
    ret->now = timer->now;
    ret->predicted_end = timer->predicted_end;

ret->state_name = strdup(timer->state_name);
    if (ret->state_name == NULL) {
        Py_DECREF(ret);
        return (_ped_Timer *) PyErr_NoMemory();
    }

/* XXX: don't know what to do with these */
    ret->handler = timer->handler;
    ret->context = timer->context;

return ret;
}

/* vim:tw=78:ts=4:et:sw=4
 */
07070100115834000081A40000FFFE0000FFFD0000000157CD697A0000254D000000FC0000001000000000000000000000002C00000000pyparted-1466619794.7a0f829/src/pynatmath.c/*
 * pynatmath.c
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Chris Lumens <clumens@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#include <Python.h>

#include "convert.h"
#include "exceptions.h"
#include "pydevice.h"
#include "pynatmath.h"
#include "docstrings/pynatmath.h"
#include "typeobjects/pynatmath.h"

/* _ped.Alignment functions */
void _ped_Alignment_dealloc(_ped_Alignment *self) {
    PyObject_GC_UnTrack(self);
    PyObject_GC_Del(self);
}

int _ped_Alignment_compare(_ped_Alignment *self, PyObject *obj) {
    _ped_Alignment *comp = NULL;
    int check = PyObject_IsInstance(obj, (PyObject *) &_ped_Alignment_Type_obj);

if (PyErr_Occurred()) {
        return -1;
    }

if (!check) {
        PyErr_SetString(PyExc_ValueError, "object comparing to must be a _ped.Alignment");
        return -1;
    }

comp = (_ped_Alignment *) obj;
    if ((self->offset == comp->offset) &&
        (self->grain_size == comp->grain_size)) {
        return 0;
    } else {
        return 1;
    }
}

PyObject *_ped_Alignment_richcompare(_ped_Alignment *a, PyObject *b, int op) {
    if (op == Py_EQ || op == Py_NE) {
        int rv = _ped_Alignment_compare(a, b);
        if (PyErr_Occurred())
            return NULL;
        return PyBool_FromLong(op == Py_EQ ? rv == 0 : rv != 0);
    } else if ((op == Py_LT) || (op == Py_LE) ||
               (op == Py_GT) || (op == Py_GE)) {
        PyErr_SetString(PyExc_TypeError, "comparison operator not supported for _ped.Alignment");
        return NULL;
    } else {
        PyErr_SetString(PyExc_ValueError, "unknown richcompare op");
        return NULL;
    }
}

PyObject *_ped_Alignment_str(_ped_Alignment *self) {
    char *ret = NULL;

if (asprintf(&ret, "_ped.Alignment instance --\n"
                       "  offset: %lld  grain_size: %lld",
                 self->offset, self->grain_size) == -1) {
        return PyErr_NoMemory();
    }

return Py_BuildValue("s", ret);
}

int _ped_Alignment_traverse(_ped_Alignment *self, visitproc visit, void *arg) {
    return 0;
}

int _ped_Alignment_clear(_ped_Alignment *self) {
    return 0;
}

int _ped_Alignment_init(_ped_Alignment *self, PyObject *args, PyObject *kwds) {
    static char *kwlist[] = {"offset", "grain_size", NULL};
    PedAlignment *alignment = NULL;

if (!PyArg_ParseTupleAndKeywords(args, kwds, "LL", kwlist,
                                     &self->offset, &self->grain_size)) {
        return -1;
    } else {
        alignment = ped_alignment_new(self->offset, self->grain_size);
        if (!alignment) {
            PyErr_SetString(CreateException, "Could not create new alignment");
            return -1;
        }

self->offset = alignment->offset;
        self->grain_size = alignment->grain_size;

ped_alignment_destroy(alignment);
        return 0;
    }
}

PyObject *_ped_Alignment_get(_ped_Alignment *self, void *closure) {
    char *member = (char *) closure;

if (member == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.Alignment()");
        return NULL;
    }

if (!strcmp(member, "offset")) {
        return PyLong_FromLongLong(self->offset);
    } else if (!strcmp(member, "grain_size")) {
        return PyLong_FromLongLong(self->grain_size);
    } else {
        PyErr_Format(PyExc_AttributeError, "_ped.Alignment object has no attribute %s", member);
        return NULL;
    }
}

int _ped_Alignment_set(_ped_Alignment *self, PyObject *value, void *closure) {
    char *member = (char *) closure;

if (member == NULL) {
        return -1;
    }

if (!strcmp(member, "offset")) {
        self->offset = PyLong_AsLongLong(value);
        if (PyErr_Occurred()) {
            return -1;
        }
    } else if (!strcmp(member, "grain_size")) {
        self->grain_size = PyLong_AsLongLong(value);
        if (PyErr_Occurred()) {
            return -1;
        }
    } else {
        return -1;
    }

return 0;
}

/* 1:1 function mappings for natmath.h in libparted */
PyObject *py_ped_alignment_duplicate(PyObject *s, PyObject *args) {
    PedAlignment *alignment = NULL, *align = NULL;
    _ped_Alignment *ret = NULL;

alignment = _ped_Alignment2PedAlignment(s);
    if (alignment == NULL) {
        return NULL;
    }

align = ped_alignment_duplicate(alignment);

ped_alignment_destroy(alignment);

if (align) {
        ret = PedAlignment2_ped_Alignment(align);
    }
    else {
        PyErr_SetString(CreateException, "Could not duplicate alignment");
        return NULL;
    }

ped_alignment_destroy(align);

return (PyObject *) ret;
}

PyObject *py_ped_alignment_intersect(PyObject *s, PyObject *args) {
    PyObject *in_b = NULL;
    PedAlignment *out_a = NULL, *out_b = NULL, *align = NULL;
    _ped_Alignment *ret = NULL;

if (!PyArg_ParseTuple(args, "O!", &_ped_Alignment_Type_obj, &in_b)) {
        return NULL;
    }

out_a = _ped_Alignment2PedAlignment(s);
    if (out_a == NULL) {
        return NULL;
    }

out_b = _ped_Alignment2PedAlignment(in_b);
    if (out_b == NULL) {
        return NULL;
    }

align = ped_alignment_intersect(out_a, out_b);

ped_alignment_destroy(out_a);
    ped_alignment_destroy(out_b);

if (align) {
        ret = PedAlignment2_ped_Alignment(align);
    }
    else {
        PyErr_SetString(PyExc_ArithmeticError, "Could not find alignment intersection");
        return NULL;
    }

ped_alignment_destroy(align);

return (PyObject *) ret;
}

PyObject *py_ped_alignment_align_up(PyObject *s, PyObject *args) {
    PyObject *in_geom = NULL;
    PedAlignment *align = NULL;
    PedGeometry *out_geom = NULL;
    PedSector sector, ret;

if (!PyArg_ParseTuple(args, "O!L", &_ped_Geometry_Type_obj, &in_geom, &sector)) {
        return NULL;
    }

align = _ped_Alignment2PedAlignment(s);
    if (align == NULL) {
        return NULL;
    }

out_geom = _ped_Geometry2PedGeometry(in_geom);
    if (out_geom == NULL) {
        return NULL;
    }

ret = ped_alignment_align_up(align, out_geom, sector);

ped_alignment_destroy(align);

if (ret == -1) {
        PyErr_SetString(PyExc_ArithmeticError, "Could not align up to sector");
        return NULL;
    }

return PyLong_FromLongLong(ret);
}

PyObject *py_ped_alignment_align_down(PyObject *s, PyObject *args) {
    PyObject *in_geom = NULL;
    PedAlignment *align = NULL;
    PedGeometry *out_geom = NULL;
    PedSector sector, ret;

if (!PyArg_ParseTuple(args, "O!L", &_ped_Geometry_Type_obj, &in_geom, &sector)) {
        return NULL;
    }

align = _ped_Alignment2PedAlignment(s);
    if (align == NULL) {
        return NULL;
    }

out_geom = _ped_Geometry2PedGeometry(in_geom);
    if (out_geom == NULL) {
        return NULL;
    }

ret = ped_alignment_align_down(align, out_geom, sector);

ped_alignment_destroy(align);

if (ret == -1) {
        PyErr_SetString(PyExc_ArithmeticError, "Could not align down to sector");
        return NULL;
    }

return PyLong_FromLongLong(ret);
}

PyObject *py_ped_alignment_align_nearest(PyObject *s, PyObject *args) {
    PyObject *in_geom = NULL;
    PedAlignment *align = NULL;
    PedGeometry *out_geom = NULL;
    PedSector sector, ret;

if (!PyArg_ParseTuple(args, "O!L", &_ped_Geometry_Type_obj, &in_geom, &sector)) {
        return NULL;
    }

align = _ped_Alignment2PedAlignment(s);
    if (align == NULL) {
        return NULL;
    }

out_geom = _ped_Geometry2PedGeometry(in_geom);
    if (out_geom == NULL) {
        return NULL;
    }

ret = ped_alignment_align_nearest(align, out_geom, sector);

ped_alignment_destroy(align);

if (ret == -1) {
        PyErr_SetString(PyExc_ArithmeticError, "Could not align to closest sector");
        return NULL;
    }

return PyLong_FromLongLong(ret);
}

PyObject *py_ped_alignment_is_aligned(PyObject *s, PyObject *args) {
    int ret = -1;
    PyObject *in_geom = NULL;
    PedAlignment *align = NULL;
    PedGeometry *out_geom = NULL;
    PedSector sector;

if (!PyArg_ParseTuple(args, "O!L", &_ped_Geometry_Type_obj, &in_geom, &sector)) {
        return NULL;
    }

align = _ped_Alignment2PedAlignment(s);
    if (align == NULL) {
        return NULL;
    }

out_geom = _ped_Geometry2PedGeometry(in_geom);
    if (out_geom == NULL) {
        return NULL;
    }

ret = ped_alignment_is_aligned(align, out_geom, sector);
    ped_alignment_destroy(align);

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

/* vim:tw=78:ts=4:et:sw=4
 */
07070100115835000081A40000FFFE0000FFFD0000000157CD697A0000D2DF000000FC0000001000000000000000000000002900000000pyparted-1466619794.7a0f829/src/pydisk.c/*
 * pydisk.c
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Chris Lumens <clumens@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#include <Python.h>

#include <stdlib.h>

#include "convert.h"
#include "exceptions.h"
#include "pydisk.h"
#include "docstrings/pydisk.h"
#include "typeobjects/pydisk.h"

/* _ped.Partition functions */
void _ped_Partition_dealloc(_ped_Partition *self) {
    PyObject_GC_UnTrack(self);

Py_CLEAR(self->disk);
    self->disk = NULL;

Py_CLEAR(self->geom);
    self->geom = NULL;

Py_CLEAR(self->fs_type);
    self->fs_type = NULL;

PyObject_GC_Del(self);
}

int _ped_Partition_compare(_ped_Partition *self, PyObject *obj) {
    _ped_Partition *comp = NULL;
    int check = PyObject_IsInstance(obj, (PyObject *) &_ped_Partition_Type_obj);

if (PyErr_Occurred()) {
        return -1;
    }

if (!check) {
        PyErr_SetString(PyExc_ValueError, "object comparing to must be a _ped.Partition");
        return -1;
    }

comp = (_ped_Partition *) obj;
    if ((_ped_Disk_Type_obj.tp_richcompare(self->disk, comp->disk, Py_EQ)) &&
        (_ped_Geometry_Type_obj.tp_richcompare(self->geom, comp->geom, Py_EQ)) &&
        (self->ped_partition->num == comp->ped_partition->num) &&
        (self->type == comp->type) &&
        (_ped_FileSystemType_Type_obj.tp_richcompare(self->fs_type, comp->fs_type, Py_EQ))) {
        return 0;
    } else {
        return 1;
    }
}

PyObject *_ped_Partition_richcompare(_ped_Partition *a, PyObject *b, int op) {
    if (op == Py_EQ) {
        if ((_ped_Partition_Type_obj.tp_richcompare((PyObject *) a, b, Py_EQ))) {
            Py_RETURN_TRUE;
        } else {
            Py_RETURN_FALSE;
        }
    } else if (op == Py_NE) {
        if (!(_ped_Partition_Type_obj.tp_richcompare((PyObject *) a, b, Py_EQ))) {
            Py_RETURN_TRUE;
        } else {
            Py_RETURN_FALSE;
        }
    } else if ((op == Py_LT) || (op == Py_LE) ||
               (op == Py_GT) || (op == Py_GE)) {
        PyErr_SetString(PyExc_TypeError, "comparison operator not supported for _ped.Partition");
        return NULL;
    } else {
        PyErr_SetString(PyExc_ValueError, "unknown richcompare op");
        return NULL;
    }
}

PyObject *_ped_Partition_str(_ped_Partition *self) {
    char *ret = NULL;
    char *disk = NULL, *fs_type = NULL, *geom = NULL;

disk = PyUnicode_AsUTF8(_ped_Disk_Type_obj.tp_repr(self->disk));
    if (disk == NULL) {
        return NULL;
    }

fs_type = PyUnicode_AsUTF8(_ped_FileSystemType_Type_obj.tp_repr(self->fs_type));
    if (fs_type == NULL) {
        return NULL;
    }

geom = PyUnicode_AsUTF8(_ped_Geometry_Type_obj.tp_repr(self->geom));
    if (geom == NULL) {
        return NULL;
    }

if (asprintf(&ret, "_ped.Partition instance --\n"
                       "  disk: %s  fs_type: %s\n"
                       "  num: %d  type: %d\n"
                       "  geom: %s",
                 disk, fs_type, self->ped_partition->num, self->type,
                 geom) == -1) {
        return PyErr_NoMemory();
    }

return Py_BuildValue("s", ret);
}

int _ped_Partition_traverse(_ped_Partition *self, visitproc visit, void *arg) {
    int err;

if (self->disk) {
        if ((err = visit(self->disk, arg))) {
            return err;
        }
    }

if (self->geom) {
        if ((err = visit(self->geom, arg))) {
            return err;
        }
    }

if (self->fs_type) {
        if ((err = visit(self->fs_type, arg))) {
            return err;
        }
    }

return 0;
}

int _ped_Partition_clear(_ped_Partition *self) {
    Py_CLEAR(self->disk);
    self->disk = NULL;

Py_CLEAR(self->geom);
    self->geom = NULL;

Py_CLEAR(self->fs_type);
    self->fs_type = NULL;

return 0;
}

int _ped_Partition_init(_ped_Partition *self, PyObject *args, PyObject *kwds) {
    static char *kwlist[] = {"disk", "type", "start", "end", "fs_type", NULL};
    PedSector start, end;
    PedDisk *disk = NULL;
    PedFileSystemType *fstype = NULL;
    PedPartition *part = NULL;

self->fs_type = Py_None;

if (kwds == NULL) {
        if (!PyArg_ParseTuple(args, "O!iLL|O!",
                              &_ped_Disk_Type_obj, &self->disk,
                              &self->type, &start, &end,
                              &_ped_FileSystemType_Type_obj, &self->fs_type)) {
            self->disk = self->fs_type = NULL;
            return -1;
        }
    } else {
        if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!iLL|O!", kwlist,
                                         &_ped_Disk_Type_obj, &self->disk,
                                         &self->type, &start, &end,
                                         &_ped_FileSystemType_Type_obj, &self->fs_type)) {
            self->disk = self->fs_type = NULL;
            return -1;
        }
    }

/*
     * try to call libparted with provided information,
     * on failure, raise an exception
     */
    disk = _ped_Disk2PedDisk(self->disk);

if (self->fs_type != Py_None)
        fstype = _ped_FileSystemType2PedFileSystemType(self->fs_type);

part = ped_partition_new(disk, self->type, fstype, start, end);
    if (part == NULL) {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                !PyErr_ExceptionMatches(PyExc_NotImplementedError)) {
                PyErr_SetString(PartitionException, partedExnMessage);
            }
        } else {
            PyErr_Format(PartitionException, "Could not create new partition on device %s", disk->dev->path);
        }

self->disk = self->fs_type = NULL;
        return -3;
    }

/* increment reference count for PyObjects read by PyArg_ParseTuple */
    Py_INCREF(self->disk);
    Py_INCREF(self->fs_type);

/* copy in non-PyObject object members generated by libparted */
    self->type = part->type;

/*
     * copy in PyObject object members generated by libparted
     * first, we drop the reference count to zero and set it to NULL
     * second, we convert the libparted type to a PyObject
     */
    Py_CLEAR(self->geom);
    self->geom = (PyObject *) PedGeometry2_ped_Geometry(&(part->geom));
    if (self->geom == NULL) {
        Py_CLEAR(self->disk);
        Py_CLEAR(self->fs_type);
        ped_partition_destroy(part);
        return -4;
    }

self->ped_partition = part;

/* On creation the object is not owned by any disk */
    self->_owned = 0;

return 0;
}

PyObject *_ped_Partition_get(_ped_Partition *self, void *closure) {
    char *member = (char *) closure;

if (member == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.Partition()");
        return NULL;
    }

if (!strcmp(member, "num")) {
        return Py_BuildValue("i", self->ped_partition->num);
    } else if (!strcmp(member, "type")) {
        return PyLong_FromLong(self->type);
    } else {
        PyErr_Format(PyExc_AttributeError, "_ped.Partition object has no attribute %s", member);
        return NULL;
    }
}

int _ped_Partition_set(_ped_Partition *self, PyObject *value, void *closure) {
    char *member = (char *) closure;

if (member == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.Partition()");
        return -1;
    }

if (!strcmp(member, "type")) {
        self->type = PyLong_AsLong(value);
        if (PyErr_Occurred()) {
            return -1;
        }
    } else {
        PyErr_Format(PyExc_AttributeError, "_ped.Partition object has no attribute %s", member);
        return -1;
    }

return 0;
}

/* _ped.Disk functions */
void _ped_Disk_dealloc(_ped_Disk *self) {
    if (self->ped_disk) {
        ped_disk_destroy(self->ped_disk);
    }

PyObject_GC_UnTrack(self);

Py_CLEAR(self->dev);
    self->dev = NULL;

Py_CLEAR(self->type);
    self->type = NULL;

PyObject_GC_Del(self);
}

int _ped_Disk_compare(_ped_Disk *self, PyObject *obj) {
    _ped_Disk *comp = NULL;
    int check = PyObject_IsInstance(obj, (PyObject *) &_ped_Disk_Type_obj);

if (PyErr_Occurred()) {
        return -1;
    }

if (!check) {
        PyErr_SetString(PyExc_ValueError, "object comparing to must be a _ped.Disk");
        return -1;
    }

comp = (_ped_Disk *) obj;
    if ((_ped_Device_Type_obj.tp_richcompare(self->dev, comp->dev, Py_EQ)) &&
        (_ped_DiskType_Type_obj.tp_richcompare(self->type, comp->type, Py_EQ))) {
        return 0;
    } else {
        return 1;
    }
}

PyObject *_ped_Disk_richcompare(_ped_Disk *a, PyObject *b, int op) {
    if (op == Py_EQ || op == Py_NE) {
        int rv = _ped_Disk_compare(a, b);
        if (PyErr_Occurred())
            return NULL;
        return PyBool_FromLong(op == Py_EQ ? rv == 0 : rv != 0);
    } else if ((op == Py_LT) || (op == Py_LE) ||
               (op == Py_GT) || (op == Py_GE)) {
        PyErr_SetString(PyExc_TypeError, "comparison operator not supported for _ped.Disk");
        return NULL;
    } else {
        PyErr_SetString(PyExc_ValueError, "unknown richcompare op");
        return NULL;
    }
}

PyObject *_ped_Disk_str(_ped_Disk *self) {
    char *ret = NULL;
    char *dev = NULL, *type = NULL;

dev = PyUnicode_AsUTF8(_ped_Device_Type_obj.tp_repr(self->dev));
    if (dev == NULL) {
        return NULL;
    }

type = PyUnicode_AsUTF8(_ped_Device_Type_obj.tp_repr(self->type));
    if (type == NULL) {
        return NULL;
    }

if (asprintf(&ret, "_ped.Disk instance --\n  dev: %s  type: %s",
                 dev, type) == -1) {
        return PyErr_NoMemory();
    }

return Py_BuildValue("s", ret);
}

int _ped_Disk_traverse(_ped_Disk *self, visitproc visit, void *arg) {
    int err;

if (self->dev) {
        if ((err = visit(self->dev, arg))) {
            return err;
        }
    }

if (self->type) {
        if ((err = visit(self->type, arg))) {
            return err;
        }
    }

return 0;
}

int _ped_Disk_clear(_ped_Disk *self) {
    Py_CLEAR(self->dev);
    self->dev = NULL;

Py_CLEAR(self->type);
    self->type = NULL;

return 0;
}

int _ped_Disk_init(_ped_Disk *self, PyObject *args, PyObject *kwds) {
    static char *kwlist[] = {"dev", NULL};
    PedDevice *device = NULL;
    PedDisk *disk = NULL;

if (kwds == NULL) {
        if (!PyArg_ParseTuple(args, "O!", &_ped_Device_Type_obj, &self->dev)) {
            self->dev = NULL;
            return -1;
        }
    } else {
        if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!", kwlist,
                                         &_ped_Device_Type_obj, &self->dev)) {
            self->dev = NULL;
            return -2;
        }
    }

device = _ped_Device2PedDevice(self->dev);
    if (device == NULL) {
        self->dev = NULL;
        return -3;
    }
    disk = ped_disk_new(device);

if (disk == NULL) {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                !PyErr_ExceptionMatches(PyExc_NotImplementedError)) {
                PyErr_SetString(DiskLabelException, partedExnMessage);
            }
        } else {
            PyErr_Format(IOException, "Failed to read partition table from device %s", device->path);
        }

self->dev = NULL;
        return -4;
    }

Py_INCREF(self->dev);

self->type = (PyObject *) PedDiskType2_ped_DiskType((PedDiskType *) disk->type);

self->ped_disk = disk;

return 0;
}

/* _ped.DiskType functions */
void _ped_DiskType_dealloc(_ped_DiskType *self) {
    PyObject_GC_UnTrack(self);
    free(self->name);
    PyObject_GC_Del(self);
}

int _ped_DiskType_compare(_ped_DiskType *self, PyObject *obj) {
    _ped_DiskType *comp = NULL;
    int check = PyObject_IsInstance(obj, (PyObject *) &_ped_DiskType_Type_obj);

if (PyErr_Occurred()) {
        return -1;
    }

if (!check) {
        PyErr_SetString(PyExc_ValueError, "object comparing to must be a _ped.DiskType");
        return -1;
    }

comp = (_ped_DiskType *) obj;
    if ((!strcmp(self->name, comp->name)) &&
        (self->features == comp->features)) {
        return 0;
    } else {
        return 1;
    }
}

PyObject *_ped_DiskType_richcompare(_ped_DiskType *a, PyObject *b, int op) {
    if (op == Py_EQ || op == Py_NE) {
        int rv = _ped_DiskType_compare(a, b);
        if (PyErr_Occurred())
            return NULL;
        return PyBool_FromLong(op == Py_EQ ? rv == 0 : rv != 0);
    } else if ((op == Py_LT) || (op == Py_LE) ||
               (op == Py_GT) || (op == Py_GE)) {
        PyErr_SetString(PyExc_TypeError, "comparison operator not supported for _ped.DiskType");
        return NULL;
    } else {
        PyErr_SetString(PyExc_ValueError, "unknown richcompare op");
        return NULL;
    }
}

PyObject *_ped_DiskType_str(_ped_DiskType *self) {
    char *ret = NULL;

if (asprintf(&ret, "_ped.DiskType instance --\n"
                       "  name: %s  features: %lld",
                 self->name, self->features) == -1) {
        return PyErr_NoMemory();
    }

return Py_BuildValue("s", ret);
}

int _ped_DiskType_traverse(_ped_DiskType *self, visitproc visit, void *arg) {
    return 0;
}

int _ped_DiskType_clear(_ped_DiskType *self) {
    return 0;
}

PyObject *_ped_DiskType_get(_ped_DiskType *self, void *closure) {
    char *member = (char *) closure;

if (member == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.DiskType()");
        return NULL;
    }

if (!strcmp(member, "name")) {
        if (self->name != NULL)
            return PyUnicode_FromString(self->name);
        else
            return PyUnicode_FromString("");
    } else if (!strcmp(member, "features")) {
        return PyLong_FromLong(self->features);
    } else {
        PyErr_Format(PyExc_AttributeError, "_ped.DiskType object has no attribute %s", member);
        return NULL;
    }
}

/* 1:1 function mappings for disk.h in libparted */
PyObject *py_ped_disk_type_get_next(PyObject *s, PyObject *args) {
    PyObject *in_type = NULL;
    PedDiskType *cur = NULL, *next = NULL;
    _ped_DiskType *ret = NULL;

if (!PyArg_ParseTuple(args, "|O!", &_ped_DiskType_Type_obj, &in_type)) {
        return NULL;
    }

if (in_type) {
        cur = _ped_DiskType2PedDiskType(in_type);
        if (!cur) {
            return NULL;
        }
    }

next = ped_disk_type_get_next(cur);
    if (next) {
        ret = PedDiskType2_ped_DiskType(next);
        return (PyObject *) ret;
    } else {
        PyErr_SetNone(PyExc_IndexError);
        return NULL;
    }
}

PyObject *py_ped_disk_type_get(PyObject *s, PyObject *args) {
    char *in_name = NULL;
    PedDiskType *out_type = NULL;
    _ped_DiskType *ret = NULL;

if (!PyArg_ParseTuple(args, "s", &in_name)) {
        return NULL;
    }

if (in_name) {
        out_type = ped_disk_type_get(in_name);

if (out_type == NULL) {
            PyErr_SetString(UnknownTypeException, in_name);
            return NULL;
        }

ret = PedDiskType2_ped_DiskType(out_type);
        if (ret == NULL) {
            return NULL;
        }

}

return (PyObject *) ret;
}

PyObject *py_ped_disk_type_check_feature(PyObject *s, PyObject *args) {
    PedDiskType *disktype = NULL;
    PedDiskTypeFeature feature = -1;
    int ret = 0;

if (!PyArg_ParseTuple(args, "i", &feature)) {
        return NULL;
    }

disktype = _ped_DiskType2PedDiskType(s);
    if (disktype) {
        ret = ped_disk_type_check_feature(disktype, feature);
    }
    else {
        return NULL;
    }

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_disk_clobber(PyObject *s, PyObject *args) {
    PedDevice *device = NULL;
    int ret = 0;

device = _ped_Device2PedDevice(s);
    if (device == NULL)
        return NULL;

ret = ped_disk_clobber(device);
    if (ret == 0) {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                PyErr_SetString(IOException, partedExnMessage);
        }
        else
            PyErr_Format(DiskException, "Failed to clobber partition table on device %s", device->path);

return NULL;
    }

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

/* XXX: is this necessary? */
PyObject *py_ped_disk_duplicate(PyObject *s, PyObject *args) {
    PedDisk *disk = NULL, *pass_disk = NULL;
    _ped_Disk *ret = NULL;

disk = _ped_Disk2PedDisk(s);
    if (disk) {
        pass_disk = ped_disk_duplicate(disk);
        if (pass_disk == NULL) {
            if (partedExnRaised) {
                partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                    !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                    PyErr_SetString(IOException, partedExnMessage);
            }
            else
                PyErr_Format(DiskException, "Could not duplicate device %s", disk->dev->path);

return NULL;
        }

ret = PedDisk2_ped_Disk(pass_disk);
        if (ret == NULL) {
            return NULL;
        }
    }
    else {
        return NULL;
    }

return (PyObject *) ret;
}

/*
 * XXX:
 * We need to call ped_disk_destroy() to make sure the OS-specific
 * free() function is called on the disk.  That flushes buffers,
 * closes handles, arms, and crosschecks and whatnot.
 *
 * Similar to py_ped_device_destroy(), we might move the call to
 * ped_disk_destroy() to the tp_clear() for _ped.Disk.
 */
PyObject *py_ped_disk_destroy(PyObject *s, PyObject *args) {
    PedDisk *disk = NULL;

disk = _ped_Disk2PedDisk(s);
    if (disk == NULL) {
        return NULL;
    }

ped_disk_destroy(disk);
    Py_CLEAR(s);

Py_INCREF(Py_None);
    return Py_None;
}

PyObject *py_ped_disk_commit(PyObject *s, PyObject *args) {
    PedDisk *disk = NULL;
    int ret = 0;

disk = _ped_Disk2PedDisk(s);
    if (disk) {
        ret = ped_disk_commit(disk);
        if (ret == 0) {
            if (partedExnRaised) {
                partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                    !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                    PyErr_SetString(IOException, partedExnMessage);
            }
            else
                PyErr_Format(DiskException, "Could not commit to disk %s, (%s)",
                             disk->dev->path, __func__);

return NULL;
        }
    }
    else {
        return NULL;
    }

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_disk_commit_to_dev(PyObject *s, PyObject *args) {
    PedDisk *disk = NULL;
    int ret = 0;

disk = _ped_Disk2PedDisk(s);
    if (disk) {
        ret = ped_disk_commit_to_dev(disk);
        if (ret == 0) {
            if (partedExnRaised) {
                partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                    !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                    PyErr_SetString(IOException, partedExnMessage);
            }
            else
                PyErr_Format(DiskException, "Could not commit to disk %s, (%s)",
                             disk->dev->path, __func__);

return NULL;
        }
    }
    else {
        return NULL;
    }

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_disk_commit_to_os(PyObject *s, PyObject *args) {
    PedDisk *disk = NULL;
    int ret = 0;

disk = _ped_Disk2PedDisk(s);
    if (disk) {
        ret = ped_disk_commit_to_os(disk);
        if (ret == 0) {
            if (partedExnRaised) {
                partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                    !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                    PyErr_SetString(IOException, partedExnMessage);
            }
            else
                PyErr_Format(DiskException, "Could not commit to disk %s, (%s)",
                             disk->dev->path, __func__);

return NULL;
        }
    }
    else {
        return NULL;
    }

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_disk_check(PyObject *s, PyObject *args) {
    PedDisk *disk = NULL;
    int ret = 0;

disk = _ped_Disk2PedDisk(s);
    if (disk) {
        ret = ped_disk_check(disk);
        if (ret == 0) {
            if (partedExnRaised) {
                partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                    !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                    PyErr_SetString(IOException, partedExnMessage);
            }
            else
                PyErr_Format(DiskException, "Could not check disk %s", disk->dev->path);

return NULL;
        }
    }
    else {
        return NULL;
    }

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_disk_print(PyObject *s, PyObject *args) {
    PedDisk *disk = NULL;

disk = _ped_Disk2PedDisk(s);
    if (disk) {
        ped_disk_print(disk);
    }
    else {
        return NULL;
    }

Py_INCREF(Py_None);
    return Py_None;
}

PyObject *py_ped_disk_get_primary_partition_count(PyObject *s, PyObject *args) {
    PedDisk *disk = NULL;
    int ret = 0;

disk = _ped_Disk2PedDisk(s);
    if (disk) {
        ret = ped_disk_get_primary_partition_count(disk);
    }
    else {
        return NULL;
    }

return PyLong_FromLong(ret);
}

PyObject *py_ped_disk_get_last_partition_num(PyObject *s, PyObject *args) {
    PedDisk *disk = NULL;
    int ret = 0;

disk = _ped_Disk2PedDisk(s);
    if (disk) {
        ret = ped_disk_get_last_partition_num(disk);
    }
    else {
        return NULL;
    }

return PyLong_FromLong(ret);
}

PyObject *py_ped_disk_get_max_primary_partition_count(PyObject *s,
                                                      PyObject *args) {
    PedDisk *disk = NULL;
    int ret = 0;

disk = _ped_Disk2PedDisk(s);
    if (disk) {
        ret = ped_disk_get_max_primary_partition_count(disk);
    }
    else {
        return NULL;
    }

return PyLong_FromLong(ret);
}

PyObject *py_ped_disk_get_max_supported_partition_count(PyObject *s,
                                                        PyObject *args) {
    PedDisk *disk = NULL;
    int max = 0;

disk = _ped_Disk2PedDisk(s);
    if (disk) {
        if (ped_disk_get_max_supported_partition_count(disk, &max) == true) {
            return Py_BuildValue("i", max);
        }
    }

Py_INCREF(Py_None);
    return Py_None;
}

PyObject *py_ped_disk_get_partition_alignment(PyObject *s, PyObject *args) {
    PedDisk *disk = NULL;
    PedAlignment *alignment = NULL;
    _ped_Alignment *ret = NULL;

disk = _ped_Disk2PedDisk(s);
    if (!disk)
        return NULL;

alignment = ped_disk_get_partition_alignment(disk);
    if (!alignment) {
        PyErr_SetString(CreateException, "Could not get alignment for device");
        return NULL;
    }

ret = PedAlignment2_ped_Alignment(alignment);
    ped_alignment_destroy(alignment);

return (PyObject *) ret;
}

PyObject *py_ped_disk_max_partition_length(PyObject *s, PyObject *args) {
    PedDisk *disk = NULL;

disk = _ped_Disk2PedDisk(s);
    if (!disk)
        return NULL;

return PyLong_FromUnsignedLongLong(ped_disk_max_partition_length(disk));
}

PyObject *py_ped_disk_max_partition_start_sector(PyObject *s, PyObject *args) {
    PedDisk *disk = NULL;

disk = _ped_Disk2PedDisk(s);
    if (!disk)
        return NULL;

return PyLong_FromUnsignedLongLong(ped_disk_max_partition_start_sector(disk));
}

PyObject *py_ped_disk_set_flag(PyObject *s, PyObject *args) {
    int ret, flag, state;
    PedDisk *disk = NULL;

if (!PyArg_ParseTuple(args, "ii", &flag, &state)) {
        return NULL;
    }

disk = _ped_Disk2PedDisk(s);
    if (disk == NULL) {
        return NULL;
    }

ret = ped_disk_set_flag(disk, flag, state);
    if (ret == 0) {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                PyErr_SetString(DiskException, partedExnMessage);
        }
        else
            PyErr_Format(DiskException, "Could not set flag on disk %s", disk->dev->path);

return NULL;
    }

Py_RETURN_TRUE;
}

PyObject *py_ped_disk_get_flag(PyObject *s, PyObject *args) {
    int flag;
    PedDisk *disk = NULL;

if (!PyArg_ParseTuple(args, "i", &flag)) {
        return NULL;
    }

disk = _ped_Disk2PedDisk(s);
    if (disk == NULL) {
        return NULL;
    }

if (ped_disk_get_flag(disk, flag)) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_disk_is_flag_available(PyObject *s, PyObject *args) {
    int flag;
    PedDisk *disk = NULL;

if (!PyArg_ParseTuple(args, "i", &flag)) {
        return NULL;
    }

disk = _ped_Disk2PedDisk(s);
    if (disk == NULL) {
        return NULL;
    }

if (ped_disk_is_flag_available(disk, flag)) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_disk_flag_get_name(PyObject *s, PyObject *args) {
    int flag;
    char *ret = NULL;

if (!PyArg_ParseTuple(args, "i", &flag)) {
        return NULL;
    }

if ((flag < PED_DISK_FIRST_FLAG) || (flag > PED_DISK_LAST_FLAG)) {
        PyErr_SetString(PyExc_ValueError, "Invalid flag provided.");
        return NULL;
    }

ret = (char *) ped_disk_flag_get_name(flag);
    if (ret == NULL) {
        if (partedExnRaised) {
            partedExnRaised = 0;

return NULL;
    }

return PyUnicode_FromString(ret);
}

PyObject *py_ped_disk_flag_get_by_name(PyObject *s, PyObject *args) {
    char *name = NULL;

if (!PyArg_ParseTuple(args, "s", &name)) {
        return NULL;
    }

return PyLong_FromLong(ped_disk_flag_get_by_name(name));
}

PyObject *py_ped_disk_flag_next(PyObject *s, PyObject *args) {
    int flag;

if (!PyArg_ParseTuple(args, "i", &flag)) {
        return NULL;
    }

return Py_BuildValue("i", ped_disk_flag_next(flag));
}

/*
 * XXX:
 * We need to call ped_disk_destroy() to make sure the OS-specific
 * free() function is called on the disk.  That flushes buffers,
 * closes handles, arms, and crosschecks and whatnot.
 *
 * Similar to py_ped_device_destroy(), we might move the call to
 * ped_disk_destroy() to the tp_clear() for _ped.Disk.
 */
PyObject *py_ped_partition_destroy(_ped_Partition *s, PyObject *args) {
    PedPartition *partition = NULL;

partition = _ped_Partition2PedPartition(s);
    if (partition == NULL) {
        return NULL;
    }

ped_partition_destroy(partition);
    Py_CLEAR(s);

Py_INCREF(Py_None);
    return Py_None;
}

PyObject *py_ped_partition_is_active(_ped_Partition *s, PyObject *args) {
    PedPartition *partition = NULL;
    int ret = 0;

partition = _ped_Partition2PedPartition(s);
    if (partition) {
        ret = ped_partition_is_active(partition);
    }
    else {
        return NULL;
    }

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_partition_set_flag(_ped_Partition *s, PyObject *args) {
    int in_state = -1;
    PedPartition *part = NULL;
    int flag;
    int ret = 0;

if (!PyArg_ParseTuple(args, "ii", &flag, &in_state)) {
        return NULL;
    }

part = _ped_Partition2PedPartition(s);
    if (part == NULL) {
        return NULL;
    }

if (part && flag && in_state > -1) {
        ret = ped_partition_set_flag(part, flag, in_state);
        if (ret == 0) {
            if (partedExnRaised) {
                partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                    !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                    PyErr_SetString(PartitionException, partedExnMessage);
            }
            else
                PyErr_Format(PartitionException, "Could not set flag on partition %s%d", part->disk->dev->path, part->num);

return NULL;
        }
    }

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_partition_get_flag(_ped_Partition *s, PyObject *args) {
    PedPartition *part = NULL;
    int flag;
    int ret = -1;

if (!PyArg_ParseTuple(args, "i", &flag)) {
        return NULL;
    }

part = _ped_Partition2PedPartition(s);
    if (part == NULL) {
        return NULL;
    }

/* ped_partition_get_flag will assert on this. */
    if (!ped_partition_is_active(part)) {
        PyErr_Format(PartitionException, "Could not get flag on inactive partition %s%d", part->disk->dev->path, part->num);
        return NULL;
    }

ret = ped_partition_get_flag(part, flag);

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_partition_is_flag_available(_ped_Partition *s, PyObject *args) {
    PedPartition *part = NULL;
    int flag;
    int ret = 0;

if (!PyArg_ParseTuple(args, "i", &flag)) {
        return NULL;
    }

part = _ped_Partition2PedPartition(s);
    if (part == NULL) {
        return NULL;
    }

if (!ped_partition_is_active(part)) {
        PyErr_Format(PartitionException, "Flag is not available on inactive partition %s%d", part->disk->dev->path, part->num);
        return NULL;
    }

ret = ped_partition_is_flag_available(part, flag);

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_partition_set_system(_ped_Partition *s, PyObject *args) {
    PyObject *in_fstype = NULL;
    PedPartition *part = NULL;
    PedFileSystemType *out_fstype = NULL;
    int ret = 0;

if (!PyArg_ParseTuple(args, "O!", &_ped_FileSystemType_Type_obj, &in_fstype)) {
        return NULL;
    }

part = _ped_Partition2PedPartition(s);
    if (part == NULL) {
        return NULL;
    }

out_fstype = _ped_FileSystemType2PedFileSystemType(in_fstype);
    if (out_fstype == NULL) {
        return NULL;
    }

/* ped_partition_set_system will assert on this. */
    if (!ped_partition_is_active(part)) {
        PyErr_Format(PartitionException, "Could not set system flag on inactive partition %s%d", part->disk->dev->path, part->num);
        return NULL;
    }

ret = ped_partition_set_system(part, out_fstype);
    if (ret == 0) {
        PyErr_Format(PartitionException, "Could not set system flag on partition %s%d", part->disk->dev->path, part->num);
        return NULL;
    }

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_partition_set_name(_ped_Partition *s, PyObject *args) {
    PedPartition *part = NULL;
    char *in_name = NULL;
    int ret = 0;

if (!PyArg_ParseTuple(args, "s", &in_name)) {
        return NULL;
    }

part = _ped_Partition2PedPartition(s);
    if (part == NULL) {
        return NULL;
    }

/* ped_partition_set_name will assert on this. */
    if (!ped_partition_is_active(part)) {
        PyErr_Format(PartitionException, "Could not set system flag on inactive partition %s%d", part->disk->dev->path, part->num);
        return NULL;
    }

if (part) {
        ret = ped_partition_set_name(part, in_name);
        if (ret == 0) {
            if (partedExnRaised) {
                partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                    !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                    PyErr_SetString(PartitionException, partedExnMessage);
            }
            else
                PyErr_Format(PartitionException, "Could not set name on partition %s%d", part->disk->dev->path, part->num);

return NULL;
        }
    }
    else {
        return NULL;
    }

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_partition_get_name(_ped_Partition *s, PyObject *args) {
    PedPartition *part = NULL;
    char *ret = NULL;

part = _ped_Partition2PedPartition(s);
    if (part == NULL) {
        return NULL;
    }

/* ped_partition_get_name will assert on this. */
    if (!ped_partition_is_active(part)) {
        PyErr_Format(PartitionException, "Could not get name on inactive partition %s%d", part->disk->dev->path, part->num);
        return NULL;
    }

if (part) {
        ret = (char *) ped_partition_get_name(part);
        if (ret == NULL) {
            if (partedExnRaised) {
                partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                    !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                    PyErr_SetString(PartitionException, partedExnMessage);
            }
            else
                PyErr_Format(PartitionException, "Could not read name on partition %s%d", part->disk->dev->path, part->num);

return NULL;
        }
    }
    else {
        return NULL;
    }

return PyUnicode_FromString(ret);
}

PyObject *py_ped_partition_is_busy(_ped_Partition *s, PyObject *args) {
    PedPartition *part = NULL;
    int ret = 0;

part = _ped_Partition2PedPartition(s);
    if (part) {
        ret = ped_partition_is_busy(part);
    }
    else {
        return NULL;
    }

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_partition_get_path(_ped_Partition *s, PyObject *args) {
    PedPartition *part = NULL;
    char *ret = NULL;

part = _ped_Partition2PedPartition(s);
    if (part) {
        ret = ped_partition_get_path(part);
        if (ret == NULL) {
            PyErr_Format(PartitionException, "Could not get path for partition %s%d", part->disk->dev->path, part->num);
            return NULL;
        }
    }
    else {
        return NULL;
    }

return PyUnicode_FromString(ret);
}

PyObject *py_ped_partition_reset_num(_ped_Partition *s, PyObject *args) {
    PedPartition *part = NULL;

part = _ped_Partition2PedPartition(s);
    if (part == NULL) {
        Py_RETURN_FALSE;
    }

part->num = -1;

Py_RETURN_TRUE;
}

PyObject *py_ped_partition_type_get_name(PyObject *s, PyObject *args) {
    long type;
    char *ret = NULL;

if (!PyArg_ParseTuple(args, "i", &type)) {
        return NULL;
    }

if (type) {
        ret = (char *) ped_partition_type_get_name(type);
    }

if (ret != NULL)
        return PyUnicode_FromString(ret);
    else
        return PyUnicode_FromString("");
}

PyObject *py_ped_partition_flag_get_name(PyObject *s, PyObject *args) {
    int flag;
    char *ret = NULL;

if (!PyArg_ParseTuple(args, "i", &flag)) {
        return NULL;
    }

if ((flag < PED_PARTITION_FIRST_FLAG) || (flag > PED_PARTITION_LAST_FLAG)) {
        PyErr_SetString(PyExc_ValueError, "Invalid flag provided.");
        return NULL;
    }

if (flag) {
        ret = (char *) ped_partition_flag_get_name(flag);

if (!ret) {
            /* Re-raise the libparted exception. */
            partedExnRaised = 0;
            return NULL;
        }
    }

return PyUnicode_FromString(ret);
}

PyObject *py_ped_partition_flag_get_by_name(PyObject *s, PyObject *args) {
    char *name = NULL;

if (!PyArg_ParseTuple(args, "s", &name)) {
        return NULL;
    }

return PyLong_FromLong(ped_partition_flag_get_by_name(name));
}

PyObject *py_ped_partition_flag_next(PyObject *s, PyObject *args) {
    int flag;

if (!PyArg_ParseTuple(args, "i", &flag)) {
        return NULL;
    }

return Py_BuildValue("i", ped_partition_flag_next(flag));
}

PyObject *py_ped_disk_add_partition(PyObject *s, PyObject *args) {
    _ped_Partition *in_part = NULL;
    PyObject *in_constraint = NULL;
    PedDisk *disk = NULL;
    PedPartition *out_part = NULL;
    PedConstraint *out_constraint = NULL;
    int ret = 0;

if (!PyArg_ParseTuple(args, "O!|O!",&_ped_Partition_Type_obj,
                          &in_part, &_ped_Constraint_Type_obj, &in_constraint)) {
        return NULL;
    }

disk = _ped_Disk2PedDisk(s);
    if (disk == NULL) {
        return NULL;
    }

/* Its non-sense to add an owned partition */
    if (in_part->_owned == 1) {
        PyErr_SetString(PartitionException, "Attempting to add a partition "
                                            "that is already owned by a disk.");
        return NULL;
    }

out_part = _ped_Partition2PedPartition(in_part);
    if (out_part == NULL) {
        return NULL;
    }

if (out_part->disk != disk) {
        PyErr_SetString(PartitionException, "Cannot add a partition to another disk then the one used for creating the partition");
        return NULL;
    }

if (in_constraint) {
        out_constraint = _ped_Constraint2PedConstraint(in_constraint);
        if (out_constraint == NULL) {
            return NULL;
        }
    }

ret = ped_disk_add_partition(disk, out_part, out_constraint);

if (out_constraint)
        ped_constraint_destroy(out_constraint);

if (ret == 0) {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                PyErr_SetString(PartitionException, partedExnMessage);
        }
        else
            PyErr_Format(PartitionException, "Could not create partition %s%d", out_part->disk->dev->path, out_part->num);

return NULL;
    }

/* update our _ped.Partition object with out_part values */
    in_part->type = out_part->type;
    in_part->_owned = 1;
    *((_ped_Geometry *)in_part->geom)->ped_geometry = out_part->geom;

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_disk_remove_partition(PyObject *s, PyObject *args) {
    _ped_Partition *in_part = NULL;
    PedDisk *disk = NULL;
    PedPartition *out_part = NULL;
    int ret = 0;

if (!PyArg_ParseTuple(args, "O!", &_ped_Partition_Type_obj, &in_part)) {
        return NULL;
    }

disk = _ped_Disk2PedDisk(s);
    if (disk == NULL) {
        return NULL;
    }

/* Its non-sense  to remove an unowned partition */
    if (in_part->_owned == 0) {
        PyErr_SetString(PartitionException, "Attempting to remove a partition "
                                            "that is not owned by any disk.");
        return NULL;
    }

out_part = _ped_Partition2PedPartition(in_part);
    if (out_part == NULL) {
        return NULL;
    }

if (out_part->disk != disk) {
        PyErr_SetString(PartitionException, "Partition is not part of the disk it is being removed from");
        return NULL;
    }

if (out_part->part_list != NULL) {
        PedPartition *part;
        for (part = out_part->part_list; part; part = part->next) {
            if (ped_partition_is_active(part))
                break;
        }
        if (part) {
            PyErr_SetString(PartitionException, "Attempting to remove an extended partition that still contains logical partitions");
            return NULL;
        }
    }

ret = ped_disk_remove_partition(disk, out_part);
    if (ret == 0) {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                PyErr_SetString(PartitionException, partedExnMessage);
        }
        else
            PyErr_Format(PartitionException, "Could not remove partition %s%d", out_part->disk->dev->path, out_part->num);

return NULL;
    }

in_part->_owned = 0;

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_disk_delete_partition(PyObject *s, PyObject *args) {
    return py_ped_disk_remove_partition(s, args);
}

PyObject *py_ped_disk_delete_all(PyObject *s, PyObject *args) {
    PedDisk *disk = NULL;
    int ret = 0;

disk = _ped_Disk2PedDisk(s);
    if (disk) {
        ret = ped_disk_delete_all(disk);
        if (ret == 0) {
            if (partedExnRaised) {
                partedExnRaised = 0;

return NULL;
        }
    }
    else {
        return NULL;
    }

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_disk_set_partition_geom(PyObject *s, PyObject *args) {
    _ped_Partition *in_part = NULL;
    PyObject *in_constraint = NULL;
    PedDisk *disk = NULL;
    PedPartition *out_part = NULL;
    PedConstraint *out_constraint = NULL;
    PedSector start, end;
    int ret = 0;

if (!PyArg_ParseTuple(args, "O!OLL", &_ped_Partition_Type_obj, &in_part,
                          &in_constraint, &start, &end)) {
        return NULL;
    }

if (in_constraint != Py_None && !PyObject_IsInstance(in_constraint,
                                      (PyObject *)&_ped_Constraint_Type_obj)) {
        PyErr_SetString(PyExc_ValueError, "invalid constraint type");
        return NULL;
    }

disk = _ped_Disk2PedDisk(s);
    if (disk == NULL) {
        return NULL;
    }

out_part = _ped_Partition2PedPartition(in_part);
    if (out_part == NULL) {
        return NULL;
    }

if (out_part->disk != disk) {
        PyErr_SetString(PartitionException, "partition.disk does not match disk");
        return NULL;
    }

if (in_constraint != Py_None) {
        out_constraint = _ped_Constraint2PedConstraint(in_constraint);
        if (out_constraint == NULL) {
            return NULL;
        }
    }

ret = ped_disk_set_partition_geom(disk, out_part, out_constraint,
                                      start, end);

if (out_constraint)
        ped_constraint_destroy(out_constraint);

if (ret == 0) {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                PyErr_SetString(PartitionException, partedExnMessage);
        }
        else
            PyErr_Format(PartitionException, "Could not set geometry on %s%d", disk->dev->path, out_part->num);

return NULL;
    }

*((_ped_Geometry *)in_part->geom)->ped_geometry = out_part->geom;

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_disk_maximize_partition(PyObject *s, PyObject *args) {
    _ped_Partition *in_part = NULL;
    PyObject *in_constraint = NULL;
    PedDisk *disk = NULL;
    PedPartition *out_part = NULL;
    PedConstraint *out_constraint = NULL;
    int ret = 0;

if (!PyArg_ParseTuple(args, "O!|O!", &_ped_Partition_Type_obj, &in_part,
                          &_ped_Constraint_Type_obj, &in_constraint)) {
        return NULL;
    }

disk = _ped_Disk2PedDisk(s);
    if (disk == NULL) {
        return NULL;
    }

out_part = _ped_Partition2PedPartition(in_part);
    if (out_part == NULL) {
        return NULL;
    }

if (out_part->disk != disk) {
        PyErr_SetString(PartitionException, "partition.disk does not match disk");
        return NULL;
    }

if (in_constraint) {
        out_constraint = _ped_Constraint2PedConstraint(in_constraint);
        if (out_constraint == NULL) {
            return NULL;
        }
    }

ret = ped_disk_maximize_partition(disk, out_part, out_constraint);

if (out_constraint)
        ped_constraint_destroy(out_constraint);

if (ret == 0) {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                PyErr_SetString(PartitionException, partedExnMessage);
        }
        else
            PyErr_Format(PartitionException, "Could not maximize partition size for %s%d", disk->dev->path, out_part->num);

return NULL;
    }

*((_ped_Geometry *)in_part->geom)->ped_geometry = out_part->geom;

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_disk_get_max_partition_geometry(PyObject *s, PyObject *args) {
    _ped_Partition *in_part = NULL;
    PyObject *in_constraint = NULL;
    PedDisk *disk = NULL;
    PedPartition *out_part = NULL;
    PedConstraint *out_constraint = NULL;
    PedGeometry *pass_geom = NULL;
    _ped_Geometry *ret = NULL;

if (!PyArg_ParseTuple(args, "O!|O!", &_ped_Partition_Type_obj, &in_part,
                          &_ped_Constraint_Type_obj, &in_constraint)) {
        return NULL;
    }

disk = _ped_Disk2PedDisk(s);
    if (disk == NULL) {
        return NULL;
    }

out_part = _ped_Partition2PedPartition(in_part);
    if (out_part == NULL) {
        return NULL;
    }

if (out_part->disk != disk) {
        PyErr_SetString(PartitionException, "partition.disk does not match disk");
        return NULL;
    }

if (in_constraint) {
        out_constraint = _ped_Constraint2PedConstraint(in_constraint);
        if (out_constraint == NULL) {
            return NULL;
        }
    }

pass_geom = ped_disk_get_max_partition_geometry(disk, out_part,
                                                    out_constraint);
    if (out_constraint)
        ped_constraint_destroy(out_constraint);

if (pass_geom == NULL) {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                PyErr_SetString(PartitionException, partedExnMessage);
        }
        else
            PyErr_Format(PartitionException, "Could not get maximum partition size for %s%d", disk->dev->path, out_part->num);

return NULL;
    }

ret = PedGeometry2_ped_Geometry(pass_geom);
    if (ret == NULL) {
        return NULL;
    }

return (PyObject *) ret;
}

PyObject *py_ped_disk_minimize_extended_partition(PyObject *s, PyObject *args) {
    PedDisk *disk = NULL;
    int ret = 0;

disk = _ped_Disk2PedDisk(s);
    if (disk) {
        ret = ped_disk_minimize_extended_partition(disk);
        if (ret == 0) {
            if (partedExnRaised) {
                partedExnRaised = 0;

return NULL;
        }
    }
    else {
        return NULL;
    }

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_disk_next_partition(PyObject *s, PyObject *args) {
    _ped_Partition *in_part = NULL;
    PedDisk *disk = NULL;
    PedPartition *out_part = NULL;
    PedPartition *pass_part = NULL;
    _ped_Partition *ret = NULL;

if (!PyArg_ParseTuple(args, "|O!", &_ped_Partition_Type_obj, &in_part)) {
        return NULL;
    }

disk = _ped_Disk2PedDisk(s);
    if (disk == NULL) {
        return NULL;
    }

if (in_part) {
        out_part = _ped_Partition2PedPartition(in_part);
        if (out_part == NULL) {
            return NULL;
        }

if (out_part->disk != disk) {
            PyErr_SetString(PartitionException, "partition.disk does not match disk");
            return NULL;
        }
    }

pass_part = ped_disk_next_partition(disk, out_part);
    if (pass_part == NULL) {
        Py_INCREF(Py_None);
        return Py_None;
    }

ret = PedPartition2_ped_Partition(pass_part, (_ped_Disk *)s);
    if (ret == NULL) {
        return NULL;
    }

ret->_owned = 1;
    return (PyObject *) ret;
}

PyObject *py_ped_disk_get_partition(PyObject *s, PyObject *args) {
    int num;
    PedDisk *disk = NULL;
    PedPartition *pass_part = NULL;
    _ped_Partition *ret = NULL;

if (!PyArg_ParseTuple(args, "i", &num)) {
        return NULL;
    }

disk = _ped_Disk2PedDisk(s);
    if (disk) {
        pass_part = ped_disk_get_partition(disk, num);
        if (pass_part == NULL) {
            PyErr_SetString(PartitionException, "Partition does not exist");
            return NULL;
        }

ret = PedPartition2_ped_Partition(pass_part, (_ped_Disk *)s);
        if (ret == NULL) {
            return NULL;
        }
    }
    else {
        return NULL;
    }

ret->_owned = 1;
    return (PyObject *) ret;
}

PyObject *py_ped_disk_get_partition_by_sector(PyObject *s, PyObject *args) {
    PedDisk *disk = NULL;
    PedSector sector;
    PedPartition *pass_part = NULL;
    _ped_Partition *ret = NULL;

if (!PyArg_ParseTuple(args, "L", &sector)) {
        return NULL;
    }

disk = _ped_Disk2PedDisk(s);
    if (disk == NULL) {
        return NULL;
    }

pass_part = ped_disk_get_partition_by_sector(disk, sector);
    if (pass_part == NULL) {
        PyErr_SetString(PartitionException, "Partition does not exist");
        return NULL;
    }

ret = PedPartition2_ped_Partition(pass_part, (_ped_Disk *)s);
    if (ret == NULL) {
        return NULL;
    }

ret->_owned = 1;
    return (PyObject *) ret;
}

PyObject *py_ped_disk_extended_partition(PyObject *s, PyObject *args) {
    PedDisk *disk = NULL;
    PedPartition *pass_part = NULL;
    _ped_Partition *ret = NULL;

disk = _ped_Disk2PedDisk(s);
    if (disk) {
        pass_part = ped_disk_extended_partition(disk);
        if (pass_part == NULL) {
            PyErr_SetString(PartitionException, "Extended partition does not exist");
            return NULL;
        }

ret = PedPartition2_ped_Partition(pass_part, (_ped_Disk *)s);
        if (ret == NULL) {
            return NULL;
        }
    }
    else {
        return NULL;
    }

ret->_owned = 1;
    return (PyObject *) ret;
}

PyObject *py_ped_disk_new_fresh(PyObject *s, PyObject *args) {
    _ped_Device *in_device = NULL;
    _ped_DiskType *in_type = NULL;
    PedDevice *device = NULL;
    PedDiskType *type = NULL;
    PedDisk *disk = NULL;
    _ped_Disk *ret = NULL;

if (!PyArg_ParseTuple(args, "O!O!", &_ped_Device_Type_obj, &in_device,
                                        &_ped_DiskType_Type_obj, &in_type)) {
        return NULL;
    }

if ((device = _ped_Device2PedDevice((PyObject *) in_device)) == NULL) {
        return NULL;
    }

if ((type = _ped_DiskType2PedDiskType((PyObject *) in_type)) == NULL) {
        return NULL;
    }

if ((disk = ped_disk_new_fresh(device, type)) == NULL) {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                PyErr_SetString(DiskException, partedExnMessage);
        } else {
            PyErr_Format(DiskException, "Could not create new disk label on %s", disk->dev->path);
        }

return NULL;
    }

ret = PedDisk2_ped_Disk(disk);
    return (PyObject *) ret;
}

PyObject *py_ped_disk_new(PyObject *s, PyObject *args) {
    _ped_Device *in_device = NULL;
    PedDevice *device = NULL;
    PedDisk *disk = NULL;
    _ped_Disk *ret = NULL;

if (!PyArg_ParseTuple(args, "O!", &_ped_Device_Type_obj, &in_device)) {
        return NULL;
    }

if ((device = _ped_Device2PedDevice((PyObject *) in_device)) == NULL) {
        return NULL;
    }

if ((disk = ped_disk_new(device)) == NULL) {
        if (partedExnRaised) {
            partedExnRaised = 0;

return NULL;
    }

ret = PedDisk2_ped_Disk(disk);
    return (PyObject *) ret;
}

/* vim:tw=78:ts=4:et:sw=4
 */
07070100115839000081A40000FFFE0000FFFD0000000157CD697A000064BA000000FC0000001000000000000000000000002B00000000pyparted-1466619794.7a0f829/src/pydevice.c/*
 * pydevice.c
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Chris Lumens <clumens@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#include <Python.h>

#include "convert.h"
#include "exceptions.h"
#include "pyconstraint.h"
#include "pydevice.h"
#include "docstrings/pydevice.h"
#include "typeobjects/pydevice.h"

/* _ped.CHSGeometry functions */
void _ped_CHSGeometry_dealloc(_ped_CHSGeometry *self) {
    PyObject_GC_UnTrack(self);
    PyObject_GC_Del(self);
}

int _ped_CHSGeometry_compare(_ped_CHSGeometry *self, PyObject *obj) {
    _ped_CHSGeometry *comp = NULL;
    int check = PyObject_IsInstance(obj, (PyObject *) &_ped_CHSGeometry_Type_obj);

if (PyErr_Occurred()) {
        return -1;
    }

if (!check) {
        PyErr_SetString(PyExc_ValueError, "object comparing to must be a _ped.CHSGeometry");
        return -1;
    }

comp = (_ped_CHSGeometry *) obj;
    if ((self->cylinders == comp->cylinders) &&
        (self->heads == comp->heads) &&
        (self->sectors == comp->sectors)) {
        return 0;
    } else {
        return 1;
    }
}

PyObject *_ped_CHSGeometry_richcompare(_ped_CHSGeometry *a, PyObject *b,
                                       int op) {
    if (op == Py_EQ || op == Py_NE) {
        int rv = _ped_CHSGeometry_compare(a, b);
        if (PyErr_Occurred())
            return NULL;
        return PyBool_FromLong(op == Py_EQ ? rv == 0 : rv != 0);
    } else if ((op == Py_LT) || (op == Py_LE) ||
               (op == Py_GT) || (op == Py_GE)) {
        PyErr_SetString(PyExc_TypeError, "comparison operator not supported for _ped.CHSGeometry");
        return NULL;
    } else {
        PyErr_SetString(PyExc_ValueError, "unknown richcompare op");
        return NULL;
    }
}

PyObject *_ped_CHSGeometry_str(_ped_CHSGeometry *self) {
    char *ret = NULL;

if (asprintf(&ret, "_ped.CHSGeometry instance --\n"
                       "  cylinders: %d  heads: %d  sectors: %d",
                 self->cylinders, self->heads, self->sectors) == -1) {
        return PyErr_NoMemory();
    }

return Py_BuildValue("s", ret);
}

int _ped_CHSGeometry_traverse(_ped_CHSGeometry *self, visitproc visit, void *arg) {
    return 0;
}

int _ped_CHSGeometry_clear(_ped_CHSGeometry *self) {
    return 0;
}

PyObject *_ped_CHSGeometry_get(_ped_CHSGeometry *self, void *closure) {
    char *member = (char *) closure;

if (member == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.CHSGeometry()");
        return NULL;
    }

if (!strcmp(member, "cylinders")) {
        return Py_BuildValue("i", self->cylinders);
    } else if (!strcmp(member, "heads")) {
        return Py_BuildValue("i", self->heads);
    } else if (!strcmp(member, "sectors")) {
        return Py_BuildValue("i", self->sectors);
    } else {
        PyErr_Format(PyExc_AttributeError, "_ped.CHSGeometry object has no attribute %s", member);
        return NULL;
    }
}

/* _ped.Device functions */
void _ped_Device_dealloc(_ped_Device *self) {
    PyObject_GC_UnTrack(self);

free(self->model);
    free(self->path);

Py_CLEAR(self->hw_geom);
    self->hw_geom = NULL;

Py_CLEAR(self->bios_geom);
    self->bios_geom = NULL;

PyObject_GC_Del(self);
}

int _ped_Device_compare(_ped_Device *self, PyObject *obj) {
    _ped_Device *comp = NULL;
    int check = PyObject_IsInstance(obj, (PyObject *) &_ped_Device_Type_obj);

if (PyErr_Occurred()) {
        return -1;
    }

if (!check) {
        PyErr_SetString(PyExc_ValueError, "object comparing to must be a _ped.Device");
        return -1;
    }

comp = (_ped_Device *) obj;
    if ((!strcmp(self->model, comp->model)) &&
        (!strcmp(self->path, comp->path)) &&
        (self->type == comp->type) &&
        (self->sector_size == comp->sector_size) &&
        (self->phys_sector_size == comp->phys_sector_size) &&
        (self->length == comp->length) &&
        (self->open_count == comp->open_count) &&
        (self->read_only == comp->read_only) &&
        (self->external_mode == comp->external_mode) &&
        (self->dirty == comp->dirty) &&
        (self->boot_dirty == comp->dirty) &&
        (_ped_CHSGeometry_Type_obj.tp_richcompare(self->hw_geom, comp->hw_geom, Py_EQ)) &&
        (_ped_CHSGeometry_Type_obj.tp_richcompare(self->bios_geom, comp->bios_geom, Py_EQ)) &&
        (self->host == comp->host) &&
        (self->did == comp->did)) {
        return 0;
    } else {
        return 1;
    }
}

PyObject *_ped_Device_richcompare(_ped_Device *a, PyObject *b, int op) {
    if (op == Py_EQ || op == Py_NE) {
        int rv = _ped_Device_compare(a, b);
        if (PyErr_Occurred())
            return NULL;
        return PyBool_FromLong(op == Py_EQ ? rv == 0 : rv != 0);
    } else if ((op == Py_LT) || (op == Py_LE) ||
               (op == Py_GT) || (op == Py_GE)) {
        PyErr_SetString(PyExc_TypeError, "comparison operator not supported for _ped.Device");
        return NULL;
    } else {
        PyErr_SetString(PyExc_ValueError, "unknown richcompare op");
        return NULL;
    }
}

PyObject *_ped_Device_str(_ped_Device *self) {
    char *ret = NULL;
    char *hw_geom = NULL, *bios_geom = NULL;

hw_geom = PyUnicode_AsUTF8(_ped_CHSGeometry_Type_obj.tp_repr(self->hw_geom));
    if (hw_geom == NULL) {
        return NULL;
    }

bios_geom = PyUnicode_AsUTF8(_ped_CHSGeometry_Type_obj.tp_repr(self->bios_geom));
    if (bios_geom == NULL) {
        return NULL;
    }

if (asprintf(&ret, "_ped.Device instance --\n"
                       "  model: %s  path: %s  type: %lld\n"
                       "  sector_size: %lld  phys_sector_size: %lld\n"
                       "  length: %lld  open_count: %d  read_only: %d\n"
                       "  external_mode: %d  dirty: %d  boot_dirty: %d\n"
                       "  host: %hd  did: %hd\n"
                       "  hw_geom: %s  bios_geom: %s",
                 self->model, self->path, self->type,
                 self->sector_size, self->phys_sector_size,
                 self->length, self->open_count, self->read_only,
                 self->external_mode, self->dirty, self->boot_dirty,
                 self->host, self->did,
                 hw_geom, bios_geom) == -1) {
        return PyErr_NoMemory();
    }

return Py_BuildValue("s", ret);
}

int _ped_Device_traverse(_ped_Device *self, visitproc visit, void *arg) {
    int err;

if (self->hw_geom) {
        if ((err = visit(self->hw_geom, arg))) {
            return err;
        }
    }

if (self->bios_geom) {
        if ((err = visit(self->bios_geom, arg))) {
            return err;
        }
    }

return 0;
}

int _ped_Device_clear(_ped_Device *self) {
    Py_CLEAR(self->hw_geom);
    self->hw_geom = NULL;

Py_CLEAR(self->bios_geom);
    self->bios_geom = NULL;

return 0;
}

PyObject *_ped_Device_get(_ped_Device *self, void *closure) {
    char *member = (char *) closure;

if (member == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.Device()");
        return NULL;
    }

if (!strcmp(member, "model")) {
        if (self->model != NULL)
            return PyUnicode_FromString(self->model);
        else
            return PyUnicode_FromString("");
    } else if (!strcmp(member, "path")) {
        if (self->path != NULL)
            return PyUnicode_FromString(self->path);
        else
            return PyUnicode_FromString("");
    } else if (!strcmp(member, "type")) {
        return PyLong_FromLong(self->type);
    } else if (!strcmp(member, "sector_size")) {
        return PyLong_FromLongLong(self->sector_size);
    } else if (!strcmp(member, "phys_sector_size")) {
        return PyLong_FromLongLong(self->phys_sector_size);
    } else if (!strcmp(member, "length")) {
        return PyLong_FromLongLong(self->length);
    } else if (!strcmp(member, "open_count")) {
        return Py_BuildValue("i", self->open_count);
    } else if (!strcmp(member, "read_only")) {
        return Py_BuildValue("i", self->read_only);
    } else if (!strcmp(member, "external_mode")) {
        return Py_BuildValue("i", self->external_mode);
    } else if (!strcmp(member, "dirty")) {
        return Py_BuildValue("i", self->dirty);
    } else if (!strcmp(member, "boot_dirty")) {
        return Py_BuildValue("i", self->boot_dirty);
    } else if (!strcmp(member, "host")) {
        return Py_BuildValue("h", self->host);
    } else if (!strcmp(member, "did")) {
        return Py_BuildValue("h", self->did);
    } else {
        PyErr_Format(PyExc_AttributeError, "_ped.Device object has no attribute %s", member);
        return NULL;
    }
}

/*
 * Returns the _ped.DiskType for the specified _ped.Device.
 * Even though this function is part of pydisk.c, it's a method
 * on _ped.Device since it operates on _ped.Device objects and
 * not on _ped.Disk objects.
 */
PyObject *py_ped_disk_probe(PyObject *s, PyObject *args) {
    PedDevice *device = NULL;
    PedDiskType *type = NULL;
    _ped_DiskType *ret = NULL;

device = _ped_Device2PedDevice(s);
    if (device) {
        type = ped_disk_probe(device);
        if (type == NULL) {
            PyErr_Format(IOException, "Could not probe device %s", device->path);
            return NULL;
        }

ret = PedDiskType2_ped_DiskType(type);
        if (ret == NULL) {
            return NULL;
        }
    }

return (PyObject *) ret;
}

/* 1:1 function mappings for device.h in libparted */
PyObject *py_ped_device_probe_all(PyObject *s, PyObject *args)  {
    ped_device_probe_all();

Py_INCREF(Py_None);
    return Py_None;
}

PyObject *py_ped_device_free_all(PyObject *s, PyObject *args) {
    ped_device_free_all();

Py_INCREF(Py_None);
    return Py_None;
}

PyObject *py_ped_device_get(PyObject *s, PyObject *args) {
    PedDevice *device = NULL;
    _ped_Device *ret = NULL;
    char *path = NULL;

if (!PyArg_ParseTuple(args, "z", &path)) {
        return NULL;
    }

if (path == NULL) {
        PyErr_Format(DeviceException, "Could not find device for empty path");
        return NULL;
    }

device = ped_device_get(path);
    if (device) {
        ret = PedDevice2_ped_Device(device);
    }
    else {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                PyErr_SetString(IOException, partedExnMessage);
        }
        else
            PyErr_Format(DeviceException, "Could not find device for path %s", path);

return NULL;
    }

return (PyObject *) ret;
}

PyObject *py_ped_device_get_next(PyObject *s, PyObject *args) {
    PyObject *in_device = NULL;
    PedDevice *cur = NULL, *next = NULL;
    _ped_Device *ret = NULL;

if (!PyArg_ParseTuple(args, "|O!", &_ped_Device_Type_obj, &in_device)) {
        return NULL;
    }

if (in_device) {
        cur = _ped_Device2PedDevice(in_device);
        if (!cur) {
            return NULL;
        }
    }

next = ped_device_get_next(cur);
    if (next) {
        ret = PedDevice2_ped_Device(next);
        return (PyObject *) ret;
    }
    else {
        PyErr_SetNone(PyExc_IndexError);
        return NULL;
    }
}

PyObject *py_ped_device_is_busy(PyObject *s, PyObject *args) {
    int ret = -1;
    PedDevice *device = NULL;

device = _ped_Device2PedDevice(s);
    if (device == NULL) {
        return NULL;
    }

ret = ped_device_is_busy(device);

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_device_open(PyObject *s, PyObject *args) {
    int ret = -1;
    PedDevice *device = NULL;

device = _ped_Device2PedDevice(s);
    if (device == NULL) {
        return NULL;
    }

if (device->external_mode) {
        PyErr_Format(IOException, "Device %s is already open for external access.", device->path);
        return NULL;
    }

ret = ped_device_open(device);
    if (ret == 0) {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                PyErr_SetString(IOException, partedExnMessage);
        }
        else
            PyErr_Format(IOException, "Could not open device %s", device->path);

return NULL;
    }

((_ped_Device *) s)->open_count = device->open_count;

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_device_close(PyObject *s, PyObject *args) {
    int ret = -1;
    PedDevice *device = NULL;

device = _ped_Device2PedDevice(s);
    if (device == NULL) {
        return NULL;
    }

if (!device->open_count) {
        PyErr_Format(IOException, "Device %s is not open.", device->path);
        return NULL;
    }

if (device->external_mode) {
        PyErr_Format(IOException, "Device %s is already open for external access.", device->path);
        return NULL;
    }

ret = ped_device_close(device);
    if (ret == 0) {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                PyErr_SetString(IOException, partedExnMessage);
        }
        else
            PyErr_Format(IOException, "Could not close device %s", device->path);

return NULL;
    }

((_ped_Device *) s)->open_count = device->open_count;

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_device_destroy(PyObject *s, PyObject *args) {
    _ped_Device *dev = (_ped_Device *) s;
    PedDevice *device = NULL;

device = _ped_Device2PedDevice(s);
    if (device == NULL) {
        return NULL;
    }

ped_device_destroy(device);

Py_CLEAR(dev->hw_geom);
    dev->hw_geom = NULL;

Py_CLEAR(dev->bios_geom);
    dev->bios_geom = NULL;

Py_CLEAR(dev);

Py_INCREF(Py_None);
    return Py_None;
}

PyObject *py_ped_device_cache_remove(PyObject *s, PyObject *args) {
    PedDevice *device = NULL;

device = _ped_Device2PedDevice(s);
    if (device == NULL) {
        return NULL;
    }

ped_device_cache_remove(device);

Py_INCREF(Py_None);
    return Py_None;
}

PyObject *py_ped_device_begin_external_access(PyObject *s, PyObject *args) {
    int ret = -1;
    PedDevice *device = NULL;

device = _ped_Device2PedDevice(s);
    if (device == NULL) {
        return NULL;
    }

if (device->external_mode) {
        PyErr_Format(IOException, "Device %s is already open for external access.", device->path);
        return NULL;
    }

ret = ped_device_begin_external_access(device);
    if (ret == 0) {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                PyErr_SetString(IOException, partedExnMessage);
        }
        else
            PyErr_Format(IOException, "Could not begin external access mode on device %s", device->path);

return NULL;
    }

((_ped_Device *) s)->external_mode = device->external_mode;

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_device_end_external_access(PyObject *s, PyObject *args) {
    int ret = -1;
    PedDevice *device = NULL;

device = _ped_Device2PedDevice(s);
    if (device == NULL) {
        return NULL;
    }

if (!device->external_mode) {
        PyErr_Format(IOException, "Device %s is not open for external access.", device->path);
        return NULL;
    }

ret = ped_device_end_external_access(device);
    if (ret == 0) {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                PyErr_SetString(IOException, partedExnMessage);
        }
        else
            PyErr_Format(IOException, "Could not end external access mode on device %s", device->path);

return NULL;
    }

((_ped_Device *) s)->external_mode = device->external_mode;

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_device_read(PyObject *s, PyObject *args) {
    PyObject *ret = NULL;
    PedSector start, count;
    PedDevice *device = NULL;
    char *out_buf = NULL;

if (!PyArg_ParseTuple(args, "LL", &start, &count)) {
        return NULL;
    }

device = _ped_Device2PedDevice(s);
    if (device == NULL) {
        return NULL;
    }

if (!device->open_count) {
        PyErr_Format(IOException, "Device %s is not open.", device->path);
        return NULL;
    }

if (device->external_mode) {
        PyErr_Format(IOException, "Device %s is already open for external access.", device->path);
        return NULL;
    }

if ((out_buf = malloc(device->sector_size * count)) == NULL) {
        return PyErr_NoMemory();
    }

if (ped_device_read(device, out_buf, start, count) == 0) {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                PyErr_SetString(IOException, partedExnMessage);
        }
        else
            PyErr_Format(IOException, "Could not read from device %s", device->path);

free(out_buf);
        return NULL;
    }

ret = PyUnicode_FromString(out_buf);
    free(out_buf);

return ret;
}

PyObject *py_ped_device_write(PyObject *s, PyObject *args) {
    PyObject *in_buf = NULL;
    PedSector start, count, ret;
    PedDevice *device = NULL;
    void *out_buf = NULL;

if (!PyArg_ParseTuple(args, "OLL", &in_buf, &start, &count)) {
        return NULL;
    }

device = _ped_Device2PedDevice(s);
    if (device == NULL) {
        return NULL;
    }

out_buf = PyCapsule_GetPointer(in_buf, 0);
    if (out_buf == NULL) {
        return NULL;
    }

if (!device->open_count) {
        PyErr_Format(IOException, "Device %s is not open.", device->path);
        return NULL;
    }

if (device->external_mode) {
        PyErr_Format(IOException, "Device %s is already open for external access.", device->path);
        return NULL;
    }

ret = ped_device_write(device, out_buf, start, count);
    if (ret == 0) {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                PyErr_SetString(IOException, partedExnMessage);
        }
        else
            PyErr_Format(IOException, "Could not write to device %s", device->path);

return NULL;
    }

return PyLong_FromLong(ret);
}

PyObject *py_ped_device_sync(PyObject *s, PyObject *args) {
    int ret = -1;
    PedDevice *device = NULL;

device = _ped_Device2PedDevice(s);
    if (device == NULL) {
        return NULL;
    }

if (!device->open_count) {
        PyErr_Format(IOException, "Device %s is not open.", device->path);
        return NULL;
    }

if (device->external_mode) {
        PyErr_Format(IOException, "Device %s is already open for external access.", device->path);
        return NULL;
    }

ret = ped_device_sync(device);
    if (ret == 0) {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                PyErr_SetString(IOException, partedExnMessage);
        }
        else
            PyErr_Format(IOException, "Could not sync device %s", device->path);

return NULL;
    }

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_device_sync_fast(PyObject *s, PyObject *args) {
    int ret = -1;
    PedDevice *device = NULL;

device = _ped_Device2PedDevice(s);
    if (device == NULL) {
        return NULL;
    }

if (!device->open_count) {
        PyErr_Format(IOException, "Device %s is not open.", device->path);
        return NULL;
    }

if (device->external_mode) {
        PyErr_Format(IOException, "Device %s is already open for external access.", device->path);
        return NULL;
    }

ret = ped_device_sync_fast(device);
    if (ret == 0) {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                PyErr_SetString(IOException, partedExnMessage);
        }
        else
            PyErr_Format(IOException, "Could not sync device %s", device->path);

return NULL;
    }

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_device_check(PyObject *s, PyObject *args) {
    PedSector start, count, ret;
    PedDevice *device = NULL;
    char *out_buf = NULL;

if (!PyArg_ParseTuple(args, "LL", &start, &count)) {
        return NULL;
    }

device = _ped_Device2PedDevice(s);
    if (device == NULL) {
        return NULL;
    }

if (!device->open_count) {
        PyErr_Format(IOException, "Device %s is not open.", device->path);
        return NULL;
    }

if (device->external_mode) {
        PyErr_Format(IOException, "Device %s is already open for external access.", device->path);
        return NULL;
    }

if ((out_buf = malloc(device->sector_size * 32)) == NULL) {
        return PyErr_NoMemory();
    }

ret = ped_device_check(device, out_buf, start, count);
    free(out_buf);

return PyLong_FromLongLong(ret);
}

PyObject *py_ped_device_get_constraint(PyObject *s, PyObject *args) {
    PedDevice *device = NULL;
    PedConstraint *constraint = NULL;
    _ped_Constraint *ret = NULL;

device = _ped_Device2PedDevice(s);
    if (device == NULL) {
        return NULL;
    }

constraint = ped_device_get_constraint(device);
    if (constraint) {
        ret = PedConstraint2_ped_Constraint(constraint);
    }
    else {
        PyErr_SetString(CreateException, "Could not create constraint");
        return NULL;
    }

ped_constraint_destroy(constraint);

return (PyObject *) ret;
}

PyObject *py_ped_device_get_minimal_aligned_constraint(PyObject *s, PyObject *args) {
    PedDevice *device = NULL;
    PedConstraint *constraint = NULL;
    _ped_Constraint *ret = NULL;

device = _ped_Device2PedDevice(s);
    if (device == NULL) {
        return NULL;
    }

constraint = ped_device_get_minimal_aligned_constraint(device);
    if (!constraint) {
        PyErr_SetString(CreateException, "Could not create constraint");
        return NULL;
    }

ret = PedConstraint2_ped_Constraint(constraint);
    ped_constraint_destroy(constraint);

return (PyObject *) ret;
}

PyObject *py_ped_device_get_optimal_aligned_constraint(PyObject *s, PyObject *args) {
    PedDevice *device = NULL;
    PedConstraint *constraint = NULL;
    _ped_Constraint *ret = NULL;

device = _ped_Device2PedDevice(s);
    if (device == NULL) {
        return NULL;
    }

constraint = ped_device_get_optimal_aligned_constraint(device);
    if (!constraint) {
        PyErr_SetString(CreateException, "Could not create constraint");
        return NULL;
    }

ret = PedConstraint2_ped_Constraint(constraint);
    ped_constraint_destroy(constraint);

return (PyObject *) ret;
}

PyObject *py_ped_device_get_minimum_alignment(PyObject *s, PyObject *args) {
    PedDevice *device = NULL;
    PedAlignment *alignment = NULL;
    _ped_Alignment *ret = NULL;

device = _ped_Device2PedDevice(s);
    if (device == NULL) {
        return NULL;
    }

alignment = ped_device_get_minimum_alignment(device);
    if (!alignment) {
        PyErr_SetString(CreateException, "Could not get alignment for device");
        return NULL;
    }

ret = PedAlignment2_ped_Alignment(alignment);
    ped_alignment_destroy(alignment);

return (PyObject *) ret;
}

PyObject *py_ped_device_get_optimum_alignment(PyObject *s, PyObject *args) {
    PedDevice *device = NULL;
    PedAlignment *alignment = NULL;
    _ped_Alignment *ret = NULL;

device = _ped_Device2PedDevice(s);
    if (device == NULL) {
        return NULL;
    }

alignment = ped_device_get_optimum_alignment(device);
    if (!alignment) {
        PyErr_SetString(CreateException, "Could not get alignment for device");
        return NULL;
    }

ret = PedAlignment2_ped_Alignment(alignment);
    ped_alignment_destroy(alignment);

return (PyObject *) ret;
}

/* vim:tw=78:ts=4:et:sw=4
 */
0707010011583A000081A40000FFFE0000FFFD0000000157CD697A00007FF0000000FC0000001000000000000000000000002D00000000pyparted-1466619794.7a0f829/src/_pedmodule.c/*
 * _pedmodule.c
 * libparted Python bindings.  This module is low-level in that it directly
 * maps to the libparted API.  It is intended to be used by a higher level
 * Python module that implements the libparted functionality via Python
 * classes and other high level language features.
 *
 * Copyright (C) 2007-2015 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Chris Lumens <clumens@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#include <Python.h>
#include <parted/parted.h>
#include <unistd.h>
#include <sys/types.h>

#include "_pedmodule.h"
#include "exceptions.h"
#include "pyconstraint.h"
#include "pydevice.h"
#include "pydisk.h"
#include "pyfilesys.h"
#include "pygeom.h"
#include "pynatmath.h"
#include "pytimer.h"
#include "pyunit.h"

#if PED_DISK_LAST_FLAG < 2
#define PED_DISK_GPT_PMBR_BOOT 2
#endif

#if PED_PARTITION_LAST_FLAG < 15
#define PED_PARTITION_LEGACY_BOOT 15
#endif

char *partedExnMessage = NULL;
unsigned int partedExnRaised = 0;

PyObject *exn_handler = NULL;

/* Docs strings are broken out of the module structure here to be at least a
 * little bit readable.
 */
PyDoc_STRVAR(libparted_version_doc,
"libparted_version() -> string\n\n"
"Return the version of libparted that pyparted was built against.");

PyDoc_STRVAR(pyparted_version_doc,
"pyparted_version() -> (major, minor, update)\n\n"
"Return the version of the pyparted module.");

PyDoc_STRVAR(constraint_new_from_min_max_doc,
"constraint_new_from_min_max(min, max) -> Constraint\n\n"
"min and max are Geometry objects.  Return a Constraint that requires the region\n"
"to be entirely contained inside max and to entirely contain min.");

PyDoc_STRVAR(constraint_new_from_min_doc,
"constraint_new_from_min(Geometry) -> Constraint\n\n"
"Return a Constraint that requires a region to entirely contain Geometry.");

PyDoc_STRVAR(constraint_new_from_max,
"constraint_new_from_max(Geometry) -> Constraint\n\n"
"Return a Constraint that requires a region to be entirely contained inside\n"
"Geometry.");

PyDoc_STRVAR(constraint_any_doc,
"constraint_any(Device) -> Constraint\n\n"
"Return a Constraint that any region on Device will satisfy.");

PyDoc_STRVAR(constraint_exact_doc,
"constraint_exact(Geometry) -> Constraint\n\n"
"Return a Constraint that only the given Geometry will satisfy.");

PyDoc_STRVAR(device_get_doc,
"device_get(string) -> Device\n\n"
"Return the Device corresponding to the given path.  Typically, path will\n"
"be a device name like /dev/sda.");

PyDoc_STRVAR(device_get_next_doc,
"device_get_next(Device) -> Device\n\n"
"Return the next Device in the list detected by _ped.device_probe_all().");

PyDoc_STRVAR(device_probe_all_doc,
"device_probe_all()\n\n"
"Attempt to detect all devices.");

PyDoc_STRVAR(device_free_all_doc,
"device_free_all()\n\n"
"Close and free all devices.");

PyDoc_STRVAR(file_system_probe_doc,
"file_system_probe(Geometry) -> FileSystemType\n\n"
"Attempt to detect a file system in the region described by Geometry.\n"
"This function tries to be clever at dealing with ambiguous\n"
"situations, such as when one file system was not completely erased\n"
"before a new file system was created on top of it.");

PyDoc_STRVAR(file_system_probe_specific_doc,
"file_system_probe_specific(FileSystemType, Geometry) -> Geometry\n\n"
"Attempt to find a file system and return the region it occupies.");

PyDoc_STRVAR(file_system_type_get_doc,
"file_system_type_get(self, string) -> _ped.FileSystemType\n\n"
"Get a FileSystemType by its name, or raise _ped.UnknownTypeException if no\n"
"type by that name exists.");

PyDoc_STRVAR(file_system_type_get_next_doc,
"file_system_type_get_next(self) -> _ped.FileSystemType\n\n"
"Get the next FileSystemType in parted's list after self, or raise IndexError\n"
"if there are no more types.");

PyDoc_STRVAR(disk_type_get_next_doc,
"disk_type_get_next(self) -> DiskType\n\n"
"Return the next DiskType after self.  If self is the last DiskType, raise\n"
"IndexError.");

PyDoc_STRVAR(disk_type_get_doc,
"disk_type_get(string) -> DiskType\n\n"
"Return a DiskType object with the given name.  If no DiskType exists with\n"
"that name, raise _ped.UnknownTypeException.");

PyDoc_STRVAR(partition_type_get_name_doc,
"partition_type_get_name(integer) -> string\n\n"
"Return a name for a partition type constant.  This mainly exists just to\n"
"present something in user interfaces.  It doesn't really provide the best\n"
"names for partition types.");

PyDoc_STRVAR(partition_flag_get_name_doc,
"partition_flag_get_name(integer) -> string\n\n"
"Return a name for a partition flag constant.  If an invalid flag is provided,\n"
"_ped.PartedExeption will be raised.");

PyDoc_STRVAR(partition_flag_get_by_name_doc,
"partition_flag_get_by_name(string) -> integer\n\n"
"Return a partition flag given its name, or 0 if no flag matches the name.");

PyDoc_STRVAR(partition_flag_next_doc,
"partition_flag_next(integer) -> integer\n\n"
"Given a partition flag, return the next flag.  If there is no next flag, 0\n"
"is returned.");

PyDoc_STRVAR(disk_new_fresh_doc,
"disk_new_fresh(Device, DiskType) -> Disk\n\n"
"Given the Device and DiskType, create a new Disk object with using the\n"
"DiskType specified.  The new disk label is only in-memory, the caller\n"
"will have to use the commit_to_dev() method to write the new label to\n"
"the disk.");

PyDoc_STRVAR(disk_new_doc,
"disk_new(Device) -> Disk\n\n"
"Given the Device, create a new Disk object. And probe, read the details of\n"
"the disk.");

PyDoc_STRVAR(disk_flag_get_name_doc,
"disk_flag_get_name(integer) -> string\n\n"
"Return a name for a disk flag constant.  If an invalid flag is provided,\n"
"a ValueError will be raised.");

PyDoc_STRVAR(disk_flag_get_by_name_doc,
"disk_flag_get_by_name(string) -> integer\n\n"
"Return a disk flag given its name, or 0 if no flag matches the name.");

PyDoc_STRVAR(disk_flag_next_doc,
"disk_flag_next(integer) -> integer\n\n"
"Given a disk flag, return the next flag.  If there is no next flag, 0\n"
"is returned.");

PyDoc_STRVAR(unit_set_default_doc,
"unit_set_default(Unit)\n\n"
"Sets the default Unit to be used by further unit_* calls.  This\n"
"primarily affects the formatting of error messages.");

PyDoc_STRVAR(unit_get_default_doc,
"unit_get_default() -> Unit\n\n"
"Returns the default Unit.");

PyDoc_STRVAR(unit_get_name_doc,
"unit_get_name(Unit) -> string\n\n"
"Returns a textual representation of a given Unit.");

PyDoc_STRVAR(unit_get_by_name_doc,
"unit_get_by_name(string) -> Unit\n\n"
"Returns a Unit given its textual representation.  Returns one of the\n"
"UNIT_* constants.");

PyDoc_STRVAR(register_exn_handler_doc,
"register_exn_handler(function)\n\n"
"When parted raises an exception, the function registered here will be called\n"
"to help determine what action to take.  This does not bypass the exception\n"
"handler pyparted uses.  Instead, it can be used to pop up a dialog to ask the\n"
"user which course of action to take, or to provide a different default answer,\n"
"or other actions.\n\n"
"The given function must accept as arguments:  (1) an integer corresponding to\n"
"one of the EXCEPTION_TYPE_* constants; (2) an integer corresponding to one of the\n"
"EXCEPTION_OPT_* constants; and (3) a string that is the problem encountered by\n"
"parted.  This string will already be translated.  The given function must return\n"
"one of the EXCEPTION_RESOLVE_* constants instructing parted how to proceed.");

PyDoc_STRVAR(clear_exn_handler_doc,
"clear_exn_handler()\n\n"
"Clear any previously added exception handling function.  This means the\n"
"default behavior for all parted exceptions will be used, so only safe\n"
"answers to any questions parted asks will be automatically provided.");

PyDoc_STRVAR(_ped_doc,
"This module implements an interface to libparted.\n\n"
"pyparted provides two API layers:  a lower level that exposes the complete\n"
"libparted API, and a higher level built on top of that which provides a\n"
"more Python-like view.  The _ped module is the base of the lower level\n"
"API.  It provides:\n\n"
"\t- Access to all the basic objects and submodules of pyparted\n"
"\t- Basic unit handling and mathematical functions\n"
"\t- A few basic device probing functions\n"
"\t- The DEVICE_*, PARTITION_*, and UNIT_* constants from libparted\n"
"\t- A variety of exceptions for handling error conditions\n\n"
"For complete documentation, refer to the docs strings for each _ped\n"
"method, exception class, and subclass.");

PyObject *py_ped_register_exn_handler(PyObject *s, PyObject *args) {
    PyObject *fn = NULL;

if (!PyArg_ParseTuple(args, "O", &fn)) {
        return NULL;
    }

Py_DECREF(exn_handler);
    exn_handler = fn;

Py_RETURN_TRUE;
}

PyObject *py_ped_clear_exn_handler(PyObject *s, PyObject *args) {
    exn_handler = Py_None;
    Py_INCREF(exn_handler);
    Py_RETURN_TRUE;
}

/* all of the methods for the _ped module */
static struct PyMethodDef PyPedModuleMethods[] = {
    {"libparted_version", (PyCFunction) py_libparted_get_version, METH_VARARGS,
                          libparted_version_doc},
    {"pyparted_version", (PyCFunction) py_pyparted_version, METH_VARARGS,
                         pyparted_version_doc},

{"register_exn_handler", (PyCFunction) py_ped_register_exn_handler, METH_VARARGS,
                             register_exn_handler_doc},
    {"clear_exn_handler", (PyCFunction) py_ped_clear_exn_handler, METH_VARARGS,
                          clear_exn_handler_doc},

/* pyconstraint.c */
    {"constraint_new_from_min_max", (PyCFunction) py_ped_constraint_new_from_min_max,
                                    METH_VARARGS, constraint_new_from_min_max_doc},
    {"constraint_new_from_min", (PyCFunction) py_ped_constraint_new_from_min,
                                METH_VARARGS, constraint_new_from_min_doc},
    {"constraint_new_from_max", (PyCFunction) py_ped_constraint_new_from_max,
                                METH_VARARGS, constraint_new_from_max},
    {"constraint_any", (PyCFunction) py_ped_constraint_any, METH_VARARGS,
                       constraint_any_doc},
    {"constraint_exact", (PyCFunction) py_ped_constraint_exact, METH_VARARGS,
                         constraint_exact_doc},

/* pydevice.c */
    {"device_get", (PyCFunction) py_ped_device_get, METH_VARARGS,
                   device_get_doc},
    {"device_get_next", (PyCFunction) py_ped_device_get_next, METH_VARARGS,
                        device_get_next_doc},
    {"device_probe_all", (PyCFunction) py_ped_device_probe_all, METH_VARARGS,
                         device_probe_all_doc},
    {"device_free_all", (PyCFunction) py_ped_device_free_all, METH_VARARGS,
                        device_free_all_doc},

/* pydisk.c */
    {"disk_type_get_next", (PyCFunction) py_ped_disk_type_get_next, METH_VARARGS,
                           disk_type_get_next_doc},
    {"disk_type_get", (PyCFunction) py_ped_disk_type_get, METH_VARARGS,
                      disk_type_get_doc},
    {"partition_type_get_name", (PyCFunction) py_ped_partition_type_get_name,
                                METH_VARARGS, partition_type_get_name_doc},
    {"partition_flag_get_name", (PyCFunction) py_ped_partition_flag_get_name,
                                METH_VARARGS, partition_flag_get_name_doc},
    {"partition_flag_get_by_name", (PyCFunction) py_ped_partition_flag_get_by_name,
                            METH_VARARGS, partition_flag_get_by_name_doc},
    {"partition_flag_next", (PyCFunction) py_ped_partition_flag_next,
                            METH_VARARGS, partition_flag_next_doc},
    {"disk_new_fresh", (PyCFunction) py_ped_disk_new_fresh,
                       METH_VARARGS, disk_new_fresh_doc},
    {"disk_new", (PyCFunction) py_ped_disk_new,
                       METH_VARARGS, disk_new_doc},
    {"disk_flag_get_name", (PyCFunction) py_ped_disk_flag_get_name,
                                METH_VARARGS, disk_flag_get_name_doc},
    {"disk_flag_get_by_name", (PyCFunction) py_ped_disk_flag_get_by_name,
                            METH_VARARGS, disk_flag_get_by_name_doc},
    {"disk_flag_next", (PyCFunction) py_ped_disk_flag_next,
                            METH_VARARGS, disk_flag_next_doc},

/* pyfilesys.c */
    {"file_system_probe", (PyCFunction) py_ped_file_system_probe, METH_VARARGS,
                          file_system_probe_doc},
    {"file_system_probe_specific", (PyCFunction) py_ped_file_system_probe_specific,
                                   METH_VARARGS, file_system_probe_specific_doc},
    {"file_system_type_get", (PyCFunction) py_ped_file_system_type_get, METH_VARARGS,
                             file_system_type_get_doc},
    {"file_system_type_get_next", (PyCFunction) py_ped_file_system_type_get_next,
                                  METH_VARARGS, file_system_type_get_next_doc},

/* pyunit.c */
    {"unit_set_default", (PyCFunction) py_ped_unit_set_default, METH_VARARGS,
                         unit_set_default_doc},
    {"unit_get_default", (PyCFunction) py_ped_unit_get_default, METH_VARARGS,
                         unit_get_default_doc},
    {"unit_get_name", (PyCFunction) py_ped_unit_get_name, METH_VARARGS,
                      unit_get_name_doc},
    {"unit_get_by_name", (PyCFunction) py_ped_unit_get_by_name, METH_VARARGS,
                         unit_get_by_name_doc},

{ NULL, NULL, 0, NULL }
};

#if PY_MAJOR_VERSION >= 3
#define MOD_INIT(name) PyMODINIT_FUNC PyInit_##name(void)
#define MOD_ERROR_VAL NULL
#define MOD_SUCCESS_VAL(val) val

struct PyModuleDef module_def = {
     PyModuleDef_HEAD_INIT,
     "_ped",
     _ped_doc,
     -1,
     PyPedModuleMethods,
        NULL, NULL, NULL, NULL
    };
#else
#define MOD_INIT(name) PyMODINIT_FUNC init##name(void)
#define MOD_ERROR_VAL
#define MOD_SUCCESS_VAL(val)
#endif

PyObject *py_libparted_get_version(PyObject *s, PyObject *args) {
    char *ret = (char *) ped_get_version();

if (ret != NULL)
        return PyUnicode_FromString(ret);
    else
        return PyUnicode_FromString("");
}

PyObject *py_pyparted_version(PyObject *s, PyObject *args) {
    int t = 0;
    int major = -1, minor = -1, update = -1;
    char suffix[11];
    char *v = PYPARTED_VERSION;

/* Read pyparted version string.  Support the following formats:
     *     X
     *     X.Y
     *     X.Y.Z
     *     X.Y.Z-string
     */
    if (index(v, '-')) {
        memset(&suffix, '\0', sizeof(suffix));
        t = sscanf(v, "%d.%d.%d-%10s", &major, &minor, &update,
                   (char *) &suffix);
    } else {
        t = sscanf(v, "%d.%d.%d", &major, &minor, &update);
    }

if (t == 0 || t == EOF) {
        return NULL;
    }

if (t == 1) {
        return Py_BuildValue("(i)", major);
    } else if (t == 2) {
        if (minor == -1) {
            return Py_BuildValue("(is)", major, suffix);
        } else {
            return Py_BuildValue("(ii)", major, minor);
        }
    } else if (t == 3) {
        if (update == -1) {
            return Py_BuildValue("(iis)", major, minor, suffix);
        } else {
            return Py_BuildValue("(iii)", major, minor, update);
        }
    } else {
        return Py_BuildValue("(iiis)", major, minor, update, suffix);
    }
}

/* This function catches libparted exceptions and converts them into Python
 * exceptions that the various methods can catch and do something with.  The
 * main motivation for this function is that methods in our parted module need
 * to be able to raise specific, helpful exceptions instead of something
 * generic.
 *
 * It is also possible for callers to specify a function to help in deciding
 * what to do with parted exceptions.  See the docs for the
 * py_ped_register_exn_handler function.
 */
static PedExceptionOption partedExnHandler(PedException *e) {
    switch (e->type) {
        /* Raise yes/no exceptions so the caller can deal with them,
         * otherwise ignore */
        case PED_EXCEPTION_INFORMATION:
        case PED_EXCEPTION_WARNING:
            if (e->options == PED_EXCEPTION_YES_NO) {
                partedExnRaised = 1;
                partedExnMessage = strdup(e->message);

if (partedExnMessage == NULL)
                    PyErr_NoMemory();
                else if (exn_handler && PyCallable_Check(exn_handler)) {
                    PyObject *args, *retval;

args = PyTuple_New(3);
                    PyTuple_SetItem(args, 0, PyLong_FromLong(e->type));
                    PyTuple_SetItem(args, 1, PyLong_FromLong(e->options));
                    PyTuple_SetItem(args, 2, PyUnicode_FromString(e->message));

retval = PyObject_CallObject(exn_handler, args);
                    Py_DECREF(args);
                    if (retval != NULL && (PyLong_AsLong(retval) == PED_EXCEPTION_UNHANDLED || (PyLong_AsLong(retval) & e->options) > 0))
                        return PyLong_AsLong(retval);
                    else
                        /* Call failed, use the default value. */
                        return PED_EXCEPTION_NO;
                }
                else {
                    /* If no exception handling function was registered to
                     * tell us what to do, return "no" for any yes/no
                     * questions to prevent any potential disk destruction.
                     */
                    return PED_EXCEPTION_NO;
                }
            } else {
                partedExnRaised = 0;
                return PED_EXCEPTION_IGNORE;
            }

/* Set global flags so parted module methods can raise specific
         * exceptions with the message.
         */
        case PED_EXCEPTION_ERROR:
        case PED_EXCEPTION_FATAL:
            partedExnRaised = 1;
            partedExnMessage = strdup(e->message);

if (partedExnMessage == NULL)
                PyErr_NoMemory();
            else if (exn_handler && PyCallable_Check(exn_handler)) {
                PyObject *args, *retval;

args = PyTuple_New(3);
                PyTuple_SetItem(args, 0, PyLong_FromLong(e->type));
                PyTuple_SetItem(args, 1, PyLong_FromLong(e->options));
                PyTuple_SetItem(args, 2, PyUnicode_FromString(e->message));

retval = PyObject_CallObject(exn_handler, args);
                Py_DECREF(args);
                if (retval != NULL && (PyLong_AsLong(retval) == PED_EXCEPTION_UNHANDLED || (PyLong_AsLong(retval) & e->options) > 0))
                    return PyLong_AsLong(retval);
                else
                    /* Call failed, use the default value. */
                    return PED_EXCEPTION_CANCEL;
            }
            else {
                /* If no exception handling function was registered to tell us
                 * what to do, return "cancel" for any questions to prevent
                 * any potential disk destruction.
                 */
                return PED_EXCEPTION_CANCEL;
            }

/* Raise exceptions for internal parted bugs immediately. */
        case PED_EXCEPTION_BUG:
            partedExnRaised = 1;
            PyErr_SetString (PartedException, e->message);
            return PED_EXCEPTION_CANCEL;

/* Raise NotImplemented exceptions immediately too. */
        case PED_EXCEPTION_NO_FEATURE:
            partedExnRaised = 1;
            PyErr_SetString (PyExc_NotImplementedError, e->message);
            return PED_EXCEPTION_CANCEL;
    }

return PED_EXCEPTION_IGNORE;
}

MOD_INIT(_ped) {
    PyObject *m = NULL;

/* init the main Python module and add methods */
#if PY_MAJOR_VERSION >= 3
    m = PyModule_Create(&module_def);
#else
    m = Py_InitModule3("_ped", PyPedModuleMethods, _ped_doc);
#endif

/* PedUnit possible values */
    PyModule_AddIntConstant(m, "UNIT_SECTOR", PED_UNIT_SECTOR);
    PyModule_AddIntConstant(m, "UNIT_BYTE", PED_UNIT_BYTE);
    PyModule_AddIntConstant(m, "UNIT_KILOBYTE", PED_UNIT_KILOBYTE);
    PyModule_AddIntConstant(m, "UNIT_MEGABYTE", PED_UNIT_MEGABYTE);
    PyModule_AddIntConstant(m, "UNIT_GIGABYTE", PED_UNIT_GIGABYTE);
    PyModule_AddIntConstant(m, "UNIT_TERABYTE", PED_UNIT_TERABYTE);
    PyModule_AddIntConstant(m, "UNIT_COMPACT", PED_UNIT_COMPACT);
    PyModule_AddIntConstant(m, "UNIT_CYLINDER", PED_UNIT_CYLINDER);
    PyModule_AddIntConstant(m, "UNIT_CHS", PED_UNIT_CHS);
    PyModule_AddIntConstant(m, "UNIT_PERCENT", PED_UNIT_PERCENT);
    PyModule_AddIntConstant(m, "UNIT_KIBIBYTE", PED_UNIT_KIBIBYTE);
    PyModule_AddIntConstant(m, "UNIT_MEBIBYTE", PED_UNIT_MEBIBYTE);
    PyModule_AddIntConstant(m, "UNIT_GIBIBYTE", PED_UNIT_GIBIBYTE);
    PyModule_AddIntConstant(m, "UNIT_TEBIBYTE", PED_UNIT_TEBIBYTE);

/* add PedCHSGeometry type as _ped.CHSGeometry */
    if (PyType_Ready(&_ped_CHSGeometry_Type_obj) < 0)
        return MOD_ERROR_VAL;

Py_INCREF(&_ped_CHSGeometry_Type_obj);
    PyModule_AddObject(m, "CHSGeometry",
                       (PyObject *)&_ped_CHSGeometry_Type_obj);

/* add PedDevice type as _ped.Device */
    if (PyType_Ready(&_ped_Device_Type_obj) < 0)
        return MOD_ERROR_VAL;

Py_INCREF(&_ped_Device_Type_obj);
    PyModule_AddObject(m, "Device", (PyObject *)&_ped_Device_Type_obj);

PyModule_AddIntConstant(m, "DEVICE_UNKNOWN", PED_DEVICE_UNKNOWN);
    PyModule_AddIntConstant(m, "DEVICE_SCSI", PED_DEVICE_SCSI);
    PyModule_AddIntConstant(m, "DEVICE_IDE", PED_DEVICE_IDE);
    PyModule_AddIntConstant(m, "DEVICE_DAC960", PED_DEVICE_DAC960);
    PyModule_AddIntConstant(m, "DEVICE_CPQARRAY", PED_DEVICE_CPQARRAY);
    PyModule_AddIntConstant(m, "DEVICE_FILE", PED_DEVICE_FILE);
    PyModule_AddIntConstant(m, "DEVICE_ATARAID", PED_DEVICE_ATARAID);
    PyModule_AddIntConstant(m, "DEVICE_I2O", PED_DEVICE_I2O);
    PyModule_AddIntConstant(m, "DEVICE_UBD", PED_DEVICE_UBD);
    PyModule_AddIntConstant(m, "DEVICE_DASD", PED_DEVICE_DASD);
    PyModule_AddIntConstant(m, "DEVICE_VIODASD", PED_DEVICE_VIODASD);
    PyModule_AddIntConstant(m, "DEVICE_SX8", PED_DEVICE_SX8);
    PyModule_AddIntConstant(m, "DEVICE_DM", PED_DEVICE_DM);
    PyModule_AddIntConstant(m, "DEVICE_XVD", PED_DEVICE_XVD);
    PyModule_AddIntConstant(m, "DEVICE_SDMMC", PED_DEVICE_SDMMC);
    PyModule_AddIntConstant(m, "DEVICE_VIRTBLK", PED_DEVICE_VIRTBLK);

/* add PedTimer type as _ped.Timer */
    if (PyType_Ready(&_ped_Timer_Type_obj) < 0)
        return MOD_ERROR_VAL;

Py_INCREF(&_ped_Timer_Type_obj);
    PyModule_AddObject(m, "Timer", (PyObject *)&_ped_Timer_Type_obj);

/* add PedGeometry type as _ped.Geometry */
    if (PyType_Ready(&_ped_Geometry_Type_obj) < 0)
        return MOD_ERROR_VAL;

Py_INCREF(&_ped_Geometry_Type_obj);
    PyModule_AddObject(m, "Geometry", (PyObject *)&_ped_Geometry_Type_obj);

/* add PedAlignment type as _ped.Alignment */
    if (PyType_Ready(&_ped_Alignment_Type_obj) < 0)
        return MOD_ERROR_VAL;

Py_INCREF(&_ped_Alignment_Type_obj);
    PyModule_AddObject(m, "Alignment", (PyObject *)&_ped_Alignment_Type_obj);

/* add PedConstraint type as _ped.Constraint */
    if (PyType_Ready(&_ped_Constraint_Type_obj) < 0)
        return MOD_ERROR_VAL;

Py_INCREF(&_ped_Constraint_Type_obj);
    PyModule_AddObject(m, "Constraint", (PyObject *)&_ped_Constraint_Type_obj);

/* add PedPartition type as _ped.Partition */
    if (PyType_Ready(&_ped_Partition_Type_obj) < 0)
        return MOD_ERROR_VAL;

Py_INCREF(&_ped_Partition_Type_obj);
    PyModule_AddObject(m, "Partition", (PyObject *)&_ped_Partition_Type_obj);

/* add PedDisk as _ped.Disk */
    if (PyType_Ready(&_ped_Disk_Type_obj) < 0)
        return MOD_ERROR_VAL;

Py_INCREF(&_ped_Disk_Type_obj);
    PyModule_AddObject(m, "Disk", (PyObject *)&_ped_Disk_Type_obj);

/* add PedDiskType as _ped.DiskType */
    if (PyType_Ready(&_ped_DiskType_Type_obj) < 0)
        return MOD_ERROR_VAL;

Py_INCREF(&_ped_DiskType_Type_obj);
    PyModule_AddObject(m, "DiskType", (PyObject *)&_ped_DiskType_Type_obj);

/* possible PedDiskTypeFeature values */
    PyModule_AddIntConstant(m, "PARTITION_NORMAL", PED_PARTITION_NORMAL);
    PyModule_AddIntConstant(m, "PARTITION_LOGICAL", PED_PARTITION_LOGICAL);
    PyModule_AddIntConstant(m, "PARTITION_EXTENDED", PED_PARTITION_EXTENDED);
    PyModule_AddIntConstant(m, "PARTITION_FREESPACE", PED_PARTITION_FREESPACE);
    PyModule_AddIntConstant(m, "PARTITION_METADATA", PED_PARTITION_METADATA);
    PyModule_AddIntConstant(m, "PARTITION_PROTECTED", PED_PARTITION_PROTECTED);

PyModule_AddIntConstant(m, "PARTITION_BOOT", PED_PARTITION_BOOT);
    PyModule_AddIntConstant(m, "PARTITION_ROOT", PED_PARTITION_ROOT);
    PyModule_AddIntConstant(m, "PARTITION_SWAP", PED_PARTITION_SWAP);
    PyModule_AddIntConstant(m, "PARTITION_HIDDEN", PED_PARTITION_HIDDEN);
    PyModule_AddIntConstant(m, "PARTITION_RAID", PED_PARTITION_RAID);
    PyModule_AddIntConstant(m, "PARTITION_LVM", PED_PARTITION_LVM);
    PyModule_AddIntConstant(m, "PARTITION_LBA", PED_PARTITION_LBA);
    PyModule_AddIntConstant(m, "PARTITION_HPSERVICE", PED_PARTITION_HPSERVICE);
    PyModule_AddIntConstant(m, "PARTITION_PALO", PED_PARTITION_PALO);
    PyModule_AddIntConstant(m, "PARTITION_PREP", PED_PARTITION_PREP);
    PyModule_AddIntConstant(m, "PARTITION_MSFT_RESERVED", PED_PARTITION_MSFT_RESERVED);
    PyModule_AddIntConstant(m, "PARTITION_APPLE_TV_RECOVERY", PED_PARTITION_APPLE_TV_RECOVERY);
    PyModule_AddIntConstant(m, "PARTITION_BIOS_GRUB", PED_PARTITION_BIOS_GRUB);
    PyModule_AddIntConstant(m, "PARTITION_DIAG", PED_PARTITION_DIAG);
    PyModule_AddIntConstant(m, "PARTITION_LEGACY_BOOT", PED_PARTITION_LEGACY_BOOT);
    PyModule_AddIntConstant(m, "PARTITION_MSFT_DATA", PED_PARTITION_MSFT_DATA);
    PyModule_AddIntConstant(m, "PARTITION_IRST", PED_PARTITION_IRST);
    PyModule_AddIntConstant(m, "PARTITION_ESP", PED_PARTITION_ESP);

PyModule_AddIntConstant(m, "DISK_CYLINDER_ALIGNMENT", PED_DISK_CYLINDER_ALIGNMENT);
    PyModule_AddIntConstant(m, "DISK_GPT_PMBR_BOOT", PED_DISK_GPT_PMBR_BOOT);

PyModule_AddIntConstant(m, "DISK_TYPE_EXTENDED", PED_DISK_TYPE_EXTENDED);
    PyModule_AddIntConstant(m, "DISK_TYPE_PARTITION_NAME", PED_DISK_TYPE_PARTITION_NAME);

/* add PedFileSystemType as _ped.FileSystemType */
    if (PyType_Ready(&_ped_FileSystemType_Type_obj) < 0)
        return MOD_ERROR_VAL;

Py_INCREF(&_ped_FileSystemType_Type_obj);
    PyModule_AddObject(m, "FileSystemType",
                       (PyObject *)&_ped_FileSystemType_Type_obj);

/* add PedFileSystem as _ped.FileSystem */
    if (PyType_Ready(&_ped_FileSystem_Type_obj) < 0)
        return MOD_ERROR_VAL;

Py_INCREF(&_ped_FileSystem_Type_obj);
    PyModule_AddObject(m, "FileSystem", (PyObject *)&_ped_FileSystem_Type_obj);

/* add our custom exceptions */
    AlignmentException = PyErr_NewException("_ped.AlignmentException", NULL,
                                             NULL);
    Py_INCREF(AlignmentException);
    PyModule_AddObject(m, "AlignmentException", AlignmentException);

ConstraintException = PyErr_NewException("_ped.ConstraintException", NULL,
                                             NULL);
    Py_INCREF(ConstraintException);
    PyModule_AddObject(m, "ConstraintException", ConstraintException);

CreateException = PyErr_NewException("_ped.CreateException", NULL, NULL);
    Py_INCREF(CreateException);
    PyModule_AddObject(m, "CreateException", CreateException);

DeviceException = PyErr_NewException("_ped.DeviceException", NULL, NULL);
    Py_INCREF(DeviceException);
    PyModule_AddObject(m, "DeviceException", DeviceException);

DiskException = PyErr_NewException("_ped.DiskException", NULL, NULL);
    Py_INCREF(DiskException);
    PyModule_AddObject(m, "DiskException", DiskException);

DiskLabelException = PyErr_NewException("_ped.DiskLabelException", NULL, NULL);
    Py_INCREF(DiskLabelException);
    PyModule_AddObject(m, "DiskLabelException", DiskLabelException);

FileSystemException = PyErr_NewException("_ped.FileSystemException", NULL,
                                             NULL);
    Py_INCREF(FileSystemException);
    PyModule_AddObject(m, "FileSystemException", FileSystemException);

GeometryException = PyErr_NewException("_ped.GeometryException", NULL, NULL);
    Py_INCREF(GeometryException);
    PyModule_AddObject(m, "GeometryException", GeometryException);

IOException = PyErr_NewException("_ped.IOException", NULL, NULL);
    Py_INCREF(IOException);
    PyModule_AddObject(m, "IOException", IOException);

NotNeededException = PyErr_NewException("_ped.NotNeededException",
                                            NULL, NULL);
    Py_INCREF(NotNeededException);
    PyModule_AddObject(m, "NotNeededException", NotNeededException);

PartedException = PyErr_NewException("_ped.PartedException", NULL, NULL);
    Py_INCREF(PartedException);
    PyModule_AddObject(m, "PartedException", PartedException);

PartitionException = PyErr_NewException("_ped.PartitionException", NULL,
                                             NULL);
    Py_INCREF(PartitionException);
    PyModule_AddObject(m, "PartitionException", PartitionException);

TimerException = PyErr_NewException("_ped.TimerException", NULL, NULL);
    Py_INCREF(TimerException);
    PyModule_AddObject(m, "TimerException", TimerException);

UnknownDeviceException = PyErr_NewException("_ped.UnknownDeviceException",
                                                NULL, NULL);
    Py_INCREF(UnknownDeviceException);
    PyModule_AddObject(m, "UnknownDeviceException", UnknownDeviceException);

UnknownTypeException = PyErr_NewException("_ped.UnknownTypeException", NULL,
                                              NULL);
    Py_INCREF(UnknownTypeException);
    PyModule_AddObject(m, "UnknownTypeException", UnknownTypeException);

/* Exception type constants. */
    PyModule_AddIntConstant(m, "EXCEPTION_TYPE_INFORMATION", PED_EXCEPTION_INFORMATION);
    PyModule_AddIntConstant(m, "EXCEPTION_TYPE_WARNING", PED_EXCEPTION_WARNING);
    PyModule_AddIntConstant(m, "EXCEPTION_TYPE_ERROR", PED_EXCEPTION_ERROR);
    PyModule_AddIntConstant(m, "EXCEPTION_TYPE_FATAL", PED_EXCEPTION_FATAL);
    PyModule_AddIntConstant(m, "EXCEPTION_TYPE_BUG", PED_EXCEPTION_BUG);
    PyModule_AddIntConstant(m, "EXCEPTION_TYPE_NO_FEATURE", PED_EXCEPTION_NO_FEATURE);

/* Exception resolution constants. */
    PyModule_AddIntConstant(m, "EXCEPTION_RESOLVE_UNHANDLED", PED_EXCEPTION_UNHANDLED);
    PyModule_AddIntConstant(m, "EXCEPTION_RESOLVE_FIX", PED_EXCEPTION_FIX);
    PyModule_AddIntConstant(m, "EXCEPTION_RESOLVE_YES", PED_EXCEPTION_YES);
    PyModule_AddIntConstant(m, "EXCEPTION_RESOLVE_NO", PED_EXCEPTION_NO);
    PyModule_AddIntConstant(m, "EXCEPTION_RESOLVE_OK", PED_EXCEPTION_OK);
    PyModule_AddIntConstant(m, "EXCEPTION_RESOLVE_RETRY", PED_EXCEPTION_RETRY);
    PyModule_AddIntConstant(m, "EXCEPTION_RESOLVE_IGNORE", PED_EXCEPTION_IGNORE);
    PyModule_AddIntConstant(m, "EXCEPTION_RESOLVE_CANCEL", PED_EXCEPTION_CANCEL);

/* Exception option constants. */
    PyModule_AddIntConstant(m, "EXCEPTION_OPT_OK_CANCEL", PED_EXCEPTION_OK_CANCEL);
    PyModule_AddIntConstant(m, "EXCEPTION_OPT_YES_NO", PED_EXCEPTION_YES_NO);
    PyModule_AddIntConstant(m, "EXCEPTION_OPT_YES_NO_CANCEL", PED_EXCEPTION_YES_NO_CANCEL);
    PyModule_AddIntConstant(m, "EXCEPTION_OPT_IGNORE_CANCEL", PED_EXCEPTION_IGNORE_CANCEL);
    PyModule_AddIntConstant(m, "EXCEPTION_OPT_RETRY_CANCEL", PED_EXCEPTION_RETRY_CANCEL);
    PyModule_AddIntConstant(m, "EXCEPTION_OPT_RETRY_IGNORE_CANCEL", PED_EXCEPTION_RETRY_IGNORE_CANCEL);

exn_handler = Py_None;
    Py_INCREF(exn_handler);

/* Set up our libparted exception handler. */
    ped_exception_set_handler(partedExnHandler);
    return MOD_SUCCESS_VAL(m);
}

/* vim:tw=78:ts=4:et:sw=4
 */
0707010011583B000081A40000FFFE0000FFFD0000000157CD697A00004A1F000000FC0000001000000000000000000000002F00000000pyparted-1466619794.7a0f829/src/pyconstraint.c/*
 * pyconstraint.c
 *
 * Copyright (C) 2007-2013  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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Chris Lumens <clumens@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#include <Python.h>

#include "convert.h"
#include "exceptions.h"
#include "pyconstraint.h"
#include "pygeom.h"
#include "pynatmath.h"
#include "docstrings/pyconstraint.h"
#include "typeobjects/pyconstraint.h"

/* _ped.Constraint functions */
void _ped_Constraint_dealloc(_ped_Constraint *self) {
    PyObject_GC_UnTrack(self);

Py_CLEAR(self->start_align);
    self->start_align = NULL;

Py_CLEAR(self->end_align);
    self->end_align = NULL;

Py_CLEAR(self->start_range);
    self->start_range = NULL;

Py_CLEAR(self->end_range);
    self->end_range = NULL;

PyObject_GC_Del(self);
}

int _ped_Constraint_compare(_ped_Constraint *self, PyObject *obj) {
    _ped_Constraint *comp = NULL;
    int check = PyObject_IsInstance(obj, (PyObject *) &_ped_Constraint_Type_obj);

if (PyErr_Occurred()) {
        return -1;
    }

if (!check) {
        PyErr_SetString(PyExc_ValueError, "object comparing to must be a _ped.Constraint");
        return -1;
    }

comp = (_ped_Constraint *) obj;
    if ((_ped_Alignment_Type_obj.tp_richcompare(self->start_align, comp->start_align, Py_EQ)) &&
        (_ped_Alignment_Type_obj.tp_richcompare(self->end_align, comp->end_align, Py_EQ)) &&
        (_ped_Geometry_Type_obj.tp_richcompare(self->start_range, comp->start_range, Py_EQ)) &&
        (_ped_Geometry_Type_obj.tp_richcompare(self->end_range, comp->end_range, Py_EQ)) &&
        (self->min_size == comp->min_size) &&
        (self->max_size == comp->max_size)) {
        return 0;
    } else {
        return 1;
    }
}

PyObject *_ped_Constraint_richcompare(_ped_Constraint *a, PyObject *b, int op) {
    if (op == Py_EQ || op == Py_NE) {
        int rv = _ped_Constraint_compare(a, b);
        if (PyErr_Occurred())
            return NULL;
        return PyBool_FromLong(op == Py_EQ ? rv == 0 : rv != 0);
    } else if ((op == Py_LT) || (op == Py_LE) ||
               (op == Py_GT) || (op == Py_GE)) {
        PyErr_SetString(PyExc_TypeError, "comparison operator not supported for _ped.Constraint");
        return NULL;
    } else {
        PyErr_SetString(PyExc_ValueError, "unknown richcompare op");
        return NULL;
    }
}

PyObject *_ped_Constraint_str(_ped_Constraint *self) {
    char *ret = NULL;
    char *start_align = NULL, *end_align = NULL;
    char *start_range = NULL, *end_range = NULL;

start_align =
PyUnicode_AsUTF8(_ped_Alignment_Type_obj.tp_repr(self->start_align));
    if (start_align == NULL) {
        return NULL;
    }

end_align =
PyUnicode_AsUTF8(_ped_Alignment_Type_obj.tp_repr(self->end_align));
    if (end_align == NULL) {
        return NULL;
    }

start_range =
PyUnicode_AsUTF8(_ped_Geometry_Type_obj.tp_repr(self->start_range));
    if (start_range == NULL) {
        return NULL;
    }

end_range =
PyUnicode_AsUTF8(_ped_Geometry_Type_obj.tp_repr(self->end_range));
    if (end_range == NULL) {
        return NULL;
    }

if (asprintf(&ret, "_ped.Constraint instance --\n"
                       "  start_align: %s  end_align: %s\n"
                       "  start_range: %s  end_range: %s\n"
                       "  min_size: %lld  max_size: %lld",
                 start_align, end_align,
                 start_range, end_range,
                 self->min_size, self->max_size) == -1) {
        return PyErr_NoMemory();
    }

return Py_BuildValue("s", ret);
}

int _ped_Constraint_traverse(_ped_Constraint *self, visitproc visit, void *arg) {
    int err;

if (self->start_align) {
        if ((err = visit(self->start_align, arg))) {
            return err;
        }
    }

if (self->end_align) {
        if ((err = visit(self->end_align, arg))) {
            return err;
        }
    }

if (self->start_range) {
        if ((err = visit(self->start_range, arg))) {
            return err;
        }
    }

if (self->end_range) {
        if ((err = visit(self->end_range, arg))) {
            return err;
        }
    }

return 0;
}

int _ped_Constraint_clear(_ped_Constraint *self) {
    Py_CLEAR(self->start_align);
    self->start_align = NULL;

Py_CLEAR(self->end_align);
    self->end_align = NULL;

Py_CLEAR(self->start_range);
    self->start_range = NULL;

Py_CLEAR(self->end_range);
    self->end_range = NULL;

return 0;
}

int _ped_Constraint_init(_ped_Constraint *self, PyObject *args,
                         PyObject *kwds) {
    static char *kwlist[] = {"start_align", "end_align", "start_range",
                             "end_range", "min_size", "max_size", NULL};
    PedConstraint *constraint = NULL;
    PedAlignment *start_align = NULL, *end_align = NULL;
    PedGeometry *start_range = NULL, *end_range = NULL;

if (kwds == NULL) {
        if (!PyArg_ParseTuple(args, "O!O!O!O!LL",
                              &_ped_Alignment_Type_obj, &self->start_align,
                              &_ped_Alignment_Type_obj, &self->end_align,
                              &_ped_Geometry_Type_obj, &self->start_range,
                              &_ped_Geometry_Type_obj, &self->end_range,
                              &self->min_size, &self->max_size)) {
            self->start_align = self->end_align = NULL;
            self->start_range = self->end_range = NULL;
            return -1;
        }
    } else {
        if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!O!O!O!LL", kwlist,
                                         &_ped_Alignment_Type_obj,
                                         &self->start_align,
                                         &_ped_Alignment_Type_obj,
                                         &self->end_align,
                                         &_ped_Geometry_Type_obj,
                                         &self->start_range,
                                         &_ped_Geometry_Type_obj,
                                         &self->end_range,
                                         &self->min_size,
                                         &self->max_size)) {
            self->start_align = self->end_align = NULL;
            self->start_range = self->end_range = NULL;
            return -2;
        }
    }

/*
     * try to call libparted with provided information,
     * on failure, raise an exception
     */
    start_align = _ped_Alignment2PedAlignment(self->start_align);
    end_align = _ped_Alignment2PedAlignment(self->end_align);
    start_range = _ped_Geometry2PedGeometry(self->start_range);
    end_range = _ped_Geometry2PedGeometry(self->end_range);

constraint = ped_constraint_new(start_align, end_align,
                                    start_range, end_range,
                                    self->min_size, self->max_size);
    if (constraint == NULL) {
        PyErr_SetString(CreateException, "Could not create new constraint");

ped_alignment_destroy(start_align);
        ped_alignment_destroy(end_align);
        self->start_align = NULL;
        self->end_align = NULL;
        self->start_range = NULL;
        self->end_range = NULL;
        return -3;
    }

/* increment reference count for PyObjects read by PyArg_ParseTuple */
    Py_INCREF(self->start_align);
    Py_INCREF(self->end_align);
    Py_INCREF(self->start_range);
    Py_INCREF(self->end_range);

/* clean up libparted objects we created */
    ped_alignment_destroy(start_align);
    ped_alignment_destroy(end_align);
    ped_constraint_destroy(constraint);
    return 0;
}

PyObject *_ped_Constraint_get(_ped_Constraint *self, void *closure) {
    char *member = (char *) closure;

if (member == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.Constraint()");
        return NULL;
    }

if (!strcmp(member, "min_size")) {
        return PyLong_FromLongLong(self->min_size);
    } else if (!strcmp(member, "max_size")) {
        return PyLong_FromLongLong(self->max_size);
    } else {
        PyErr_Format(PyExc_AttributeError, "_ped.Constraint object has no attribute %s", member);
        return NULL;
    }
}

int _ped_Constraint_set(_ped_Constraint *self, PyObject *value, void *closure) {
    char *member = (char *) closure;

if (member == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.Constraint()");
        return -1;
    }

if (!strcmp(member, "min_size")) {
        self->min_size = PyLong_AsLongLong(value);
        if (PyErr_Occurred()) {
            return -1;
        }
    } else if (!strcmp(member, "max_size")) {
        self->max_size = PyLong_AsLongLong(value);
        if (PyErr_Occurred()) {
            return -1;
        }
    } else {
        PyErr_Format(PyExc_AttributeError, "_ped.Constraint object has no attribute %s", member);
        return -1;
    }

return 0;
}

/* 1:1 function mappings for constraint.h in libparted */
PyObject *py_ped_constraint_new_from_min_max(PyObject *s, PyObject *args) {
    PyObject *in_min = NULL, *in_max = NULL;
    PedGeometry *out_min = NULL, *out_max = NULL;
    PedConstraint *constraint = NULL;
    _ped_Constraint *ret = NULL;

if (!PyArg_ParseTuple(args, "O!O!", &_ped_Geometry_Type_obj, &in_min,
                          &_ped_Geometry_Type_obj, &in_max)) {
        return NULL;
    }

out_min = _ped_Geometry2PedGeometry(in_min);
    if (out_min == NULL) {
        return NULL;
    }

out_max = _ped_Geometry2PedGeometry(in_max);
    if (out_max == NULL) {
        return NULL;
    }

/* ped_constraint_new_from_min_max will ASSERT if this isn't enforced. */
    if (!ped_geometry_test_inside(out_max, out_min)) {
        PyErr_SetString(CreateException, "min geometry must be contained within max geometry");
        return NULL;
    }

constraint = ped_constraint_new_from_min_max(out_min, out_max);
    if (constraint) {
        ret = PedConstraint2_ped_Constraint(constraint);
    }
    else {
        PyErr_SetString(CreateException, "Could not create new constraint from min/max");
        return NULL;
    }

ped_constraint_destroy(constraint);

return (PyObject *) ret;
}

PyObject *py_ped_constraint_new_from_min(PyObject *s, PyObject *args) {
    PyObject *in_min = NULL;
    PedGeometry *out_min = NULL;
    PedConstraint *constraint = NULL;
    _ped_Constraint *ret = NULL;

if (!PyArg_ParseTuple(args, "O!", &_ped_Geometry_Type_obj, &in_min)) {
        return NULL;
    }

out_min = _ped_Geometry2PedGeometry(in_min);
    if (out_min == NULL) {
        return NULL;
    }

constraint = ped_constraint_new_from_min(out_min);
    if (constraint) {
        ret = PedConstraint2_ped_Constraint(constraint);
    }
    else {
        PyErr_SetString(CreateException, "Could not create new constraint from min");
        return NULL;
    }

ped_constraint_destroy(constraint);

return (PyObject *) ret;
}

PyObject *py_ped_constraint_new_from_max(PyObject *s, PyObject *args) {
    PyObject *in_max = NULL;
    PedGeometry *out_max = NULL;
    PedConstraint *constraint = NULL;
    _ped_Constraint *ret = NULL;

if (!PyArg_ParseTuple(args, "O!", &_ped_Geometry_Type_obj, &in_max)) {
        return NULL;
    }

out_max = _ped_Geometry2PedGeometry(in_max);
    if (out_max == NULL) {
        return NULL;
    }

constraint = ped_constraint_new_from_max(out_max);
    if (constraint) {
        ret = PedConstraint2_ped_Constraint(constraint);
    }
    else {
        PyErr_SetString(CreateException, "Could not create new constraint from max");
        return NULL;
    }

ped_constraint_destroy(constraint);

return (PyObject *) ret;
}

/* XXX: Remove this function at some point in the future.  The deprecation
 * warning tells people what they should be doing.
 */
PyObject *py_ped_constraint_duplicate(PyObject *s, PyObject *args) {
    PedConstraint *constraint = NULL, *dup_constraint = NULL;
    _ped_Constraint *ret = NULL;

constraint = _ped_Constraint2PedConstraint(s);
    if (constraint == NULL) {
        return NULL;
    }

if (PyErr_WarnEx(PyExc_DeprecationWarning,
                     "use copy.deepcopy() to duplicate a _ped.Constraint",
                     1) == -1) {
        return NULL;
    }

dup_constraint = ped_constraint_duplicate(constraint);
    ped_constraint_destroy(constraint);

if (dup_constraint) {
        ret = PedConstraint2_ped_Constraint(dup_constraint);
    } else {
        PyErr_SetString(CreateException, "Could not duplicate constraint");
        return NULL;
    }

ped_constraint_destroy(dup_constraint);

return (PyObject *) ret;
}

PyObject *py_ped_constraint_intersect(PyObject *s, PyObject *args) {
    PyObject *in_constraintB = NULL;
    PedConstraint *constraintA = NULL, *constraintB = NULL;
    PedConstraint *constraint = NULL;
    _ped_Constraint *ret = NULL;

if (!PyArg_ParseTuple(args, "O!", &_ped_Constraint_Type_obj,
                          &in_constraintB)) {
        return NULL;
    }

constraintA = _ped_Constraint2PedConstraint(s);
    if (constraintA == NULL) {
        return NULL;
    }

constraintB = _ped_Constraint2PedConstraint(in_constraintB);
    if (constraintB == NULL) {
        ped_constraint_destroy(constraintA);
        return NULL;
    }

constraint = ped_constraint_intersect(constraintA, constraintB);

ped_constraint_destroy(constraintA);
    ped_constraint_destroy(constraintB);

if (constraint) {
        ret = PedConstraint2_ped_Constraint(constraint);
    }
    else {
        PyErr_SetString(PyExc_ArithmeticError, "Could not find constraint intersection");
        return NULL;
    }

ped_constraint_destroy(constraint);

return (PyObject *) ret;
}

PyObject *py_ped_constraint_solve_max(PyObject *s, PyObject *args) {
    PedConstraint *constraint = NULL;
    PedGeometry *geometry = NULL;
    _ped_Geometry *ret = NULL;

constraint = _ped_Constraint2PedConstraint(s);
    if (constraint == NULL) {
        return NULL;
    }

geometry = ped_constraint_solve_max(constraint);

ped_constraint_destroy(constraint);

if (geometry) {
        ret = PedGeometry2_ped_Geometry(geometry);
    }
    else {
        if (partedExnRaised) {
            partedExnRaised = 0;

if (!PyErr_ExceptionMatches(PartedException) &&
                !PyErr_ExceptionMatches(PyExc_NotImplementedError))
                PyErr_SetString(ConstraintException, partedExnMessage);
        }
        else
            PyErr_SetString(PyExc_ArithmeticError, "Could not find largest region satisfying constraint");

return NULL;
    }

return (PyObject *) ret;
}

PyObject *py_ped_constraint_solve_nearest(PyObject *s, PyObject *args) {
    PyObject *in_geometry = NULL;
    PedConstraint *constraint = NULL;
    PedGeometry *out_geometry = NULL;
    PedGeometry *geometry = NULL;
    _ped_Geometry *ret = NULL;

if (!PyArg_ParseTuple(args, "O!", &_ped_Geometry_Type_obj,
                          &in_geometry)) {
        return NULL;
    }

constraint = _ped_Constraint2PedConstraint(s);
    if (constraint == NULL) {
        return NULL;
    }

out_geometry = _ped_Geometry2PedGeometry(in_geometry);
    if (out_geometry == NULL) {
        ped_constraint_destroy(constraint);
        return NULL;
    }

geometry = ped_constraint_solve_nearest(constraint, out_geometry);

ped_constraint_destroy(constraint);

if (geometry) {
        ret = PedGeometry2_ped_Geometry(geometry);
    }
    else {
        PyErr_SetString(PyExc_ArithmeticError, "Could not find region nearest to constraint for given geometry");
        return NULL;
    }

return (PyObject *) ret;
}

PyObject *py_ped_constraint_is_solution(PyObject *s, PyObject *args) {
    PyObject *in_geometry = NULL;
    PedConstraint *constraint = NULL;
    PedGeometry *out_geometry = NULL;
    int ret = 0;

if (!PyArg_ParseTuple(args, "O!", &_ped_Geometry_Type_obj,
                          &in_geometry)) {
        return NULL;
    }

constraint = _ped_Constraint2PedConstraint(s);
    if (constraint == NULL) {
        return NULL;
    }

out_geometry = _ped_Geometry2PedGeometry(in_geometry);
    if (out_geometry == NULL) {
        ped_constraint_destroy(constraint);
        return NULL;
    }

ret = ped_constraint_is_solution(constraint, out_geometry);
    ped_constraint_destroy(constraint);

if (ret) {
        Py_RETURN_TRUE;
    } else {
        Py_RETURN_FALSE;
    }
}

PyObject *py_ped_constraint_any(PyObject *s, PyObject *args) {
    PyObject *in_device = NULL;
    PedDevice *out_device = NULL;
    PedConstraint *constraint = NULL;
    _ped_Constraint *ret = NULL;

if (!PyArg_ParseTuple(args, "O!", &_ped_Device_Type_obj, &in_device)) {
        return NULL;
    }

out_device = _ped_Device2PedDevice(in_device);
    if (out_device == NULL) {
        return NULL;
    }

constraint = ped_constraint_any(out_device);
    if (constraint) {
        ret = PedConstraint2_ped_Constraint(constraint);
    }
    else {
        PyErr_SetString(CreateException, "Could not create new constraint");
        return NULL;
    }

ped_constraint_destroy(constraint);

return (PyObject *) ret;
}

PyObject *py_ped_constraint_exact(PyObject *s, PyObject *args) {
    PyObject *in_geometry = NULL;
    PedGeometry *out_geometry = NULL;
    PedConstraint *constraint = NULL;
    _ped_Constraint *ret = NULL;

if (!PyArg_ParseTuple(args, "O!", &_ped_Geometry_Type_obj, &in_geometry)) {
        return NULL;
    }

out_geometry = _ped_Geometry2PedGeometry(in_geometry);
    if (out_geometry == NULL) {
        return NULL;
    }

constraint = ped_constraint_exact(out_geometry);
    if (constraint) {
        ret = PedConstraint2_ped_Constraint(constraint);
    }
    else {
        PyErr_SetString(CreateException, "Could not create exact constraint");
        return NULL;
    }

ped_constraint_destroy(constraint);

return (PyObject *) ret;
}

/* vim:tw=78:ts=4:et:sw=4
 */
0707010011583C000081A40000FFFE0000FFFD0000000157CD697A000025B5000000FC0000001000000000000000000000002A00000000pyparted-1466619794.7a0f829/src/pytimer.c/*
 * pytimer.c
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Chris Lumens <clumens@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#include <Python.h>

#include "convert.h"
#include "exceptions.h"
#include "pytimer.h"
#include "typeobjects/pytimer.h"

/* _ped.Timer functions */
void _ped_Timer_dealloc(_ped_Timer *self) {
    PyObject_GC_UnTrack(self);
    free(self->state_name);
    PyObject_GC_Del(self);
}

int _ped_Timer_compare(_ped_Timer *self, PyObject *obj) {
    _ped_Timer *comp = NULL;
    int check = PyObject_IsInstance(obj, (PyObject *) &_ped_Timer_Type_obj);

if (PyErr_Occurred()) {
        return -1;
    }

if (!check) {
        PyErr_SetString(PyExc_ValueError, "object comparing to must be a _ped.Timer");
        return -1;
    }

comp = (_ped_Timer *) obj;
    if ((self->frac == comp->frac) &&
        (self->start == comp->start) &&
        (self->now == comp->now) &&
        (self->predicted_end == comp->predicted_end) &&
        (!strcmp(self->state_name, comp->state_name)) &&
        (self->handler == comp->handler) &&
        (self->context == comp->context)) {
        return 0;
    } else {
        return 1;
    }
}

PyObject *_ped_Timer_richcompare(_ped_Timer *a, PyObject *b, int op) {
    if (op == Py_EQ || op == Py_NE) {
        int rv = _ped_Timer_compare(a, b);
        if (PyErr_Occurred())
            return NULL;
        return PyBool_FromLong(op == Py_EQ ? rv == 0 : rv != 0);
    } else if ((op == Py_LT) || (op == Py_LE) ||
               (op == Py_GT) || (op == Py_GE)) {
        PyErr_SetString(PyExc_TypeError, "comparison operator not supported for _ped.Timer");
        return NULL;
    } else {
        PyErr_SetString(PyExc_ValueError, "unknown richcompare op");
        return NULL;
    }
}

PyObject *_ped_Timer_str(_ped_Timer *self) {
    char *ret = NULL;

if (asprintf(&ret, "_ped.Timer instance --\n"
                       "  start: %s  now:  %s\n"
                       "  predicted_end: %s  frac: %f\n"
                       "  state_name: %s",
                 ctime(&(self->start)), ctime(&(self->now)),
                 ctime(&(self->predicted_end)), self->frac,
                 self->state_name) == -1) {
        return PyErr_NoMemory();
    }

return Py_BuildValue("s", ret);
}

int _ped_Timer_traverse(_ped_Timer *self, visitproc visit, void *arg) {
    return 0;
}

int _ped_Timer_clear(_ped_Timer *self) {
    return 0;
}

int _ped_Timer_init(_ped_Timer *self, PyObject *args, PyObject *kwds) {
    static char *kwlist[] = {"frac", "start", "now", "predicted_end",
                             "state_name", NULL};

self->state_name = NULL;

/* XXX: timers aren't really done yet in pyparted */
    PyErr_SetString(PyExc_NotImplementedError, NULL);
    return -1;

if (kwds == NULL) {
        if (!PyArg_ParseTuple(args, "|fdddz", &self->frac, &self->start,
                              &self->now, &self->predicted_end,
                              &self->state_name))
            return -1;
    } else {
        if (!PyArg_ParseTupleAndKeywords(args, kwds, "|fdddz", kwlist,
                                         &self->frac, &self->start, &self->now,
                                         &self->predicted_end, &self->state_name))
            return -2;
    }

/* self->state_name now points to the internal buffer of a PyUnicode object,
      * which may be freed when its refcount drops to zero, so strdup it.
      */
     if (self->state_name) {
         self->state_name = strdup(self->state_name);
         if (!self->state_name) {
             PyErr_NoMemory();
             return -3;
         }
     }

return 0;
}

PyObject *_ped_Timer_get(_ped_Timer *self, void *closure) {
    char *member = (char *) closure;

if (member == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.Timer()");
        return NULL;
    }

if (!strcmp(member, "frac")) {
        return Py_BuildValue("f", self->frac);
    } else if (!strcmp(member, "start")) {
        return Py_BuildValue("d", self->start);
    } else if (!strcmp(member, "now")) {
        return Py_BuildValue("d", self->now);
    } else if (!strcmp(member, "predicted_end")) {
        return Py_BuildValue("d", self->predicted_end);
    } else if (!strcmp(member, "state_name")) {
        if (self->state_name != NULL)
            return PyUnicode_FromString(self->state_name);
        else
            return PyUnicode_FromString("");
    } else {
        PyErr_Format(PyExc_AttributeError, "_ped.Timer object has no attribute %s", member);
        return NULL;
    }
}

int _ped_Timer_set(_ped_Timer *self, PyObject *value, void *closure) {
    char *member = (char *) closure;

if (member == NULL) {
        PyErr_SetString(PyExc_TypeError, "Empty _ped.Timer()");
        return -1;
    }

if (!strcmp(member, "frac")) {
        if (!PyArg_ParseTuple(value, "f", &self->frac)) {
            return -1;
        }
    } else if (!strcmp(member, "start")) {
        self->start = PyFloat_AsDouble(value);
        if (PyErr_Occurred()) {
            return -1;
        }
    } else if (!strcmp(member, "now")) {
        self->now = PyFloat_AsDouble(value);
        if (PyErr_Occurred()) {
            return -1;
        }
    } else if (!strcmp(member, "predicted_end")) {
        self->predicted_end = PyFloat_AsDouble(value);
        if (PyErr_Occurred()) {
            return -1;
        }
    } else if (!strcmp(member, "state_name")) {
        self->state_name = PyUnicode_AsUTF8(value);
        if (PyErr_Occurred()) {
            return -1;
        }
        /* self->state_name now points to the internal buffer of a PyUnicode obj
         * which may be freed when its refcount drops to zero, so strdup it.
         */
        if (self->state_name) {
            self->state_name = strdup(self->state_name);
            if (!self->state_name) {
                PyErr_NoMemory();
                return -2;
            }
        }
    } else {
        PyErr_Format(PyExc_AttributeError, "_ped.Timer object has no attribute %s", member);
        return -1;
    }

return 0;
}

/* 1:1 function mappings for timer.h in libparted */
PyObject *py_ped_timer_destroy(PyObject *s, PyObject *args) {
    Py_CLEAR(s);

Py_INCREF(Py_None);
    return Py_None;
}

PyObject *py_ped_timer_new_nested(PyObject *s, PyObject *args) {
    float nest_frac;
    PedTimer *parent = NULL, *timer = NULL;
    _ped_Timer *ret = NULL;

if (!PyArg_ParseTuple(args, "f", &nest_frac))
        return NULL;

parent = _ped_Timer2PedTimer(s);
    if (parent == NULL) {
        return NULL;
    }

timer = ped_timer_new_nested(parent, nest_frac);

ped_timer_destroy(parent);

if (timer) {
        ret = PedTimer2_ped_Timer(timer);
    }
    else {
        PyErr_SetString(CreateException, "Could not create new nested timer");
        return NULL;
    }

ped_timer_destroy(timer);

return (PyObject *) ret;
}

PyObject *py_ped_timer_destroy_nested(PyObject *s, PyObject *args) {
    PedTimer *timer = NULL;

timer = _ped_Timer2PedTimer(s);
    if (timer == NULL) {
        return NULL;
    }

ped_timer_destroy_nested(timer);
    ped_timer_destroy(timer);
    Py_CLEAR(s);

Py_INCREF(Py_None);
    return Py_None;
}

PyObject *py_ped_timer_touch(PyObject *s, PyObject *args) {
    PedTimer *timer = NULL;

timer = _ped_Timer2PedTimer(s);
    if (timer == NULL) {
        return NULL;
    }

ped_timer_touch(timer);
    ped_timer_destroy(timer);

Py_INCREF(Py_None);
    return Py_None;
}

PyObject *py_ped_timer_reset(PyObject *s, PyObject *args) {
    PedTimer *timer = NULL;

timer = _ped_Timer2PedTimer(s);
    if (timer == NULL) {
        return NULL;
    }

ped_timer_reset(timer);
    ped_timer_destroy(timer);

Py_INCREF(Py_None);
    return Py_None;
}

PyObject *py_ped_timer_update(PyObject *s, PyObject *args) {
    float frac;
    PedTimer *timer = NULL;

if (!PyArg_ParseTuple(args, "f", &frac))
        return NULL;

timer = _ped_Timer2PedTimer(s);
    if (timer == NULL) {
        return NULL;
    }

ped_timer_update(timer, frac);
    ped_timer_destroy(timer);

Py_INCREF(Py_None);
    return Py_None;
}

PyObject *py_ped_timer_set_state_name(PyObject *s, PyObject *args) {
    char *str = NULL;
    PedTimer *timer = NULL;

if (!PyArg_ParseTuple(args, "z", &str)) {
        return NULL;
    }

timer = _ped_Timer2PedTimer(s);
    if (timer == NULL) {
        return NULL;
    }

ped_timer_set_state_name(timer, str);

ped_timer_destroy(timer);
    free(str);

Py_INCREF(Py_None);
    return Py_None;
}

/* vim:tw=78:ts=4:et:sw=4
 */
07070100115842000041ED0000FFFE0000FFFD0000000257CD697A00000000000000FC0000001000000000000000000000003500000000pyparted-1466619794.7a0f829/.git/refs/remotes/origin07070100115841000041ED0000FFFE0000FFFD0000000357CD697A00000000000000FC0000001000000000000000000000002E00000000pyparted-1466619794.7a0f829/.git/refs/remotes07070100115844000041ED0000FFFE0000FFFD0000000257CD697A00000000000000FC0000001000000000000000000000002C00000000pyparted-1466619794.7a0f829/.git/refs/heads07070100115846000041ED0000FFFE0000FFFD0000000257CD697300000000000000FC0000001000000000000000000000002B00000000pyparted-1466619794.7a0f829/.git/refs/tags0707010011584A000041ED0000FFFE0000FFFD0000000257CD697A00000000000000FC0000001000000000000000000000002E00000000pyparted-1466619794.7a0f829/.git/objects/pack0707010011584D000041ED0000FFFE0000FFFD0000000257CD697300000000000000FC0000001000000000000000000000002E00000000pyparted-1466619794.7a0f829/.git/objects/info07070100115853000041ED0000FFFE0000FFFD0000000257CD697A00000000000000FC0000001000000000000000000000003A00000000pyparted-1466619794.7a0f829/.git/logs/refs/remotes/origin07070100115852000041ED0000FFFE0000FFFD0000000357CD697A00000000000000FC0000001000000000000000000000003300000000pyparted-1466619794.7a0f829/.git/logs/refs/remotes07070100115855000041ED0000FFFE0000FFFD0000000257CD697A00000000000000FC0000001000000000000000000000003100000000pyparted-1466619794.7a0f829/.git/logs/refs/heads07070100115851000041ED0000FFFE0000FFFD0000000457CD697A00000000000000FC0000001000000000000000000000002B00000000pyparted-1466619794.7a0f829/.git/logs/refs07070100115840000041ED0000FFFE0000FFFD0000000557CD697A00000000000000FC0000001000000000000000000000002600000000pyparted-1466619794.7a0f829/.git/refs07070100115847000041ED0000FFFE0000FFFD0000000257CD697300000000000000FC0000001000000000000000000000002A00000000pyparted-1466619794.7a0f829/.git/branches07070100115849000041ED0000FFFE0000FFFD0000000457CD697300000000000000FC0000001000000000000000000000002900000000pyparted-1466619794.7a0f829/.git/objects0707010011584F000041ED0000FFFE0000FFFD0000000357CD697A00000000000000FC0000001000000000000000000000002600000000pyparted-1466619794.7a0f829/.git/logs07070100115857000041ED0000FFFE0000FFFD0000000257CD697300000000000000FC0000001000000000000000000000002700000000pyparted-1466619794.7a0f829/.git/hooks07070100115863000041ED0000FFFE0000FFFD0000000257CD697300000000000000FC0000001000000000000000000000002600000000pyparted-1466619794.7a0f829/.git/info0707010011586C000081A40000FFFE0000FFFD0000000157CD697A00000FFD000000FC0000001000000000000000000000003A00000000pyparted-1466619794.7a0f829/include/typeobjects/pytimer.h/*
 * pytimer.h
 * pyparted type objects for pytimer.c
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Chris Lumens <clumens@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#ifndef TYPEOBJECTS_PYTIMER_H_INCLUDED
#define TYPEOBJECTS_PYTIMER_H_INCLUDED

#include <Python.h>
#include <structmember.h>

/* _ped.Timer type object */
static PyMemberDef _ped_Timer_members[] = {
    {NULL}
};

static PyMethodDef _ped_Timer_methods[] = {
    {"destroy", (PyCFunction) py_ped_timer_destroy, METH_VARARGS, NULL},
    {"new_nested", (PyCFunction) py_ped_timer_new_nested, METH_VARARGS, NULL},
    {"destroy_nested", (PyCFunction) py_ped_timer_destroy_nested,
                       METH_VARARGS, NULL},
    {"touch", (PyCFunction) py_ped_timer_touch, METH_VARARGS, NULL},
    {"reset", (PyCFunction) py_ped_timer_reset, METH_VARARGS, NULL},
    {"update", (PyCFunction) py_ped_timer_update, METH_VARARGS, NULL},
    {"set_state_name", (PyCFunction) py_ped_timer_set_state_name,
                       METH_VARARGS, NULL},
    {NULL}
};

static PyGetSetDef _ped_Timer_getset[] = {
    {"frac", (getter) _ped_Timer_get, (setter) _ped_Timer_set,
             "PedTimer frac", "frac"},
    {"start", (getter) _ped_Timer_get, (setter) _ped_Timer_set,
              "PedTimer.start", "start"},
    {"now", (getter) _ped_Timer_get, (setter) _ped_Timer_set,
            "PedTimer.now", "now"},
    {"predicted_end", (getter) _ped_Timer_get, (setter) _ped_Timer_set,
                      "PedTimer.predicted_end", "predicted_end"},
    {"state_name", (getter) _ped_Timer_get, (setter) _ped_Timer_set,
                   "PedTimer.state_name", "state_name"},
    {NULL}  /* Sentinel */
};

PyTypeObject _ped_Timer_Type_obj = {
    PyVarObject_HEAD_INIT(&PyType_Type,0)
    .tp_name = "_ped.Timer",
    .tp_basicsize = sizeof(_ped_Timer),
 /* .tp_itemsize = XXX */
    .tp_dealloc = (destructor) _ped_Timer_dealloc,
 /* .tp_getattr = XXX */
 /* .tp_setattr = XXX */
 /* .tp_repr = XXX */
 /* .tp_as_number = XXX */
 /* .tp_as_sequence = XXX */
 /* .tp_as_mapping = XXX */
    .tp_hash = PyObject_HashNotImplemented,
    .tp_call = NULL,
    .tp_str = (reprfunc) _ped_Timer_str,
    .tp_getattro = PyObject_GenericGetAttr,
    .tp_setattro = PyObject_GenericSetAttr,
 /* .tp_as_buffer = XXX */
    .tp_flags = TP_FLAGS,
    .tp_doc = "PedTimer objects",
    .tp_traverse = (traverseproc) _ped_Timer_traverse,
    .tp_clear = (inquiry) _ped_Timer_clear,
    .tp_richcompare = (richcmpfunc) _ped_Timer_richcompare,
 /* .tp_weaklistoffset = XXX */
 /* .tp_iter = XXX */
 /* .tp_iternext = XXX */
    .tp_methods = _ped_Timer_methods,
    .tp_members = _ped_Timer_members,
    .tp_getset = _ped_Timer_getset,
    .tp_base = NULL,
    .tp_dict = NULL,
 /* .tp_descr_get = XXX */
 /* .tp_descr_set = XXX */
 /* .tp_dictoffset = XXX */
    .tp_init = (initproc) _ped_Timer_init,
    .tp_alloc = PyType_GenericAlloc,
    .tp_new = PyType_GenericNew,
 /* .tp_free = XXX */
 /* .tp_is_gc = XXX */
    .tp_bases = NULL,
 /* .tp_del = XXX */
};

#endif /* TYPEOBJECTS_PYTIMER_H_INCLUDED */

/* vim:tw=78:ts=4:et:sw=4
 */
0707010011586D000081A40000FFFE0000FFFD0000000157CD697A00000FE4000000FC0000001000000000000000000000003C00000000pyparted-1466619794.7a0f829/include/typeobjects/pynatmath.h/*
 * pynatmath.h
 * pyparted type objects for pynatmath.c
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Chris Lumens <clumens@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#ifndef TYPEOBJECTS_PYNATMATH_H_INCLUDED
#define TYPEOBJECTS_PYNATMATH_H_INCLUDED

#include <Python.h>
#include <structmember.h>

/* _ped.Alignment type object */
static PyMemberDef _ped_Alignment_members[] = {
    {NULL}
};

static PyMethodDef _ped_Alignment_methods[] = {
    {"duplicate", (PyCFunction) py_ped_alignment_duplicate, METH_VARARGS,
                  alignment_duplicate_doc},
    {"intersect", (PyCFunction) py_ped_alignment_intersect, METH_VARARGS,
                  alignment_intersect_doc},
    {"align_up", (PyCFunction) py_ped_alignment_align_up, METH_VARARGS,
                 alignment_align_up_doc},
    {"align_down", (PyCFunction) py_ped_alignment_align_down,
                   METH_VARARGS, alignment_align_down_doc},
    {"align_nearest", (PyCFunction) py_ped_alignment_align_nearest,
                      METH_VARARGS, alignment_align_nearest_doc},
    {"is_aligned", (PyCFunction) py_ped_alignment_is_aligned,
                   METH_VARARGS, alignment_is_aligned_doc},
    {NULL}
};

static PyGetSetDef _ped_Alignment_getset[] = {
    {"offset", (getter) _ped_Alignment_get,
               (setter) _ped_Alignment_set,
               "Offset in sectors from the start of a _ped.Geometry.", "offset"},
    {"grain_size", (getter) _ped_Alignment_get,
                   (setter) _ped_Alignment_set,
                   "Alignment grain_size", "grain_size"},
    {NULL}  /* Sentinel */
};

PyTypeObject _ped_Alignment_Type_obj = {
    PyVarObject_HEAD_INIT(&PyType_Type,0)
    .tp_name = "_ped.Alignment",
    .tp_basicsize = sizeof(_ped_Alignment),
 /* .tp_itemsize = XXX */
    .tp_dealloc = (destructor) _ped_Alignment_dealloc,
 /* .tp_getattr = XXX */
 /* .tp_setattr = XXX */
 /* .tp_repr = XXX */
 /* .tp_as_number = XXX */
 /* .tp_as_sequence = XXX */
 /* .tp_as_mapping = XXX */
    .tp_hash = PyObject_HashNotImplemented,
    .tp_call = NULL,
    .tp_str = (reprfunc) _ped_Alignment_str,
    .tp_getattro = PyObject_GenericGetAttr,
    .tp_setattro = PyObject_GenericSetAttr,
 /* .tp_as_buffer = XXX */
    .tp_flags = TP_FLAGS,
    .tp_doc = _ped_Alignment_doc,
    .tp_traverse = (traverseproc) _ped_Alignment_traverse,
    .tp_clear = (inquiry) _ped_Alignment_clear,
    .tp_richcompare = (richcmpfunc) _ped_Alignment_richcompare,
 /* .tp_weaklistoffset = XXX */
 /* .tp_iter = XXX */
 /* .tp_iternext = XXX */
    .tp_methods = _ped_Alignment_methods,
    .tp_members = _ped_Alignment_members,
    .tp_getset = _ped_Alignment_getset,
    .tp_base = NULL,
    .tp_dict = NULL,
 /* .tp_descr_get = XXX */
 /* .tp_descr_set = XXX */
 /* .tp_dictoffset = XXX */
    .tp_init = (initproc) _ped_Alignment_init,
    .tp_alloc = PyType_GenericAlloc,
    .tp_new = PyType_GenericNew,
 /* .tp_free = XXX */
 /* .tp_is_gc = XXX */
    .tp_bases = NULL,
 /* .tp_del = XXX */
};

#endif /* TYPEOBJECTS_PYNATMATH_H_INCLUDED */

/* vim:tw=78:ts=4:et:sw=4
 */
0707010011586E000081A40000FFFE0000FFFD0000000157CD697A0000148E000000FC0000001000000000000000000000003900000000pyparted-1466619794.7a0f829/include/typeobjects/pygeom.h/*
 * pygeom.h
 * pyparted type objects for pygeom.c
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Chris Lumens <clumens@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#ifndef TYPEOBJECTS_PYGEOM_H_INCLUDED
#define TYPEOBJECTS_PYGEOM_H_INCLUDED

#include <Python.h>
#include <structmember.h>

/* _ped.Geometry type object */
static PyMemberDef _ped_Geometry_members[] = {
    {"dev", T_OBJECT, offsetof(_ped_Geometry, dev), READONLY,
            "The _ped.Device described by this _ped.Geometry object."},
    {NULL}
};

static PyMethodDef _ped_Geometry_methods[] = {
    {"duplicate", (PyCFunction) py_ped_geometry_duplicate, METH_VARARGS,
                  geometry_duplicate_doc},
    {"intersect", (PyCFunction) py_ped_geometry_intersect, METH_VARARGS,
                  geometry_intersect_doc},
    {"set", (PyCFunction) py_ped_geometry_set, METH_VARARGS,
            geometry_set_doc},
    {"set_start", (PyCFunction) py_ped_geometry_set_start, METH_VARARGS,
                  geometry_set_start_doc},
    {"set_end", (PyCFunction) py_ped_geometry_set_end, METH_VARARGS,
                geometry_set_end_doc},
    {"test_overlap", (PyCFunction) py_ped_geometry_test_overlap,
                     METH_VARARGS, geometry_test_overlap_doc},
    {"test_inside", (PyCFunction) py_ped_geometry_test_inside,
                    METH_VARARGS, geometry_test_inside_doc},
    {"test_equal", (PyCFunction) py_ped_geometry_test_equal,
                   METH_VARARGS, geometry_test_equal_doc},
    {"test_sector_inside", (PyCFunction) py_ped_geometry_test_sector_inside,
                           METH_VARARGS, geometry_test_sector_inside_doc},
    {"read", (PyCFunction) py_ped_geometry_read, METH_VARARGS,
             geometry_read_doc},
    {"sync", (PyCFunction) py_ped_geometry_sync, METH_VARARGS,
             geometry_sync_doc},
    {"sync_fast", (PyCFunction) py_ped_geometry_sync_fast, METH_VARARGS,
                  geometry_sync_fast_doc},
    {"write", (PyCFunction) py_ped_geometry_write, METH_VARARGS,
              geometry_write_doc},
    {"check", (PyCFunction) py_ped_geometry_check, METH_VARARGS,
              geometry_check_doc},
    {"map", (PyCFunction) py_ped_geometry_map, METH_VARARGS,
            geometry_map_doc},
    {NULL}
};

static PyGetSetDef _ped_Geometry_getset[] = {
    {"start", (getter) _ped_Geometry_get,
              (setter) _ped_Geometry_set,
              "The starting Sector of the region.", "start"},
    {"length", (getter) _ped_Geometry_get,
               (setter) _ped_Geometry_set,
               "The length of the region described by this Geometry object.",
               "length"},
    {"end", (getter) _ped_Geometry_get,
            (setter) _ped_Geometry_set,
            "The ending Sector of the region.", "end"},
    {NULL}  /* Sentinel */
};

PyTypeObject _ped_Geometry_Type_obj = {
    PyVarObject_HEAD_INIT(&PyType_Type,0)
    .tp_name = "_ped.Geometry",
    .tp_basicsize = sizeof(_ped_Geometry),
 /* .tp_itemsize = XXX */
    .tp_dealloc = (destructor) _ped_Geometry_dealloc,
 /* .tp_getattr = XXX */
 /* .tp_setattr = XXX */
 /* .tp_repr = XXX */
 /* .tp_as_number = XXX */
 /* .tp_as_sequence = XXX */
 /* .tp_as_mapping = XXX */
    .tp_hash = PyObject_HashNotImplemented,
    .tp_call = NULL,
    .tp_str = (reprfunc) _ped_Geometry_str,
    .tp_getattro = PyObject_GenericGetAttr,
    .tp_setattro = PyObject_GenericSetAttr,
 /* .tp_as_buffer = XXX */
    .tp_flags = TP_FLAGS,
    .tp_doc = _ped_Geometry_doc,
    .tp_traverse = (traverseproc) _ped_Geometry_traverse,
    .tp_clear = (inquiry) _ped_Geometry_clear,
    .tp_richcompare = (richcmpfunc) _ped_Geometry_richcompare,
 /* .tp_weaklistoffset = XXX */
 /* .tp_iter = XXX */
 /* .tp_iternext = XXX */
    .tp_methods = _ped_Geometry_methods,
    .tp_members = _ped_Geometry_members,
    .tp_getset = _ped_Geometry_getset,
    .tp_base = NULL,
    .tp_dict = NULL,
 /* .tp_descr_get = XXX */
 /* .tp_descr_set = XXX */
 /* .tp_dictoffset = XXX */
    .tp_init = (initproc) _ped_Geometry_init,
    .tp_alloc = PyType_GenericAlloc,
    .tp_new = PyType_GenericNew,
 /* .tp_free = XXX */
 /* .tp_is_gc = XXX */
    .tp_bases = NULL,
 /* .tp_del = XXX */
};

#endif /* TYPEOBJECTS_PYGEOM_H_INCLUDED */

/* vim:tw=78:ts=4:et:sw=4
 */
0707010011586F000081A40000FFFE0000FFFD0000000157CD697A00002918000000FC0000001000000000000000000000003B00000000pyparted-1466619794.7a0f829/include/typeobjects/pydevice.h/*
 * pydevice.h
 * pyparted type objects for pydevice.c
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Chris Lumens <clumens@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#ifndef TYPEOBJECTS_PYDEVICE_H_INCLUDED
#define TYPEOBJECTS_PYDEVICE_H_INCLUDED
#define PyGC_HEAD_SIZE 0
#include <Python.h>
#include <structmember.h>

/* _ped.CHSGeometry type object */
static PyMemberDef _ped_CHSGeometry_members[] = {
    {NULL}
};

static PyMethodDef _ped_CHSGeometry_methods[] = {
    {NULL}
};

static PyGetSetDef _ped_CHSGeometry_getset[] = {
    {"cylinders", (getter) _ped_CHSGeometry_get,
                  NULL,
                  "The number of cylinders.", "cylinders"},
    {"heads", (getter) _ped_CHSGeometry_get,
              NULL,
              "The number of heads", "heads"},
    {"sectors", (getter) _ped_CHSGeometry_get,
                NULL,
                "The number of sectors", "sectors"},
    {NULL}  /* Sentinel */
};

PyTypeObject _ped_CHSGeometry_Type_obj = {
    PyVarObject_HEAD_INIT(&PyType_Type,0)
    .tp_name = "_ped.CHSGeometry",
    .tp_basicsize = sizeof(_ped_CHSGeometry),
 /* .tp_itemsize = XXX */
    .tp_dealloc = (destructor) _ped_CHSGeometry_dealloc,
 /* .tp_getattr = XXX */
 /* .tp_setattr = XXX */
 /* .tp_repr = XXX */
 /* .tp_as_number = XXX */
 /* .tp_as_sequence = XXX */
 /* .tp_as_mapping = XXX */
    .tp_hash = PyObject_HashNotImplemented,
    .tp_call = NULL,
    .tp_str = (reprfunc) _ped_CHSGeometry_str,
    .tp_getattro = PyObject_GenericGetAttr,
    .tp_setattro = PyObject_GenericSetAttr,
 /* .tp_as_buffer = XXX */
    .tp_flags = TP_FLAGS,
    .tp_doc = _ped_CHSGeometry_doc,
    .tp_traverse = (traverseproc) _ped_CHSGeometry_traverse,
    .tp_clear = (inquiry) _ped_CHSGeometry_clear,
    .tp_richcompare = (richcmpfunc) _ped_CHSGeometry_richcompare,
 /* .tp_weaklistoffset = XXX */
 /* .tp_iter = XXX */
 /* .tp_iternext = XXX */
    .tp_methods = _ped_CHSGeometry_methods,
    .tp_members = _ped_CHSGeometry_members,
    .tp_getset = _ped_CHSGeometry_getset,
    .tp_base = NULL,
    .tp_dict = NULL,
 /* .tp_descr_get = XXX */
 /* .tp_descr_set = XXX */
 /* .tp_dictoffset = XXX */
    .tp_init = NULL,
    .tp_alloc = PyType_GenericAlloc,
    .tp_new = NULL,
 /* .tp_free = XXX */
 /* .tp_is_gc = XXX */
    .tp_bases = NULL,
 /* .tp_del = XXX */
};

/* _ped.Device type object */
static PyMemberDef _ped_Device_members[] = {
    {"hw_geom", T_OBJECT, offsetof(_ped_Device, hw_geom), READONLY,
                "The CHSGeometry of the Device as reported by the hardware."},
    {"bios_geom", T_OBJECT, offsetof(_ped_Device, bios_geom), READONLY,
                  "The CHSGeometry of the Device as reported by the BIOS."},
    {NULL}
};

static PyMethodDef _ped_Device_methods[] = {
    /*
     * This is a unique function as it's in pydisk.c, but is really
     * a method on _ped.Device, so it's part of this PyMethod Def
     */
    {"disk_probe", (PyCFunction) py_ped_disk_probe, METH_VARARGS,
                   disk_probe_doc},

/* These functions are all in pydevice.c */
    {"is_busy", (PyCFunction) py_ped_device_is_busy, METH_VARARGS,
                device_is_busy_doc},
    {"open", (PyCFunction) py_ped_device_open, METH_VARARGS,
             device_open_doc},
    {"close", (PyCFunction) py_ped_device_close, METH_VARARGS,
              device_close_doc},
    {"destroy", (PyCFunction) py_ped_device_destroy, METH_VARARGS,
                device_destroy_doc},
    {"cache_remove", (PyCFunction) py_ped_device_cache_remove,
                     METH_VARARGS, device_cache_remove_doc},
    {"begin_external_access", (PyCFunction) py_ped_device_begin_external_access,
                              METH_VARARGS, device_begin_external_access_doc},
    {"end_external_access", (PyCFunction) py_ped_device_end_external_access,
                            METH_VARARGS, device_end_external_access_doc},
    {"read", (PyCFunction) py_ped_device_read, METH_VARARGS,
             device_read_doc},
    {"write", (PyCFunction) py_ped_device_write, METH_VARARGS,
              device_write_doc},
    {"sync", (PyCFunction) py_ped_device_sync, METH_VARARGS,
             device_sync_doc},
    {"sync_fast", (PyCFunction) py_ped_device_sync_fast, METH_VARARGS,
                  device_sync_fast_doc},
    {"check", (PyCFunction) py_ped_device_check, METH_VARARGS,
              device_check_doc},
    {"get_constraint", (PyCFunction) py_ped_device_get_constraint,
                       METH_VARARGS, device_get_constraint_doc},
    {"get_minimal_aligned_constraint",
                  (PyCFunction) py_ped_device_get_minimal_aligned_constraint,
                  METH_NOARGS, device_get_minimal_aligned_constraint_doc},
    {"get_optimal_aligned_constraint",
                  (PyCFunction) py_ped_device_get_optimal_aligned_constraint,
                  METH_NOARGS, device_get_optimal_aligned_constraint_doc},
    {"get_minimum_alignment",
                  (PyCFunction) py_ped_device_get_minimum_alignment,
                  METH_NOARGS, device_get_minimum_alignment_doc},
    {"get_optimum_alignment",
                  (PyCFunction) py_ped_device_get_optimum_alignment,
                  METH_NOARGS, device_get_optimum_alignment_doc},

/*
     * These functions are in pydisk.c, but they work best as
     * methods on a _ped.Device.
     */
    {"clobber", (PyCFunction) py_ped_disk_clobber, METH_VARARGS,
                disk_clobber_doc},

/*
     * These functions are in pyunit.c, but they work best as methods
     * on a _ped.Device
     */
    {"unit_get_size", (PyCFunction) py_ped_unit_get_size, METH_VARARGS,
                      unit_get_size_doc},
    {"unit_format_custom_byte", (PyCFunction) py_ped_unit_format_custom_byte,
                                METH_VARARGS, unit_format_custom_byte_doc},
    {"unit_format_byte", (PyCFunction) py_ped_unit_format_byte, METH_VARARGS,
                         unit_format_byte_doc},
    {"unit_format_custom", (PyCFunction) py_ped_unit_format_custom,
                           METH_VARARGS, unit_format_custom_doc},
    {"unit_format", (PyCFunction) py_ped_unit_format, METH_VARARGS,
                    unit_format_doc},
    {"unit_parse", (PyCFunction) py_ped_unit_parse, METH_VARARGS,
                   unit_parse_doc},
    {"unit_parse_custom", (PyCFunction) py_ped_unit_parse_custom,
                          METH_VARARGS, unit_parse_custom_doc},

{NULL}
};

static PyGetSetDef _ped_Device_getset[] = {
    {"model", (getter) _ped_Device_get, NULL,
              "A brief description of the hardware, usually mfr and model.",
              "model"},
    {"path", (getter) _ped_Device_get, NULL,
             "The operating system level path to the device node.", "path"},
    {"type", (getter) _ped_Device_get, NULL,
             "The type of device, deprecated in favor of PedDeviceType", "type"},
    {"sector_size", (getter) _ped_Device_get, NULL,
                    "Logical sector size.", "sector_size"},
    {"phys_sector_size", (getter) _ped_Device_get, NULL,
                         "Physical sector size.", "phys_sector_size"},
    {"length", (getter) _ped_Device_get, NULL,
               "Device length, in sectors (LBA).", "length"},
    {"open_count", (getter) _ped_Device_get, NULL,
                   "How many times self.open() has been called.", "open_count"},
    {"read_only", (getter) _ped_Device_get, NULL,
                  "Is the device opened in read-only mode?", "read_only"},
    {"external_mode", (getter) _ped_Device_get, NULL,
                      "PedDevice external_mode", "external_mode"},
    {"dirty", (getter) _ped_Device_get, NULL,
              "Have any unflushed changes been made to self?", "dirty"},
    {"boot_dirty", (getter) _ped_Device_get, NULL,
                   "Have any unflushed changes been made to the bootloader?",
                   "boot_dirty"},
    {"host", (getter) _ped_Device_get, NULL,
             "Any SCSI host ID associated with self.", "host"},
    {"did", (getter) _ped_Device_get, NULL,
            "Any SCSI device ID associated with self.", "did"},
    {NULL}  /* Sentinel */
};

PyTypeObject _ped_Device_Type_obj = {
    PyVarObject_HEAD_INIT(&PyType_Type,0)
    .tp_name = "_ped.Device",
    .tp_basicsize = PyGC_HEAD_SIZE + sizeof(_ped_Device),
    .tp_itemsize = 0,
    .tp_dealloc = (destructor) _ped_Device_dealloc,
 /* .tp_getattr = XXX */
 /* .tp_setattr = XXX */
 /* .tp_repr = XXX */
 /* .tp_as_number = XXX */
 /* .tp_as_sequence = XXX */
 /* .tp_as_mapping = XXX */
    .tp_hash = PyObject_HashNotImplemented,
    .tp_call = NULL,
    .tp_str = (reprfunc) _ped_Device_str,
    .tp_getattro = PyObject_GenericGetAttr,
    .tp_setattro = PyObject_GenericSetAttr,
 /* .tp_as_buffer = XXX */
    .tp_flags = TP_FLAGS,
    .tp_doc = _ped_Device_doc,
    .tp_traverse = (traverseproc) _ped_Device_traverse,
    .tp_clear = (inquiry) _ped_Device_clear,
    .tp_richcompare = (richcmpfunc) _ped_Device_richcompare,
 /* .tp_weaklistoffset = XXX */
 /* .tp_iter = XXX */
 /* .tp_iternext = XXX */
    .tp_methods = _ped_Device_methods,
    .tp_members = _ped_Device_members,
    .tp_getset = _ped_Device_getset,
    .tp_base = NULL,
    .tp_dict = NULL,
 /* .tp_descr_get = XXX */
 /* .tp_descr_set = XXX */
 /* .tp_dictoffset = XXX */
    .tp_init = NULL,
    .tp_alloc = PyType_GenericAlloc,
    .tp_new = NULL,
 /* .tp_free = XXX */
 /* .tp_is_gc = XXX */
    .tp_bases = NULL,
 /* .tp_del = XXX */
};

#endif /* TYPEOBJECTS_PYDEVICE_H_INCLUDED */

/* vim:tw=78:ts=4:et:sw=4
 */
07070100115871000081A40000FFFE0000FFFD0000000157CD697A00001270000000FC0000001000000000000000000000003F00000000pyparted-1466619794.7a0f829/include/typeobjects/pyconstraint.h/*
 * pyconstraint.h
 * pyparted type objects for pyconstraint.c
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Chris Lumens <clumens@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#ifndef TYPEOBJECTS_PYCONSTRAINT_H_INCLUDED
#define TYPEOBJECTS_PYCONSTRAINT_H_INCLUDED

#include <Python.h>
#include <structmember.h>

/* _ped.Constraint type object */
static PyMemberDef _ped_Constraint_members[] = {
    {"start_align", T_OBJECT, offsetof(_ped_Constraint, start_align), 0,
                    "The _ped.Alignment describing the starting alignment constraints of the partition."},
    {"end_align", T_OBJECT, offsetof(_ped_Constraint, end_align), 0,
                  "The _ped.Alignment describing the ending alignment constraints of the partition."},
    {"start_range", T_OBJECT, offsetof(_ped_Constraint, start_range), 0,
                    "The _ped.Geometry describing the minimum size constraints of the partition."},
    {"end_range", T_OBJECT, offsetof(_ped_Constraint, end_range), 0,
                  "The _ped.Geometry describing the maximum size constraints of the partition."},
    {NULL}
};

static PyMethodDef _ped_Constraint_methods[] = {
    {"duplicate", (PyCFunction) py_ped_constraint_duplicate,
                  METH_VARARGS, constraint_duplicate_doc},
    {"intersect", (PyCFunction) py_ped_constraint_intersect,
                  METH_VARARGS, constraint_intersect_doc},
    {"solve_max", (PyCFunction) py_ped_constraint_solve_max,
                  METH_VARARGS, constraint_solve_max_doc},
    {"solve_nearest", (PyCFunction) py_ped_constraint_solve_nearest,
                      METH_VARARGS, constraint_solve_nearest_doc},
    {"is_solution", (PyCFunction) py_ped_constraint_is_solution,
                    METH_VARARGS, constraint_is_solution_doc},
    {NULL}
};

static PyGetSetDef _ped_Constraint_getset[] = {
    {"min_size", (getter) _ped_Constraint_get,
                 (setter) _ped_Constraint_set,
                 "The mimimum size in _ped.Sectors of the partition.", "min_size"},
    {"max_size", (getter) _ped_Constraint_get,
                 (setter) _ped_Constraint_set,
                 "The maximum size in _ped.Sectors of the partition.", "max_size"},
    {NULL}  /* Sentinel */
};

PyTypeObject _ped_Constraint_Type_obj = {
    PyVarObject_HEAD_INIT(&PyType_Type,0)
    .tp_name = "_ped.Constraint",
    .tp_basicsize = sizeof(_ped_Constraint),
 /* .tp_itemsize = XXX */
    .tp_dealloc = (destructor) _ped_Constraint_dealloc,
 /* .tp_getattr = XXX */
 /* .tp_setattr = XXX */
 /* .tp_repr = XXX */
 /* .tp_as_number = XXX */
 /* .tp_as_sequence = XXX */
 /* .tp_as_mapping = XXX */
    .tp_hash = PyObject_HashNotImplemented,
    .tp_call = NULL,
    .tp_str = (reprfunc) _ped_Constraint_str,
    .tp_getattro = PyObject_GenericGetAttr,
    .tp_setattro = PyObject_GenericSetAttr,
 /* .tp_as_buffer = XXX */
    .tp_flags = TP_FLAGS,
    .tp_doc = _ped_Constraint_doc,
    .tp_traverse = (traverseproc) _ped_Constraint_traverse,
    .tp_clear = (inquiry) _ped_Constraint_clear,
    .tp_richcompare = (richcmpfunc) _ped_Constraint_richcompare,
 /* .tp_weaklistoffset = XXX */
 /* .tp_iter = XXX */
 /* .tp_iternext = XXX */
    .tp_methods = _ped_Constraint_methods,
    .tp_members = _ped_Constraint_members,
    .tp_getset = _ped_Constraint_getset,
    .tp_base = NULL,
    .tp_dict = NULL,
 /* .tp_descr_get = XXX */
 /* .tp_descr_set = XXX */
 /* .tp_dictoffset = XXX */
    .tp_init = (initproc) _ped_Constraint_init,
    .tp_alloc = PyType_GenericAlloc,
    .tp_new = PyType_GenericNew,
 /* .tp_free = XXX */
 /* .tp_is_gc = XXX */
    .tp_bases = NULL,
 /* .tp_del = XXX */
};

#endif /* TYPEOBJECTS_PYCONSTRAINT_H_INCLUDED */

/* vim:tw=78:ts=4:et:sw=4
 */
07070100115873000081A40000FFFE0000FFFD0000000157CD697A0000133C000000FC0000001000000000000000000000003C00000000pyparted-1466619794.7a0f829/include/typeobjects/pyfilesys.h/*
 * pyfilesys.h
 * pyparted type objects for pyfilesys.c
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Chris Lumens <clumens@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#ifndef TYPEOBJECTS_PYFILESYS_H_INCLUDED
#define TYPEOBJECTS_PYFILESYS_H_INCLUDED

#include <Python.h>
#include <structmember.h>

/* _ped.FileSystemType type object */
static PyMemberDef _ped_FileSystemType_members[] = {
    {NULL}
};

static PyMethodDef _ped_FileSystemType_methods[] = {
    {NULL}
};

static PyGetSetDef _ped_FileSystemType_getset[] = {
    {"name", (getter) _ped_FileSystemType_get, NULL,
             "The name of the FileSystemType.", "name"},
    {NULL}  /* Sentinel */
};

PyTypeObject _ped_FileSystemType_Type_obj = {
    PyVarObject_HEAD_INIT(&PyType_Type,0)
    .tp_name = "_ped.FileSystemType",
    .tp_basicsize = sizeof(_ped_FileSystemType),
 /* .tp_itemsize = XXX */
    .tp_dealloc = (destructor) _ped_FileSystemType_dealloc,
 /* .tp_getattr = XXX */
 /* .tp_setattr = XXX */
 /* .tp_repr = XXX */
 /* .tp_as_number = XXX */
 /* .tp_as_sequence = XXX */
 /* .tp_as_mapping = XXX */
    .tp_hash = PyObject_HashNotImplemented,
    .tp_call = NULL,
    .tp_str = (reprfunc) _ped_FileSystemType_str,
    .tp_getattro = PyObject_GenericGetAttr,
    .tp_setattro = PyObject_GenericSetAttr,
 /* .tp_as_buffer = XXX */
    .tp_flags = TP_FLAGS,
    .tp_doc = _ped_FileSystemType_doc,
    .tp_traverse = (traverseproc) _ped_FileSystemType_traverse,
    .tp_clear = (inquiry) _ped_FileSystemType_clear,
    .tp_richcompare = (richcmpfunc) _ped_FileSystemType_richcompare,
 /* .tp_weaklistoffset = XXX */
 /* .tp_iter = XXX */
 /* .tp_iternext = XXX */
    .tp_methods = _ped_FileSystemType_methods,
    .tp_members = _ped_FileSystemType_members,
    .tp_getset = _ped_FileSystemType_getset,
    .tp_base = NULL,
    .tp_dict = NULL,
 /* .tp_descr_get = XXX */
 /* .tp_descr_set = XXX */
 /* .tp_dictoffset = XXX */
    .tp_init = NULL,
    .tp_alloc = PyType_GenericAlloc,
    .tp_new = NULL,
 /* .tp_free = XXX */
 /* .tp_is_gc = XXX */
    .tp_bases = NULL,
 /* .tp_del = XXX */
};

/* _ped.FileSystem type object */
static PyMemberDef _ped_FileSystem_members[] = {
    {"type", T_OBJECT, offsetof(_ped_FileSystem, type), READONLY,
             "A _ped.FileSystemType object describing the filesystem on self.geom."},
    {"geom", T_OBJECT, offsetof(_ped_FileSystem, geom), READONLY,
             "The on-disk region where this FileSystem object exists."},
    {NULL}
};

PyTypeObject _ped_FileSystem_Type_obj = {
    PyVarObject_HEAD_INIT(&PyType_Type,0)
    .tp_name = "_ped.FileSystem",
    .tp_basicsize = sizeof(_ped_FileSystem),
 /* .tp_itemsize = XXX */
    .tp_dealloc = (destructor) _ped_FileSystem_dealloc,
 /* .tp_getattr = XXX */
 /* .tp_setattr = XXX */
 /* .tp_repr = XXX */
 /* .tp_as_number = XXX */
 /* .tp_as_sequence = XXX */
 /* .tp_as_mapping = XXX */
    .tp_hash = PyObject_HashNotImplemented,
    .tp_call = NULL,
    .tp_str = (reprfunc) _ped_FileSystem_str,
    .tp_getattro = PyObject_GenericGetAttr,
    .tp_setattro = PyObject_GenericSetAttr,
 /* .tp_as_buffer = XXX */
    .tp_flags = TP_FLAGS,
    .tp_doc = _ped_FileSystem_doc,
    .tp_traverse = (traverseproc) _ped_FileSystem_traverse,
    .tp_clear = (inquiry) _ped_FileSystem_clear,
    .tp_richcompare = (richcmpfunc) _ped_FileSystem_richcompare,
 /* .tp_weaklistoffset = XXX */
 /* .tp_iter = XXX */
 /* .tp_iternext = XXX */
 /* .tp_methods = XXX */
    .tp_members = _ped_FileSystem_members,
 /* .tp_getset = XXX */
    .tp_base = NULL,
    .tp_dict = NULL,
 /* .tp_descr_get = XXX */
 /* .tp_descr_set = XXX */
 /* .tp_dictoffset = XXX */
    .tp_init = (initproc) _ped_FileSystem_init,
    .tp_alloc = PyType_GenericAlloc,
    .tp_new = PyType_GenericNew,
 /* .tp_free = XXX */
 /* .tp_is_gc = XXX */
    .tp_bases = NULL,
 /* .tp_del = XXX */
};

#endif /* TYPEOBJECTS_PYFILESYS_H_INCLUDED */

/* vim:tw=78:ts=4:et:sw=4
 */
07070100115875000081A40000FFFE0000FFFD0000000157CD697A000034CB000000FC0000001000000000000000000000003900000000pyparted-1466619794.7a0f829/include/typeobjects/pydisk.h/*
 * pydisk.h
 * pyparted type objects for pydisk.c
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Chris Lumens <clumens@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#ifndef TYPEOBJECTS_PYDISK_H_INCLUDED
#define TYPEOBJECTS_PYDISK_H_INCLUDED

#include <Python.h>
#include <structmember.h>

/* _ped.Partition type object */
static PyMemberDef _ped_Partition_members[] = {
    {"disk", T_OBJECT, offsetof(_ped_Partition, disk), READONLY,
             "The _ped.Disk this Partition exists on."},
    {"geom", T_OBJECT, offsetof(_ped_Partition, geom), READONLY,
             "A _ped.Geometry object describing the region this Partition occupies."},
    {"fs_type", T_OBJECT, offsetof(_ped_Partition, fs_type), READONLY,
                "A _ped.FileSystemType object describing the filesystem on this Partition."},
    {NULL}
};

static PyMethodDef _ped_Partition_methods[] = {
    {"destroy", (PyCFunction) py_ped_partition_destroy, METH_VARARGS,
                partition_destroy_doc},
    {"is_active", (PyCFunction) py_ped_partition_is_active, METH_VARARGS,
                  partition_is_active_doc},
    {"set_flag", (PyCFunction) py_ped_partition_set_flag, METH_VARARGS,
                 partition_set_flag_doc},
    {"get_flag", (PyCFunction) py_ped_partition_get_flag, METH_VARARGS,
                 partition_get_flag_doc},
    {"is_flag_available", (PyCFunction) py_ped_partition_is_flag_available,
                          METH_VARARGS, partition_is_flag_available_doc},
    {"set_system", (PyCFunction) py_ped_partition_set_system,
                   METH_VARARGS, partition_set_system_doc},
    {"set_name", (PyCFunction) py_ped_partition_set_name, METH_VARARGS,
                 partition_set_name_doc},
    {"get_name", (PyCFunction) py_ped_partition_get_name, METH_VARARGS,
                 partition_get_name_doc},
    {"is_busy", (PyCFunction) py_ped_partition_is_busy, METH_VARARGS,
                partition_is_busy_doc},
    {"get_path", (PyCFunction) py_ped_partition_get_path, METH_VARARGS,
                 partition_get_path_doc},
    {"reset_num", (PyCFunction) py_ped_partition_reset_num, METH_VARARGS,
                  partition_reset_num_doc},
    {NULL}
};

static PyGetSetDef _ped_Partition_getset[] = {
    {"num", (getter) _ped_Partition_get, NULL,
            "The number of this Partition on self.disk.", "num"},
    {"type", (getter) _ped_Partition_get, (setter) _ped_Partition_set,
             "PedPartition type", "type"},
    {NULL}  /* Sentinel */
};

PyTypeObject _ped_Partition_Type_obj = {
    PyVarObject_HEAD_INIT(&PyType_Type,0)
    .tp_name = "_ped.Partition",
    .tp_basicsize = sizeof(_ped_Partition),
 /* .tp_itemsize = XXX */
    .tp_dealloc = (destructor) _ped_Partition_dealloc,
 /* .tp_getattr = XXX */
 /* .tp_setattr = XXX */
 /*   .tp_compare = (cmpfunc) _ped_Partition_compare,*/
 /* .tp_repr = XXX */
 /* .tp_as_number = XXX */
 /* .tp_as_sequence = XXX */
 /* .tp_as_mapping = XXX */
    .tp_hash = PyObject_HashNotImplemented,
    .tp_call = NULL,
    .tp_str = (reprfunc) _ped_Partition_str,
    .tp_getattro = PyObject_GenericGetAttr,
    .tp_setattro = PyObject_GenericSetAttr,
 /* .tp_as_buffer = XXX */
    .tp_flags = TP_FLAGS,
    .tp_doc = _ped_Partition_doc,
    .tp_traverse = (traverseproc) _ped_Partition_traverse,
    .tp_clear = (inquiry) _ped_Partition_clear,
    .tp_richcompare = (richcmpfunc) _ped_Partition_richcompare,
 /* .tp_weaklistoffset = XXX */
 /* .tp_iter = XXX */
 /* .tp_iternext = XXX */
    .tp_methods = _ped_Partition_methods,
    .tp_members = _ped_Partition_members,
    .tp_getset = _ped_Partition_getset,
    .tp_base = NULL,
    .tp_dict = NULL,
 /* .tp_descr_get = XXX */
 /* .tp_descr_set = XXX */
 /* .tp_dictoffset = XXX */
    .tp_init = (initproc) _ped_Partition_init,
    .tp_alloc = PyType_GenericAlloc,
    .tp_new = PyType_GenericNew,
 /* .tp_free = XXX */
 /* .tp_is_gc = XXX */
    .tp_bases = NULL,
 /* .tp_del = XXX */
};

/* _ped.Disk type object */
static PyMemberDef _ped_Disk_members[] = {
    {"dev", T_OBJECT, offsetof(_ped_Disk, dev), READONLY,
            "A _ped.Device object holding self's partition table."},
    {"type", T_OBJECT, offsetof(_ped_Disk, type), READONLY,
             "The type of the disk label as a _ped.DiskType."},
    {NULL}
};

static PyMethodDef _ped_Disk_methods[] = {
    {"duplicate", (PyCFunction) py_ped_disk_duplicate, METH_VARARGS,
                  disk_duplicate_doc},
    {"destroy", (PyCFunction) py_ped_disk_destroy, METH_VARARGS,
                disk_destroy_doc},
    {"commit", (PyCFunction) py_ped_disk_commit, METH_VARARGS,
               disk_commit_doc},
    {"commit_to_dev", (PyCFunction) py_ped_disk_commit_to_dev,
                      METH_VARARGS, disk_commit_to_dev_doc},
    {"commit_to_os", (PyCFunction) py_ped_disk_commit_to_os,
                     METH_VARARGS, disk_commit_to_os_doc},
    {"check", (PyCFunction) py_ped_disk_check, METH_VARARGS,
              disk_check_doc},
    {"print", (PyCFunction) py_ped_disk_print, METH_VARARGS,
              disk_print_doc},
    {"get_primary_partition_count", (PyCFunction)
                                    py_ped_disk_get_primary_partition_count,
                                    METH_VARARGS,
                                    disk_get_primary_partition_count_doc},
    {"get_last_partition_num", (PyCFunction)
                               py_ped_disk_get_last_partition_num,
                               METH_VARARGS,
                               disk_get_last_partition_num_doc},
    {"get_max_primary_partition_count", (PyCFunction)
                                   py_ped_disk_get_max_primary_partition_count,
                                   METH_VARARGS,
                                   disk_get_max_primary_partition_count_doc},
    {"get_max_supported_partition_count", (PyCFunction)
                                 py_ped_disk_get_max_supported_partition_count,
                                 METH_VARARGS,
                                 disk_get_max_supported_partition_count_doc},
    {"get_partition_alignment", (PyCFunction)
                                 py_ped_disk_get_partition_alignment,
                                 METH_NOARGS,
                                 disk_get_partition_alignment_doc},
    {"max_partition_length", (PyCFunction)
                             py_ped_disk_max_partition_length,
                             METH_NOARGS,
                             disk_max_partition_length_doc},
    {"max_partition_start_sector", (PyCFunction)
                             py_ped_disk_max_partition_start_sector,
                             METH_NOARGS,
                             disk_max_partition_start_sector_doc},
    {"set_flag", (PyCFunction) py_ped_disk_set_flag, METH_VARARGS,
                 disk_set_flag_doc},
    {"get_flag", (PyCFunction) py_ped_disk_get_flag, METH_VARARGS,
                 disk_get_flag_doc},
    {"is_flag_available", (PyCFunction) py_ped_disk_is_flag_available,
                          METH_VARARGS, disk_is_flag_available_doc},
    {"add_partition", (PyCFunction) py_ped_disk_add_partition,
                      METH_VARARGS, disk_add_partition_doc},
    {"remove_partition", (PyCFunction) py_ped_disk_remove_partition,
                         METH_VARARGS, disk_remove_partition_doc},
    {"delete_partition", (PyCFunction) py_ped_disk_delete_partition,
                         METH_VARARGS, disk_delete_partition_doc},
    {"delete_all", (PyCFunction) py_ped_disk_delete_all, METH_VARARGS,
                   disk_delete_all_doc},
    {"set_partition_geom", (PyCFunction) py_ped_disk_set_partition_geom,
                           METH_VARARGS, disk_set_partition_geom_doc},
    {"maximize_partition", (PyCFunction) py_ped_disk_maximize_partition,
                           METH_VARARGS, disk_maximize_partition_doc},
    {"get_max_partition_geometry", (PyCFunction)
                                   py_ped_disk_get_max_partition_geometry,
                                   METH_VARARGS,
                                   disk_get_max_partition_geometry_doc},
    {"minimize_extended_partition", (PyCFunction)
                                    py_ped_disk_minimize_extended_partition,
                                    METH_VARARGS,
                                    disk_minimize_extended_partition_doc},
    {"next_partition", (PyCFunction) py_ped_disk_next_partition,
                       METH_VARARGS, disk_next_partition_doc},
    {"get_partition", (PyCFunction) py_ped_disk_get_partition,
                      METH_VARARGS, disk_get_partition_doc},
    {"get_partition_by_sector", (PyCFunction)
                                py_ped_disk_get_partition_by_sector,
                                METH_VARARGS, disk_get_partition_by_sector_doc},
    {"extended_partition", (PyCFunction) py_ped_disk_extended_partition,
                           METH_VARARGS, disk_extended_partition_doc},
    {NULL}
};

static PyGetSetDef _ped_Disk_getset[] = {
    {NULL}  /* Sentinel */
};

PyTypeObject _ped_Disk_Type_obj = {
    PyVarObject_HEAD_INIT(&PyType_Type,0)
    .tp_name = "_ped.Disk",
    .tp_basicsize = sizeof(_ped_Disk),
 /* .tp_itemsize = XXX */
    .tp_dealloc = (destructor) _ped_Disk_dealloc,
 /* .tp_getattr = XXX */
 /* .tp_setattr = XXX */
 /*   .tp_compare = (cmpfunc) _ped_Disk_compare,*/
 /* .tp_repr = XXX */
 /* .tp_as_number = XXX */
 /* .tp_as_sequence = XXX */
 /* .tp_as_mapping = XXX */
    .tp_hash = PyObject_HashNotImplemented,
    .tp_call = NULL,
    .tp_str = (reprfunc) _ped_Disk_str,
    .tp_getattro = PyObject_GenericGetAttr,
    .tp_setattro = PyObject_GenericSetAttr,
 /* .tp_as_buffer = XXX */
    .tp_flags = TP_FLAGS,
    .tp_doc = _ped_Disk_doc,
    .tp_traverse = (traverseproc) _ped_Disk_traverse,
    .tp_clear = (inquiry) _ped_Disk_clear,
    .tp_richcompare = (richcmpfunc) _ped_Disk_richcompare,
 /* .tp_weaklistoffset = XXX */
 /* .tp_iter = XXX */
 /* .tp_iternext = XXX */
    .tp_methods = _ped_Disk_methods,
    .tp_members = _ped_Disk_members,
    .tp_getset = _ped_Disk_getset,
    .tp_base = NULL,
    .tp_dict = NULL,
 /* .tp_descr_get = XXX */
 /* .tp_descr_set = XXX */
 /* .tp_dictoffset = XXX */
    .tp_init = (initproc) _ped_Disk_init,
    .tp_alloc = PyType_GenericAlloc,
    .tp_new = PyType_GenericNew,
 /* .tp_free = XXX */
 /* .tp_is_gc = XXX */
    .tp_bases = NULL,
 /* .tp_del = XXX */
};

/* _ped.DiskType type object */
static PyMemberDef _ped_DiskType_members[] = {
    {NULL}
};

static PyMethodDef _ped_DiskType_methods[] = {
    {"check_feature", (PyCFunction) py_ped_disk_type_check_feature,
                      METH_VARARGS, disk_type_check_feature_doc},
    {NULL}
};

static PyGetSetDef _ped_DiskType_getset[] = {
    {"name", (getter) _ped_DiskType_get, NULL,
             "The name of the partition table type.", "name"},
    {"features", (getter) _ped_DiskType_get, NULL,
                 "A bitmask of features supported by this DiskType.",
                 "features"},
    {NULL}  /* Sentinel */
};

PyTypeObject _ped_DiskType_Type_obj = {
    PyVarObject_HEAD_INIT(&PyType_Type,0)
    .tp_name = "_ped.DiskType",
    .tp_basicsize = sizeof(_ped_DiskType),
 /* .tp_itemsize = XXX */
    .tp_dealloc = (destructor) _ped_DiskType_dealloc,
 /* .tp_getattr = XXX */
 /* .tp_setattr = XXX */
 /*   .tp_compare = (cmpfunc) _ped_DiskType_compare,*/
 /* .tp_repr = XXX */
 /* .tp_as_number = XXX */
 /* .tp_as_sequence = XXX */
 /* .tp_as_mapping = XXX */
    .tp_hash = PyObject_HashNotImplemented,
    .tp_call = NULL,
    .tp_str = (reprfunc) _ped_DiskType_str,
    .tp_getattro = PyObject_GenericGetAttr,
    .tp_setattro = PyObject_GenericSetAttr,
 /* .tp_as_buffer = XXX */
    .tp_flags = TP_FLAGS,
    .tp_doc = _ped_DiskType_doc,
    .tp_traverse = (traverseproc) _ped_DiskType_traverse,
    .tp_clear = (inquiry) _ped_DiskType_clear,
    .tp_richcompare = (richcmpfunc) _ped_DiskType_richcompare,
 /* .tp_weaklistoffset = XXX */
 /* .tp_iter = XXX */
 /* .tp_iternext = XXX */
    .tp_methods = _ped_DiskType_methods,
    .tp_members = _ped_DiskType_members,
    .tp_getset = _ped_DiskType_getset,
    .tp_base = NULL,
    .tp_dict = NULL,
 /* .tp_descr_get = XXX */
 /* .tp_descr_set = XXX */
 /* .tp_dictoffset = XXX */
    .tp_init = NULL,
    .tp_alloc = PyType_GenericAlloc,
    .tp_new = NULL,
 /* .tp_free = XXX */
 /* .tp_is_gc = XXX */
    .tp_bases = NULL,
 /* .tp_del = XXX */
};

#endif /* TYPEOBJECTS_PYDISK_H_INCLUDED */

/* vim:tw=78:ts=4:et:sw=4
 */
0707010011587B000081A40000FFFE0000FFFD0000000157CD697A00000E7E000000FC0000001000000000000000000000003B00000000pyparted-1466619794.7a0f829/include/docstrings/pynatmath.h/*
 * docstrings/pynatmath.h
 * pyparted docstrings for for pynatmath.c
 *
 * Copyright (C) 2007, 2008 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>
 *                    Chris Lumens <clumens@redhat.com>
 */

#ifndef DOCSTRINGS_PYNATMATH_H_INCLUDED
#define DOCSTRINGS_PYNATMATH_H_INCLUDED

#include <Python.h>

PyDoc_STRVAR(alignment_duplicate_doc,
"duplicate(self) -> _ped.Alignment\n\n"
"Create an identical copy of self.  Raises _ped.CreateException if the\n"
"operation fails");

PyDoc_STRVAR(alignment_intersect_doc,
"intersect(self, Alignment) -> _ped.Alignment\n\n"
"Create a new Alignment that describes the intersection of self and\n"
"Alignment.  A sector will satisfy the new Alignment iff it satisfies both\n"
"of the original alignments, where 'satisfy' is determined by is_aligned().\n"
"The proof of this is relatively complicated and is described thoroughly\n"
"in the libparted source.  This method raises ArithmeticError if no\n"
"intersection can be found.");

PyDoc_STRVAR(alignment_align_up_doc,
"align_up(self, Geometry, Sector) -> Sector\n\n"
"Returns the closest Sector to the input Sector that lies inside Geometry\n"
"and satisfies the alignment constraint.  This method prefers, but does not\n"
"guarantee, that the result is beyond Sector.  If no such Sector can be\n"
"found, an ArithmeticError is raised.");

PyDoc_STRVAR(alignment_align_down_doc,
"align_down(self, Geometry, Sector) -> Sector\n\n"
"Returns the closest Sector to the input Sector that lies inside Geometry\n"
"and satisfies the alignment constraint.  This method prefers, but does not\n"
"guarantee, that the result is below Sector.  If no such Sector can be\n"
"found, an ArithmeticError is raised.");

PyDoc_STRVAR(alignment_align_nearest_doc,
"align_nearest(self, Geometry, Sector) -> Sector\n\n"
"Returns the closest Sector to the input Sector that lies inside Geometry\n"
"and satisfies the aligmnent constraint.  If no such Sector can be found,\n"
"an ArithmeticError is raised.");

PyDoc_STRVAR(alignment_is_aligned_doc,
"is_aligned(self, Geometry, Sector) -> boolean\n\n"
"Returns whether or not Sector lies inside Geometry and satisfies the\n"
"alignment constraint.  This method defines what 'satisfy' means for\n"
"intersection.");

PyDoc_STRVAR(_ped_Alignment_doc,
"A _ped.Alignment object describes constraints on how sectors and Geometry\n"
"objects are aligned.  It includes a variety of methods for aligning sectors\n"
"and calculating the intersection of two Alignment objects.  Most methods on\n"
"this object can raise _ped.CreateException if creating temporary objects\n"
"fails and ArithmeticError if calculating alignments and intersections fails.");

#endif /* DOCSTRINGS_PYNATMATH_H_INCLUDED */

/* vim:tw=78:ts=4:et:sw=4
 */
0707010011587D000081A40000FFFE0000FFFD0000000157CD697A0000164F000000FC0000001000000000000000000000003800000000pyparted-1466619794.7a0f829/include/docstrings/pygeom.h/*
 * pygeom.h
 * pyparted docstrings for pygeom.c
 *
 * Copyright (C) 2007, 2008 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>
 *                    Chris Lumens <clumens@redhat.com>
 */

#ifndef DOCSTRINGS_PYGEOM_H_INCLUDED
#define DOCSTRINGS_PYGEOM_H_INCLUDED

#include <Python.h>

PyDoc_STRVAR(geometry_duplicate_doc,
"duplicate(self) -> _ped.Geometry\n\n"
"Create an identical copy of self.  Raises _ped.CreateException if the\n"
"operation fails");

PyDoc_STRVAR(geometry_intersect_doc,
"intersect(self, Geometry) -> _ped.Geometry\n\n"
"Create a new Geometry describing the region common to both self and\n"
"Geometry.  Raises ArithmeticError if the two regions do not intersect.");

PyDoc_STRVAR(geometry_set_doc,
"set(self, start, length) -> boolean\n\n"
"Sets a new start Sector and length Sector in the Geometry object,\n"
"also implicitly setting the end Sector as well.");

PyDoc_STRVAR(geometry_set_start_doc,
"set_start(self, start) -> boolean\n\n"
"Sets a new start Sector without modifying the end Sector.  Length\n"
"will be modified to match the new starting position.");

PyDoc_STRVAR(geometry_set_end_doc,
"set_end(self, end) -> boolean\n\n"
"Sets a new ending Sector without modifying the start Sector.  Length\n"
"will be modified to match the new ending position.");

PyDoc_STRVAR(geometry_test_overlap_doc,
"test_overlap(self, Geometry) -> boolean\n\n"
"Return whether self and Geometry are on the same physical device and\n"
"share at least part of the same region.");

PyDoc_STRVAR(geometry_test_inside_doc,
"test_inside(self, Geometry) -> boolean\n\n"
"Return whether Geometry is entirely within self and on the same physical\n"
"device.");

PyDoc_STRVAR(geometry_test_equal_doc,
"test_equal(self, Geometry) -> boolean\n\n"
"Return whether self and Geometry are on the same device and have the same\n"
"region.");

PyDoc_STRVAR(geometry_test_sector_inside_doc,
"test_sector_inside(self, Sector) -> boolean\n\n"
"Return whether Sector is entirely within the region described by self.");

PyDoc_STRVAR(geometry_read_doc,
"read(self, buffer, offset, count) -> boolean\n\n"
"Read data from the region described by self.  This method reads count\n"
"Sectors starting at Sector offset (from the start of the region, not\n"
"from the start of the disk) into buffer.  This method raises\n"
"_ped.IOException on error.");

PyDoc_STRVAR(geometry_sync_doc,
"sync(self) -> boolean\n\n"
"Flushes all caches on the device described by self.  This operation can be\n"
"slow because it must guarantee cache coherency among multiple caches.  This\n"
"method raises _ped.IOException on error.");

PyDoc_STRVAR(geometry_sync_fast_doc,
"sync_fast(self) -> boolean\n\n"
"Flushes all caches on the device described by self without guaranteeing\n"
"cache coherency.  This makes it fast but more prone to error.  This method\n"
"raises _ped.IOException on error.");

PyDoc_STRVAR(geometry_write_doc,
"write(self, buffer, offset, count) -> boolean\n\n"
"Write data into the region described by self.  This method writes count\n"
"Sectors of buffer into the region starting at Sector offset.  The offset is\n"
"from the beginning of the region, not of the disk.  This method raises\n"
"_ped.IOException on error.");

PyDoc_STRVAR(geometry_check_doc,
"check(self, offset, granularity, count, timer=None) -> Sector\n\n"
"This method checks the region described by self for errors on the disk.\n"
"The region to check starts at offset Sectors from the beginning of the\n"
"region and is count Sectors long.  granularity specifies how Sectors should\n"
"be grouped together.\n\n"
"This method returns the first bad sector, or 0 if there are no errors.");

PyDoc_STRVAR(geometry_map_doc,
"map(self, Geometry, Sector) -> integer\n\n"
"Given a Geometry that overlaps with self and a Sector inside Geometry,\n"
"this method translates the address of Sector into an address inside self.\n"
"The new address is returned, or ArithmeticError is raised if Sector does\n"
"not exist within self.");

PyDoc_STRVAR(_ped_Geometry_doc,
"A _ped.Geometry object describes a continuous region on a physical device.\n"
"This device is given by the dev attribute when the Geometry is created.\n"
"Most methods on this object involve creating new Geometry objects as needed\n"
"and can therefore raise _ped.CreateException when an error occurs creating\n"
"the new object.  Most methods can also raise _ped.IOException when reading\n"
"or writing the underlying physical device fails.\n\n"
"libparted (and therefore pyparted) attempts to enforce the following\n"
"conditions on Geometry objects:\n\n"
"\t- start + length - 1 == end\n"
"\t- length > 0\n"
"\t- start >= 0\n"
"\t- end < dev.length");

#endif /* DOCSTRINGS_PYGEOM_H_INCLUDED */

/* vim:tw=78:ts=4:et:sw=4
 */
0707010011587E000081A40000FFFE0000FFFD0000000157CD697A000026D5000000FC0000001000000000000000000000003A00000000pyparted-1466619794.7a0f829/include/docstrings/pydevice.h/*
 * pydevice.h
 * pyparted docstrings for pydevice.c
 *
 * Copyright (C) 2007, 2008, 2009  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>
 */

#ifndef DOCSTRINGS_PYDEVICE_H_INCLUDED
#define DOCSTRINGS_PYDEVICE_H_INCLUDED

#include <Python.h>

PyDoc_STRVAR(disk_probe_doc,
"disk_probe(self) -> DiskType\n\n"
"Return the type of partition table detected, or raise _ped.IOException if\n"
"there is an error reading self.");

PyDoc_STRVAR(device_is_busy_doc,
"is_busy(self) -> bool\n\n"
"Return True if this Device is currently in use, False otherwise.");

PyDoc_STRVAR(device_open_doc,
"open(self) -> bool\n\n"
"Attempt to open this Device to allow use of read(), write(), and sync()\n"
"methods.  The open() call is architecture-dependent.  Apart from\n"
"requesting access to the device from the operating system, it does things\n"
"flushing caches.\n\n"
"This method may allocate internal resources depending on the architecture\n"
"All allocated resources are freed when you call the close() method.\n\n"
"Return True if the Device could be opened, False otherwise.");

PyDoc_STRVAR(device_close_doc,
"close(self) -> bool\n\n"
"Close this Device.  All allocated resources are freed.  If a failure\n"
"occurs while closing the Device, this method returns False.  The method\n"
"returns True on success.");

PyDoc_STRVAR(device_destroy_doc,
"destroy(self) -> None\n\n"
"Destroys the Device, removes it from the device list, destroys all\n"
"allocated resources associated with it, and destroys the object.");

PyDoc_STRVAR(device_cache_remove_doc,
"cache_remove(self) -> None\n\n"
"Remove the Device from the device list, but does not destroy it or any\n"
"allocated resources associated with it.  USE WITH CAUTION.");

PyDoc_STRVAR(device_begin_external_access_doc,
"begin_external_accessself() -> bool\n\n"
"Begins external access mode for this Device.  External access mode allows\n"
"you to safely do I/O on the device.  If a Device is open, then you should\n"
"not do any I/O on that Device, e.g. by calling an external program like\n"
"e2fsck, unless you put it in external access mode.  You should not use\n"
"any commands that do I/O to a Device while it is in external access mode.\n\n"
"Also, you should not close a Device while it is in external access mode.\n\n"
"Return True if the Device was successfully put in external access mode,\n"
"False otherwise.");

PyDoc_STRVAR(device_end_external_access_doc,
"end_external_access(self) -> bool\n\n"
"Ends external access mode for this Device.  Returns True on success,\n"
"False on failure.");

PyDoc_STRVAR(device_read_doc,
"read(self, start, count) -> bool\n\n"
"Read and return count sectors from this Device, starting at sector start.\n"
"Both start and count are long integers and buffer is a Python object large\n"
"enough to hold what you want to read.");

PyDoc_STRVAR(device_write_doc,
"write(self, buffer, start, count) -> bool\n\n"
"Write count sectors from buffer to this Device, starting at sector start.\n"
"Both start and count are long integers and buffer is a Python object holding\n"
"what you want to write to this Device.\n\n"
"Return True if the write was successful, False otherwise.");

PyDoc_STRVAR(device_sync_doc,
"sync(self) -> bool\n\n"
"Flushes all write-behind caches that might be holding up writes.  It is\n"
"slow because it guarantees cache coherency among all relevant caches.\n"
"Return True on success, False otherwise.");

PyDoc_STRVAR(device_sync_fast_doc,
"sync_fast(self) -> bool\n\n"
"Flushes all write-behind caches that might be holding writes.  WARNING:\n"
"Does NOT ensure cache coherency with other caches.  If you need cache\n"
"coherency, use sync() instead.  Return True on success, False otherwise.");

PyDoc_STRVAR(device_check_doc,
"check(self) -> long int\n\n"
"Architecture-dependent function that returns the number of sectors on\n"
"this Device that are ok.");

PyDoc_STRVAR(disk_clobber_doc,
"clobber(self) -> boolean\n\n"
"Remove all identifying information from a partition table.  If the partition\n"
"table cannot be cleared, a _ped.DiskException is raised.");

PyDoc_STRVAR(device_get_constraint_doc,
"get_constraint(self) -> Constraint\n\n"
"Get a constraint that represents hardware requirements on geometry.\n"
"This method will return a constraint representing the limits imposed by\n"
"the size of the disk, it will *not* provide any alignment constraints.\n"
"\n"
"Alignment constraints may be desirable when using media that have a\n"
"physical sector size that is a multiple of the logical sector size, as\n"
"in this case proper partition alignment can benefit disk performance\n"
"signigicantly.\n");

PyDoc_STRVAR(device_get_minimal_aligned_constraint_doc,
"get_minimal_aligned_constraint(self) -> Constraint\n\n"
"Get a constraint that represents hardware requirements on geometry and\n"
"alignment. This method returns a constraint representing the limits\n"
"imposed by the size of the disk and the minimal alignment requirements\n"
"for proper performance of the disk.\n");

PyDoc_STRVAR(device_get_optimal_aligned_constraint_doc,
"get_optimal_aligned_constraint(self) -> Constraint\n\n"
"Get a constraint that represents hardware requirements on geometry and\n"
"alignment. This method returns a constraint representing the limits\n"
"imposed by the size of the disk and the alignment requirements for\n"
"optimal performance of the disk.\n");

PyDoc_STRVAR(device_get_minimum_alignment_doc,
"get_minimum_alignment(self) -> Alignment\n\n"
"Get an alignment that represents minimum hardware requirements on\n"
"alignment. When for example using media that has a physical sector size\n"
"that is a multiple of the logical sector size, it is desirable to have\n"
"disk accesses (and thus partitions) properly aligned. Having partitions\n"
"not aligned to the minimum hardware requirements may lead to a\n"
"performance penalty.\n\n"
"The returned alignment describes the alignment for the start sector of\n"
"the partition, the end sector should be aligned too, to get the end\n"
"sector alignment decrease the returned alignment's offset by 1.\n");

PyDoc_STRVAR(device_get_optimum_alignment_doc,
"get_optimum_alignment(self) -> Alignment\n\n"
"Get an alignment that represents the hardware requirements for optimal\n"
"performance.\n\n"
"The returned alignment describes the alignment for the start sector of\n"
"the partition, the end sector should be aligned too, to get the end\n"
"sector alignment decrease the returned alignment's offset by 1.\n");

PyDoc_STRVAR(unit_get_size_doc,
"unit_get_size(self, Unit) -> long\n\n"
"Returns the byte size of self in the specified Unit.  The Unit\n"
"is any of the _ped.UNIT_* constants.");

PyDoc_STRVAR(unit_format_custom_byte_doc,
"unit_format_custom_byte(Sector, Unit) -> string\n\n"
"Return a string that describes the location of the byte Sector on\n"
"self, as described by Unit.  The Unit is any of the _ped.UNIT_*\n"
"constants.");

PyDoc_STRVAR(unit_format_byte_doc,
"unit_format_byte(Sector) -> string\n\n"
"Return a string that describes the location of the byte Sector on\n"
"self, as described by the default Unit.");

PyDoc_STRVAR(unit_format_custom_doc,
"unit_format_custom(Sector, Unit) -> string\n\n"
"Return a string that describes the location of Sector on self, as\n"
"described by Unit.  The Unit is any of the _ped.UNIT_* constants.");

PyDoc_STRVAR(unit_format_doc,
"unit_format(Device, Sector) -> string\n\n"
"Return a string that describes the location of Sector on self, as\n"
"described by the default Unit.");

PyDoc_STRVAR(unit_parse_doc,
"unit_parse(string, Sector, Geometry) -> boolean\n\n"
"Given a string providing a valid description of a location on self,\n"
"create a Geometry and Sector describing it.  Geometry will be two units\n"
"large, centered on Sector.  If this makes the Geometry exist partially\n"
"outside self, the Geometry will be intersected with the whole device\n"
"geometry.  This uses the default unit.");

PyDoc_STRVAR(unit_parse_custom_doc,
"unit_parse(string, Unit, Sector, Geometry) -> boolean\n\n"
"Follows the same description as unit_parse_doc, but takes a Unit as\n"
"well.  The Unit is any of the _ped.UNIT_* constants.");

PyDoc_STRVAR(_ped_CHSGeometry_doc,
"A _ped.CHSGeometry object describes a disk using the older CHS style\n"
"of defining disk geometry.  CHS stands for cylinders-heads-sectors.\n\n"
"The _ped.CHSGeometry objects are created automatically when devices are\n"
"probed by libparted.  They are used for reference purposes to get the\n"
"number of cylinders, heads, or sectors on a disk.  They cannot be used\n"
"to change the CHS values on a device.");

PyDoc_STRVAR(_ped_Device_doc,
"A _ped.Device object describes a block device accessible via the\n"
"operating system.  On Linux, an example block device is /dev/sda.\n\n"
"It is important to note that _ped.Device objects describe entire\n"
"block devices and not just partitions.");

#endif /* DOCSTRINGS_PYDEVICE_H_INCLUDED */

/* vim:tw=78:ts=4:et:sw=4
 */
0707010011587F000081A40000FFFE0000FFFD0000000157CD697A00000BC8000000FC0000001000000000000000000000003E00000000pyparted-1466619794.7a0f829/include/docstrings/pyconstraint.h/*
 * pyconstraint.h
 * pyparted docstrings for pyconstraint.c
 *
 * Copyright (C) 2007, 2008 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>
 *                    Chris Lumens <clumens@redhat.com>
 */

#ifndef DOCSTRINGS_PYCONSTRAINT_H_INCLUDED
#define DOCSTRINGS_PYCONSTRAINT_H_INCLUDED

#include <Python.h>

PyDoc_STRVAR(constraint_duplicate_doc,
"duplicate(Constraint) -> Constraint\n\n"
"Return a new Constraint that is a copy of the given Constraint.");

PyDoc_STRVAR(constraint_intersect_doc,
"intersect(Constraint) -> Constraint\n\n"
"Return a Constraint that requires a region to satisfy both this\n"
"Constraint object and the one passed in to the method.  Any\n"
"region satisfying both Constraints will also satisfy the returned\n"
"Constraint.");

PyDoc_STRVAR(constraint_solve_max_doc,
"solve_max() -> Constraint\n\n"
"Find the largest region that satisfies this Constraint object and\n"
"return a new Constraint.  There may be more than one solution.\n"
"There are no guarantees about which solution will be returned.\n");

PyDoc_STRVAR(constraint_solve_nearest_doc,
"solve_nearest(Geometry) -> Constraint\n\n"
"Return the nearest region to Geometry that will satisfy this\n"
"Constraint object.  This function does not guarantee what nearest\n"
"means.");

PyDoc_STRVAR(constraint_is_solution_doc,
"is_solution(Geometry) -> bool\n\n"
"Return True if Geometry satisfies this Constraint, False otherwise.");

PyDoc_STRVAR(_ped_Constraint_doc,
"A _ped.Constraint object describes a set of restrictions on other pyparted\n"
"operations.  Constraints can restrict the location and alignment of the start\n"
"and end of a partition, and its minimum and maximum size.  Constraint\n"
"operations include various methods of creating constraints, intersecting,\n"
"and solving sets of constraints.\n\n"
"Most constraint operations can raise _ped.CreateException if creating\n"
"temporary objects fails, or ArithmeticError if an error occurrs during\n"
"calculations.");

#endif /* DOCSTRINGS_PYCONSTRAINT_H_INCLUDED */

/* vim:tw=78:ts=4:et:sw=4
 */
07070100115880000081A40000FFFE0000FFFD0000000157CD697A0000085B000000FC0000001000000000000000000000003B00000000pyparted-1466619794.7a0f829/include/docstrings/pyfilesys.h/*
 * pyfilesys.h
 * pyparted docstrings for pyfilesys.c
 *
 * Copyright (C) 2007-2011  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>
 *                    Chris Lumens <clumens@redhat.com>
 */

#ifndef DOCSTRINGS_PYFILESYS_H_INCLUDED
#define DOCSTRINGS_PYFILESYS_H_INCLUDED

#include <Python.h>

PyDoc_STRVAR(_ped_FileSystemType_doc,
"A _ped.FileSystemType object gives a name to a single filesystem that parted\n"
"understands.  parted maintains a list of these objects which can be\n"
"traversed with the self.get_next method or accessed directly via self.get().");

PyDoc_STRVAR(_ped_FileSystem_doc,
"A _ped.FileSystem object describes a filesystem that exists in a given\n"
"region on a device.  The region is given by a _ped.Geometry object, and\n"
"the filesystem is further described by a _ped.FileSystemType object.\n\n"
"Filesystem operations are especially prone to failures, and pyparted raises\n"
"a variety of exceptions when error conditions are encountered.  The most\n"
"common is _ped.FileSystemException, though _ped.IOException and\n"
"_ped.CreateException may also be raised.");

#endif /* DOCSTRINGS_PYFILESYS_H_INCLUDED */

/* vim:tw=78:ts=4:et:sw=4
 */
07070100115881000081A40000FFFE0000FFFD0000000157CD697A00003547000000FC0000001000000000000000000000003800000000pyparted-1466619794.7a0f829/include/docstrings/pydisk.h/*
 * pydisk.h
 * pyparted docstrings for pydisk.c
 *
 * Copyright (C) 2007, 2008, 2009  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>
 *                    Chris Lumens <clumens@redhat.com>
 */

#ifndef DOCSTRINGS_PYDISK_H_INCLUDED
#define DOCSTRINGS_PYDISK_H_INCLUDED

#include <Python.h>

PyDoc_STRVAR(partition_destroy_doc,
"destroy(self) -> None\n\n"
"Destroys the Partition object.");

PyDoc_STRVAR(partition_is_active_doc,
"is_active(self) -> boolean\n\n"
"Return whether self is active or not.");

PyDoc_STRVAR(partition_set_flag_doc,
"set_flag(self, flag, state) -> boolean\n\n"
"Sets the state of the given flag on self .  Flags have different types of\n"
"different types of disk labels, and are not guaranteed to exist on all disk\n"
"label types.  If provided with an invalid flag for the disk's label,\n"
"_ped.PartitionException is raised.");

PyDoc_STRVAR(partition_get_flag_doc,
"get_flag(self, flag) -> integer\n\n"
"Return the state of the given flag on self.  There is no check for invalid\n"
"flag types, so these will always return 0.  It is therefore recommended to\n"
"call self.is_flag_available() first to make sure.");

PyDoc_STRVAR(partition_is_flag_available_doc,
"is_flag_available(self, flag) -> boolean\n\n"
"Return whether the given flag is valid for self.");

PyDoc_STRVAR(partition_set_system_doc,
"set_system(self, FileSystemType) -> boolean\n\n"
"Set the system type on self to FileSystemType.  On error,\n"
"_ped.PartitionException is raised.");

PyDoc_STRVAR(partition_set_name_doc,
"set_name(self, string) -> boolean\n\n"
"On disk labels that support it, this method sets the partition's name.\n"
"Before attempting this operation, DiskType.check_feature() can be used to\n"
"determine if it is even supported.  On error, _ped.PartitionException will\n"
"be raised.");

PyDoc_STRVAR(partition_get_name_doc,
"get_name(self) -> string\n\n"
"On disk labels that support it, this method returns the partition's name.  On\n"
"all other disk labels, _ped.PartitionException will be raised.  Before calling\n"
"this method, DiskType.check_feature() can be called to check for support.");

PyDoc_STRVAR(partition_is_busy_doc,
"is_busy(self) -> boolean\n\n"
"Return whether self is busy or not.  The most likely reason for a partition\n"
"to be busy is because it's mounted.  Additionally, extended partitions are\n"
"busy if any of their logical partitions are busy.");

PyDoc_STRVAR(partition_get_path_doc,
"get_path(self) -> string\n\n"
"Return a path that could be used for addressing self at an operating system\n"
"level.  For instance, on Linux this could return '/dev/sda' for a partition.\n"
"If an error occurs, _ped.PartitionException is raised.");

PyDoc_STRVAR(partition_reset_num_doc,
"reset_num(self) -> boolean\n\n"
"Reset the partition's number to value allowing it to be set correctly when\n"
"the partition is added to _ped.PartedDisk. The returned value means\n"
"success/failure");

PyDoc_STRVAR(disk_duplicate_doc,
"duplicate(self) -> Disk\n\n"
"Return a new Disk that is a copy of self.  This method raises\n"
"_ped.DiskException if there is an error making the copy.");

PyDoc_STRVAR(disk_destroy_doc,
"destroy(self) -> None\n\n"
"Destroy the Disk object.");

PyDoc_STRVAR(disk_commit_doc,
"commit(self) -> boolean\n\n"
"Write the in-memory changes to the disk's partition table and inform the\n"
"operating system of the changes.  This method is equivalent to calling:\n"
"\tself.disk_commit_to_dev()\n"
"\tself.disk_commit_to_os()\n"
"On error, _ped.DiskException is raised.");

PyDoc_STRVAR(disk_commit_to_dev_doc,
"commit_to_dev(self) -> boolean\n\n"
"Write the in-memory changes to the disk's partition table.  On error,\n"
"_ped.DiskException is raised.");

PyDoc_STRVAR(disk_commit_to_os_doc,
"commit_to_os(self) -> boolean\n\n"
"Inform the operating system that disk's partition table layout has changed.\n"
"What exactly this means depends on the operating system.  On error, a\n"
"_ped.DiskException is raised.");

PyDoc_STRVAR(disk_check_doc,
"check(self) -> boolean\n\n"
"Perform a basic sanity check on the partition table.  This check does not\n"
"depend on the type of disk.  If there is an error performing the check,\n"
"_ped.DiskException is raised.");

PyDoc_STRVAR(disk_print_doc,
"print(self) -> None\n\n"
"Print a summary of the partitions on self.");

PyDoc_STRVAR(disk_get_primary_partition_count_doc,
"get_primary_partition_count(self) -> integer\n\n"
"Return the number of primary partitions on self.");

PyDoc_STRVAR(disk_get_last_partition_num_doc,
"get_last_partition_num(self) -> integer\n\n"
"Return the highest in-use partition number on self.");

PyDoc_STRVAR(disk_get_max_primary_partition_count_doc,
"get_max_primary_partition_count(self) -> integer\n\n"
"Get the maximum number of primary partitions spported by the disk label.");

PyDoc_STRVAR(disk_get_max_supported_partition_count_doc,
"get_max_supported_partition_count(self) -> integer\n\n"
"Get the highest supported partition number of this disk.");

PyDoc_STRVAR(disk_get_partition_alignment_doc,
"get_partition_alignment(self) -> Alignment\n\n"
"Get the alignment needed for partition boundaries on this disk.\n"
"The returned alignment describes the alignment for the start sector\n"
"of the partition, for all disklabel types which require alignment,\n"
"except Sun disklabels, the end sector must be aligned too.\n"
"To get the end sector alignment decrease the PedAlignment offset by 1.\n");

PyDoc_STRVAR(disk_max_partition_length_doc,
"max_partition_length(self) -> long\n\n"
"This returns the maximum length for a partition the label on this disk\n"
"can represent. This does not necessarily mean that there is enough\n"
"freespace to create such a partition.\n"
"If this information is not available 0 is returned");

PyDoc_STRVAR(disk_max_partition_start_sector_doc,
"max_partition_start_sector(self) -> long\n\n"
"This returns the maximum partition start sector the label on this disk\n"
"can represent.\n"
"If this information is not available 0 is returned");

PyDoc_STRVAR(disk_set_flag_doc,
"set_flag(self, flag, state) -> boolean\n\n"
"Sets the state of the given flag on self .\n"
"If provided with an invalid flag for the disk's label,\n"
"a PartedException is raised.");

PyDoc_STRVAR(disk_get_flag_doc,
"get_flag(self, flag) -> boolean\n\n"
"Return the state of the given flag on self.  There is no check for invalid\n"
"flag types, so these will always return 0.  It is therefore recommended to\n"
"call self.is_flag_available() first to make sure.");

PyDoc_STRVAR(disk_is_flag_available_doc,
"is_flag_available(self, flag) -> boolean\n\n"
"Return whether the given flag is valid for self.");

PyDoc_STRVAR(disk_add_partition_doc,
"add_partition(self, Partition, Constraint) -> boolean\n\n"
"Adds the new partition Partition to self.  This operation may modify the\n"
"partition's geometry, subject to Constraint.  Having a strict Constraint\n"
"will likely cause this operation to fail, raising a _ped.PartitionException\n"
"in the process.");

PyDoc_STRVAR(disk_remove_partition_doc,
"remove_partition(self, Partition) -> boolean\n\n"
"Remove Partition from self.  If Partition is an extended partition, it must\n"
"not contain any logical partitions.  The Partition object itself is not\n"
"destroyed.  The caller must use Partition.destroy() or self.delete_partition().\n"
"For all error cases, _ped.PartitionException will be raised.");

PyDoc_STRVAR(disk_delete_partition_doc,
"delete_partition(self, Partition) -> boolean\n\n"
"Remove Partition from self and destroy the Partition object afterwards.  This\n"
"is equivalent to calling:\n"
"\tself.remove_partition(Partition)\n"
"\tPartition.destroy()\n"
"For all error cases, _ped.PartitionException will be raised.");

PyDoc_STRVAR(disk_delete_all_doc,
"disk_delete_all(self) -> boolean\n\n"
"Remove and destroy all partitions on self, raising _ped.PartitionException on\n"
"any error case.");

PyDoc_STRVAR(disk_set_partition_geom_doc,
"set_partition_geom(self, Partition, Constraint, start_sector, end_sector) ->\n"
"                  boolean\n\n"
"Change the location of Partition by setting a new Geometry on it, subject to\n"
"the restrictions of Constraint.  This operation can fail for many reasons,\n"
"all of which result in a _ped.PartitionException.  One of the most likely\n"
"failure cases is that the new location overlaps with an existing partition.\n"
"On error, Partition will be unchanged.  On success, the contents of the\n"
"partition will still not be changed - the file system itself will still\n"
"need to be resized.");

PyDoc_STRVAR(disk_maximize_partition_doc,
"maximize_partition(self, Partition, Constraint) -> boolean\n\n"
"Grow the Partition to the largest possibly size, subject to the restrictions\n"
"of Constraint.  Raise _ped.PartitionException on error.");

PyDoc_STRVAR(disk_get_max_partition_geometry_doc,
"get_max_partition_geometry(self, Partition, Constraint) -> Geometry\n\n"
"Return the maximum Geometry that Partition can be grown to, subject to the\n"
"restrictions of Constraint.  Raise _ped.PartitionException on error.");

PyDoc_STRVAR(disk_minimize_extended_partition_doc,
"minimize_extended_partition(self) -> boolean\n\n"
"Reduce the size of an extended partition on self to the minimum while still\n"
"including all logical partitions.  If there are no logical partitions, the\n"
"extended partition will be deleted.  If the extended partition cannot be\n"
"shrunk, a _ped.PartitionException will be raised.");

PyDoc_STRVAR(disk_next_partition_doc,
"next_partition(self, Partition) -> Partition\n\n"
"Return the next partition on self after Partition.  If Partition is None,\n"
"return the first partition.  If Partition is an extended partition, return\n"
"the first logical partition inside it.  If Partition is the last partition,\n"
"raise IndexError.  Repeatedly calling this method has the effect of\n"
"performing a depth-first traversal on self.");

PyDoc_STRVAR(disk_get_partition_doc,
"get_partition(self, num) -> Partition\n\n"
"Return the Partition given by num, or raise _ped.PartitionException if no\n"
"partition with that index exists.");

PyDoc_STRVAR(disk_get_partition_by_sector_doc,
"get_partition_by_sector(self, sector) -> Partition\n\n"
"Return the Partition containing sector, or raise _ped.PartitionException\n"
"otherwise.  If sector exists within a logical partition, the logical\n"
"partition is returned.");

PyDoc_STRVAR(disk_extended_partition_doc,
"extended_partition(self) -> Partition\n\n"
"If an extended partition exists on self, return it.  Otherwise, raise\n"
"_ped.PartitionException");

PyDoc_STRVAR(disk_type_check_feature_doc,
"check_feature(self, DiskTypeFeature) -> boolean\n\n"
"Return whether or not self supports a particular partition table feature.\n"
"DiskTypeFeatures are given by the _ped.DISK_TYPE_* constants.");

PyDoc_STRVAR(_ped_Partition_doc,
"A _ped.Partition object describes a single partition on a disk.  Operations\n"
"on Partition objects are limited to getting and setting flags, names, and\n"
"paths.  All other operations you may wish to do involving partitions are\n"
"done through a _ped.Disk or _ped.FileSystem object.  These objects all exist\n"
"as attributes of a Partition, though.\n\n"
"Valid flags for Partitions are given by the _ped.PARTITION_* constants,\n"
"though not all flags are valid for every disk label type.\n\n"
"For most errors involving a Partition object, _ped.PartitionException will\n"
"be raised.");

PyDoc_STRVAR(_ped_Disk_doc,
"A _ped.Disk object represents a disk label, or partition table, on a single\n"
"_ped.Device.  Since parted supports a variety of platforms, it must also\n"
"support a variety of disk labels, not all of which may support the same set\n"
"of features.  For instance, DOS disk labels support extended partitions while\n"
"other systems do not.  The Disk object therefore includes a DiskType\n"
"reference to enumerate supported features.  However, all other Disk operations\n"
"are supported on all disk label types.\n\n"
"Operations on Disk objects include creating, deleting, moving, and resizing\n"
"partitions in various ways.  Creating filesystems within these partitions is\n"
"left up to the FileSystem objects.\n\n"
"For most errors involving a Disk object, _ped.PartitionException will be\n"
"raised.  Some operations can also raise _ped.IOException or IndexError.");

PyDoc_STRVAR(_ped_DiskType_doc,
"A _ped.DiskType object is a simple object that gives a partition table a\n"
"name and describes features it supports.  A reference to one of these\n"
"objects is stored inside a _ped.Disk object.");

#endif /* PYDISK_H_INCLUDED */

/* vim:tw=78:ts=4:et:sw=4
 */
0707010011586B000041ED0000FFFE0000FFFD0000000257CD697A00000000000000FC0000001000000000000000000000003000000000pyparted-1466619794.7a0f829/include/typeobjects07070100115879000041ED0000FFFE0000FFFD0000000257CD697A00000000000000FC0000001000000000000000000000002F00000000pyparted-1466619794.7a0f829/include/docstrings07070100115869000081A40000FFFE0000FFFD0000000157CD697A000009F4000000FC0000001000000000000000000000002E00000000pyparted-1466619794.7a0f829/include/pytimer.h/*
 * pytimer.h
 * pyparted type definitions for pytimer.c
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#ifndef PYTIMER_H_INCLUDED
#define PYTIMER_H_INCLUDED

#include <Python.h>

#include <parted/parted.h>

/* 1:1 function mappings for timer.h in libparted */
PyObject *py_ped_timer_destroy(PyObject *, PyObject *);
PyObject *py_ped_timer_new_nested(PyObject *, PyObject *);
PyObject *py_ped_timer_destroy_nested(PyObject *, PyObject *);
PyObject *py_ped_timer_touch(PyObject *, PyObject *);
PyObject *py_ped_timer_reset(PyObject *, PyObject *);
PyObject *py_ped_timer_update(PyObject *, PyObject *);
PyObject *py_ped_timer_set_state_name(PyObject *, PyObject *);

/* _ped.Timer type is the Python equivalent of PedTimer in libparted */
typedef struct {
    PyObject_HEAD

/* PedTimer members */
    float frac;
    time_t start;
    time_t now;
    time_t predicted_end;
    char *state_name;
    PedTimerHandler *handler;
    void *context;
} _ped_Timer;

void _ped_Timer_dealloc(_ped_Timer *);
int _ped_Timer_compare(_ped_Timer *, PyObject *);
PyObject *_ped_Timer_richcompare(_ped_Timer *, PyObject *, int);
PyObject *_ped_Timer_str(_ped_Timer *);
int _ped_Timer_traverse(_ped_Timer *, visitproc, void *);
int _ped_Timer_clear(_ped_Timer *);
int _ped_Timer_init(_ped_Timer *, PyObject *, PyObject *);
PyObject *_ped_Timer_get(_ped_Timer *, void *);
int _ped_Timer_set(_ped_Timer *, PyObject *, void *);

extern PyTypeObject _ped_Timer_Type_obj;

#endif /* PYTIMER_H_INCLUDED */

/* vim:tw=78:ts=4:et:sw=4
 */
0707010011586A000081A40000FFFE0000FFFD0000000157CD697A00000C28000000FC0000001000000000000000000000002E00000000pyparted-1466619794.7a0f829/include/convert.h/*
 * convert.h
 * Functions for converting to/from Python _ped types and C libparted types
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Chris Lumens <clumens@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#ifndef CONVERT_H_INCLUDED
#define CONVERT_H_INCLUDED

#include <parted/parted.h>

#include "pyconstraint.h"
#include "pydevice.h"
#include "pydisk.h"
#include "pyfilesys.h"
#include "pygeom.h"
#include "pynatmath.h"
#include "pytimer.h"

#if PY_MAJOR_VERSION < 3
#define PyUnicode_AsUTF8 PyString_AsString
#define TP_FLAGS (Py_TPFLAGS_HAVE_CLASS | Py_TPFLAGS_CHECKTYPES | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_RICHCOMPARE)
#else
// XXX Restore tp_richcompare?
#define TP_FLAGS (Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE)
#endif

PedAlignment *_ped_Alignment2PedAlignment(PyObject *);
_ped_Alignment *PedAlignment2_ped_Alignment(PedAlignment *);

PedConstraint *_ped_Constraint2PedConstraint(PyObject *);
_ped_Constraint *PedConstraint2_ped_Constraint(PedConstraint *);

PedDevice *_ped_Device2PedDevice(PyObject *);
_ped_Device *PedDevice2_ped_Device(PedDevice *);

PedDisk *_ped_Disk2PedDisk(PyObject *);
_ped_Disk *PedDisk2_ped_Disk(PedDisk *);

PedDiskType *_ped_DiskType2PedDiskType(PyObject *);
_ped_DiskType *PedDiskType2_ped_DiskType(const PedDiskType *);

PedFileSystem *_ped_FileSystem2PedFileSystem(PyObject *);
_ped_FileSystem *PedFileSystem2_ped_FileSystem(PedFileSystem *);

PedFileSystemType *_ped_FileSystemType2PedFileSystemType(PyObject *);
_ped_FileSystemType *PedFileSystemType2_ped_FileSystemType(const PedFileSystemType *);

PedGeometry *_ped_Geometry2PedGeometry(PyObject *);
_ped_Geometry *PedGeometry2_ped_Geometry(PedGeometry *);

PedCHSGeometry *_ped_CHSGeometry2PedCHSGeometry(PyObject *);
_ped_CHSGeometry *PedCHSGeometry2_ped_CHSGeometry(PedCHSGeometry *);

PedPartition *_ped_Partition2PedPartition(_ped_Partition *);
_ped_Partition *PedPartition2_ped_Partition(PedPartition *, _ped_Disk *);

PedTimer *_ped_Timer2PedTimer(PyObject *);
_ped_Timer *PedTimer2_ped_Timer(PedTimer *);

#endif /* CONVERT_H_INCLUDED */

/* vim:tw=78:ts=4:et:sw=4
 */
07070100115876000081A40000FFFE0000FFFD0000000157CD697A00000675000000FC0000001000000000000000000000002D00000000pyparted-1466619794.7a0f829/include/pyunit.h/*
 * pyunit.h
 * pyparted type definitions for pyunit.c
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#ifndef PYUNIT_H_INCLUDED
#define PYUNIT_H_INCLUDED

#include <Python.h>

#include <parted/parted.h>

/* a PedUnit is a long int in C, so we store it that way in Python */

/* 1:1 function mappings for unit.h in libparted */
PyObject *py_ped_unit_set_default(PyObject *, PyObject *);
PyObject *py_ped_unit_get_default(PyObject *, PyObject *);
PyObject *py_ped_unit_get_name(PyObject *, PyObject *);
PyObject *py_ped_unit_get_by_name(PyObject *, PyObject *);

#endif /* PYUNIT_H_INCLUDED */

/* vim:tw=78:ts=4:et:sw=4
 */
07070100115877000081A40000FFFE0000FFFD0000000157CD697A00000A44000000FC0000001000000000000000000000003000000000pyparted-1466619794.7a0f829/include/pynatmath.h/*
 * pynatmath.h
 * pyparted type definitions for pynatmath.c
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Chris Lumens <clumens@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#ifndef PYNATMATH_H_INCLUDED
#define PYNATMATH_H_INCLUDED

#include <Python.h>

#include <parted/parted.h>

/* 1:1 function mappings for natmath.h in libparted */
PyObject *py_ped_alignment_duplicate(PyObject *, PyObject *);
PyObject *py_ped_alignment_intersect(PyObject *, PyObject *);
PyObject *py_ped_alignment_align_up(PyObject *, PyObject *);
PyObject *py_ped_alignment_align_down(PyObject *, PyObject *);
PyObject *py_ped_alignment_align_nearest(PyObject *, PyObject *);
PyObject *py_ped_alignment_is_aligned(PyObject *, PyObject *);

/* _ped.Alignment type is the Python equivalent of PedAlignment in libparted */
typedef struct {
    PyObject_HEAD

/* PedAlignment members */
    long long offset;              /* PedSector */
    long long grain_size;          /* PedSector */
} _ped_Alignment;

void _ped_Alignment_dealloc(_ped_Alignment *);
int _ped_Alignment_compare(_ped_Alignment *, PyObject *);
PyObject *_ped_Alignment_richcompare(_ped_Alignment *, PyObject *, int);
PyObject *_ped_Alignment_str(_ped_Alignment *);
int _ped_Alignment_traverse(_ped_Alignment *, visitproc, void *);
int _ped_Alignment_clear(_ped_Alignment *);
int _ped_Alignment_init(_ped_Alignment *, PyObject *, PyObject *);
PyObject *_ped_Alignment_get(_ped_Alignment *, void *);
int _ped_Alignment_set(_ped_Alignment *, PyObject *, void *);

extern PyTypeObject _ped_Alignment_Type_obj;

#endif /* PYNATMATH_H_INCLUDED */

/* vim:tw=78:ts=4:et:sw=4
 */
07070100115878000081A40000FFFE0000FFFD0000000157CD697A0000058E000000FC0000001000000000000000000000003100000000pyparted-1466619794.7a0f829/include/_pedmodule.h/*
 * _pedmodule.h
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#ifndef _PARTEDMODULE_H_INCLUDED
#define _PARTEDMODULE_H_INCLUDED

#include <Python.h>

extern PyObject *py_libparted_get_version(PyObject *, PyObject *);
extern PyObject *py_pyparted_version(PyObject *, PyObject *);
extern PyMODINIT_FUNC PyInit__ped(void);

#endif /* _PARTEDMODULE_H_INCLUDED */

/* vim:tw=78:ts=4:et:sw=4
 */
07070100115882000081A40000FFFE0000FFFD0000000157CD697A00000C41000000FC0000001000000000000000000000002D00000000pyparted-1466619794.7a0f829/include/pygeom.h/*
 * pygeom.h
 * pyparted type definitions for pygeom.c
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Chris Lumens <clumens@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#ifndef PYGEOM_H_INCLUDED
#define PYGEOM_H_INCLUDED

#include <Python.h>

#include <parted/parted.h>

/* 1:1 function mappings for geom.h in libparted */
PyObject *py_ped_geometry_duplicate(PyObject *, PyObject *);
PyObject *py_ped_geometry_intersect(PyObject *, PyObject *);
PyObject *py_ped_geometry_set(PyObject *, PyObject *);
PyObject *py_ped_geometry_set_start(PyObject *, PyObject *);
PyObject *py_ped_geometry_set_end(PyObject *, PyObject *);
PyObject *py_ped_geometry_test_overlap(PyObject *, PyObject *);
PyObject *py_ped_geometry_test_inside(PyObject *, PyObject *);
PyObject *py_ped_geometry_test_equal(PyObject *, PyObject *);
PyObject *py_ped_geometry_test_sector_inside(PyObject *, PyObject *);
PyObject *py_ped_geometry_read(PyObject *, PyObject *);
PyObject *py_ped_geometry_sync(PyObject *, PyObject *);
PyObject *py_ped_geometry_sync_fast(PyObject *, PyObject *);
PyObject *py_ped_geometry_write(PyObject *, PyObject *);
PyObject *py_ped_geometry_check(PyObject *, PyObject *);
PyObject *py_ped_geometry_map(PyObject *, PyObject *);

/* _ped.Geometry type is the Python equivalent of PedGeometry in libparted */
typedef struct {
    PyObject_HEAD

/* PedGeometry members */
    PyObject *dev;                /* _ped.Device */

/* store the PedGeometry from libparted */
    PedGeometry *ped_geometry;
} _ped_Geometry;

void _ped_Geometry_dealloc(_ped_Geometry *);
int _ped_Geometry_compare(_ped_Geometry *, PyObject *);
PyObject *_ped_Geometry_richcompare(_ped_Geometry *, PyObject *, int);
PyObject *_ped_Geometry_str(_ped_Geometry *);
int _ped_Geometry_traverse(_ped_Geometry *, visitproc, void *);
int _ped_Geometry_clear(_ped_Geometry *);
int _ped_Geometry_init(_ped_Geometry *, PyObject *, PyObject *);
PyObject *_ped_Geometry_get(_ped_Geometry *, void *);
int _ped_Geometry_set(_ped_Geometry *, PyObject *, void *);

extern PyTypeObject _ped_Geometry_Type_obj;

#endif /* PYGEOM_H_INCLUDED */

/* vim:tw=78:ts=4:et:sw=4
 */
07070100115883000081A40000FFFE0000FFFD0000000157CD697A00001328000000FC0000001000000000000000000000002F00000000pyparted-1466619794.7a0f829/include/pydevice.h/*
 * pydevice.h
 * pyparted type definitions for pydevice.c
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#ifndef PYDEVICE_H_INCLUDED
#define PYDEVICE_H_INCLUDED

#include <Python.h>

#include <parted/parted.h>

/* _ped.CHSGeometry type is the Python equiv of PedCHSGeometry in libparted */
typedef struct {
    PyObject_HEAD

/* a PedCHSGeometry stores three ints */
    int cylinders;
    int heads;
    int sectors;
} _ped_CHSGeometry;

void _ped_CHSGeometry_dealloc(_ped_CHSGeometry *);
int _ped_CHSGeometry_compare(_ped_CHSGeometry *, PyObject *);
PyObject *_ped_CHSGeometry_richcompare(_ped_CHSGeometry *, PyObject *, int);
PyObject *_ped_CHSGeometry_str(_ped_CHSGeometry *);
int _ped_CHSGeometry_traverse(_ped_CHSGeometry *, visitproc, void *);
int _ped_CHSGeometry_clear(_ped_CHSGeometry *);
PyObject *_ped_CHSGeometry_get(_ped_CHSGeometry *, void *);

extern PyTypeObject _ped_CHSGeometry_Type_obj;

/* _ped.Device type is the Python equivalent of PedDevice in libparted */
typedef struct {
    PyObject_HEAD

/* a PedDevice is complex, we will store primitives when appropriate or
     * just other Python objects we've created for the typedefs in libparted */
    char *model;
    char *path;
    long long type;
    long long sector_size;
    long long phys_sector_size;
    long long length;             /* PedSector */
    int open_count;
    int read_only;
    int external_mode;
    int dirty;
    int boot_dirty;
    PyObject *hw_geom;            /* a _ped.CHSGeometry */
    PyObject *bios_geom;          /* a _ped.CHSGeometry */
    short host;
    short did;
} _ped_Device;

void _ped_Device_dealloc(_ped_Device *);
int _ped_Device_compare(_ped_Device *, PyObject *);
PyObject *_ped_Device_richcompare(_ped_Device *, PyObject *, int);
PyObject *_ped_Device_str(_ped_Device *);
int _ped_Device_traverse(_ped_Device *, visitproc, void *);
int _ped_Device_clear(_ped_Device *);
PyObject *_ped_Device_get(_ped_Device *, void *);

extern PyTypeObject _ped_Device_Type_obj;

/* 1:1 function mappings for device.h in libparted */
PyObject *py_ped_disk_probe(PyObject *, PyObject *);
PyObject *py_ped_device_probe_all(PyObject *, PyObject *);
PyObject *py_ped_device_free_all(PyObject *, PyObject *);
PyObject *py_ped_device_get(PyObject *, PyObject *);
PyObject *py_ped_device_get_next(PyObject *, PyObject *);
PyObject *py_ped_device_is_busy(PyObject *, PyObject *);
PyObject *py_ped_device_open(PyObject *, PyObject *);
PyObject *py_ped_device_close(PyObject *, PyObject *);
PyObject *py_ped_device_destroy(PyObject *, PyObject *);
PyObject *py_ped_device_cache_remove(PyObject *, PyObject *);
PyObject *py_ped_device_begin_external_access(PyObject *, PyObject *);
PyObject *py_ped_device_end_external_access(PyObject *, PyObject *);
PyObject *py_ped_device_read(PyObject *, PyObject *);
PyObject *py_ped_device_write(PyObject *, PyObject *);
PyObject *py_ped_device_sync(PyObject *, PyObject *);
PyObject *py_ped_device_sync_fast(PyObject *, PyObject *);
PyObject *py_ped_device_check(PyObject *, PyObject *);
PyObject *py_ped_device_get_constraint(PyObject *, PyObject *);
PyObject *py_ped_device_get_minimal_aligned_constraint(PyObject *, PyObject *);
PyObject *py_ped_device_get_optimal_aligned_constraint(PyObject *, PyObject *);
PyObject *py_ped_device_get_minimum_alignment(PyObject *, PyObject *);
PyObject *py_ped_device_get_optimum_alignment(PyObject *, PyObject *);
PyObject *py_ped_unit_get_size(PyObject *, PyObject *);
PyObject *py_ped_unit_format_custom_byte(PyObject *, PyObject *);
PyObject *py_ped_unit_format_byte(PyObject *, PyObject *);
PyObject *py_ped_unit_format_custom(PyObject *, PyObject *);
PyObject *py_ped_unit_format(PyObject *, PyObject *);
PyObject *py_ped_unit_parse(PyObject *, PyObject *);
PyObject *py_ped_unit_parse_custom(PyObject *, PyObject *);

#endif /* PYDEVICE_H_INCLUDED */

/* vim:tw=78:ts=4:et:sw=4
 */
07070100115884000081A40000FFFE0000FFFD0000000157CD697A000006F0000000FC0000001000000000000000000000003100000000pyparted-1466619794.7a0f829/include/exceptions.h/*
 * exceptions.h
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): Chris Lumens <clumens@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#ifndef _EXCEPTIONS_H_INCLUDED
#define _EXCEPTIONS_H_INCLUDED

#include <Python.h>

/* custom exceptions for _ped */
PyObject *AlignmentException;
PyObject *CreateException;
PyObject *ConstraintException;
PyObject *DeviceException;
PyObject *DiskException;
PyObject *DiskLabelException;
PyObject *FileSystemException;
PyObject *GeometryException;
PyObject *IOException;
PyObject *NotNeededException;
PyObject *PartedException;
PyObject *PartitionException;
PyObject *TimerException;
PyObject *UnknownDeviceException;
PyObject *UnknownTypeException;

extern unsigned int partedExnRaised;
extern char *partedExnMessage;

#endif /* _EXCEPTIONS_H_INCLUDED */

/* vim:tw=78:ts=4:et:sw=4
 */
07070100115885000081A40000FFFE0000FFFD0000000157CD697A00000C76000000FC0000001000000000000000000000003300000000pyparted-1466619794.7a0f829/include/pyconstraint.h/*
 * pyconstraint.h
 * pyparted type definitions for pyconstraint.c
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Chris Lumens <clumens@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#ifndef PYCONSTRAINT_H_INCLUDED
#define PYCONSTRAINT_H_INCLUDED

#include <Python.h>

#include <parted/parted.h>

/* 1:1 function mappings for constraint.h in libparted */
PyObject *py_ped_constraint_new_from_min_max(PyObject *, PyObject *);
PyObject *py_ped_constraint_new_from_min(PyObject *, PyObject *);
PyObject *py_ped_constraint_new_from_max(PyObject *, PyObject *);
PyObject *py_ped_constraint_duplicate(PyObject *, PyObject *);
PyObject *py_ped_constraint_intersect(PyObject *, PyObject *);
PyObject *py_ped_constraint_solve_max(PyObject *, PyObject *);
PyObject *py_ped_constraint_solve_nearest(PyObject *, PyObject *);
PyObject *py_ped_constraint_is_solution(PyObject *, PyObject *);
PyObject *py_ped_constraint_any(PyObject *, PyObject *);
PyObject *py_ped_constraint_exact(PyObject *, PyObject *);

/* _ped.Constraint type is the Python equiv of PedConstraint in libparted */
typedef struct {
    PyObject_HEAD

/* PedConstraint members */
    PyObject *start_align;              /* _ped.Alignment */
    PyObject *end_align;                /* _ped.Alignment */
    PyObject *start_range;              /* _ped.Geometry  */
    PyObject *end_range;                /* _ped.Geometry  */
    long long min_size;                 /* PedSector      */
    long long max_size;                 /* PedSector      */
} _ped_Constraint;

void _ped_Constraint_dealloc(_ped_Constraint *);
int _ped_Constraint_compare(_ped_Constraint *, PyObject *);
PyObject *_ped_Constraint_richcompare(_ped_Constraint *, PyObject *, int);
PyObject *_ped_Constraint_str(_ped_Constraint *);
int _ped_Constraint_traverse(_ped_Constraint *, visitproc, void *);
int _ped_Constraint_clear(_ped_Constraint *);
int _ped_Constraint_init(_ped_Constraint *, PyObject *, PyObject *);
PyObject *_ped_Constraint_get(_ped_Constraint *, void *);
int _ped_Constraint_set(_ped_Constraint *, PyObject *, void *);

extern PyTypeObject _ped_Constraint_Type_obj;

#endif /* PYCONSTRAINT_H_INCLUDED */

/* vim:tw=78:ts=4:et:sw=4
 */
07070100115886000081A40000FFFE0000FFFD0000000157CD697A00000D82000000FC0000001000000000000000000000003000000000pyparted-1466619794.7a0f829/include/pyfilesys.h/*
 * pyfilesys.h
 * pyparted type definitions for pyfilesys.c
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Chris Lumens <clumens@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#ifndef PYFILESYS_H_INCLUDED
#define PYFILESYS_H_INCLUDED

#include <Python.h>

#include <parted/parted.h>

/* These functions need to be added to libparted.  Remove when that's done. */
#define ped_file_system_destroy(fs)

/* 1:1 function mappings for filesys.h in libparted */
PyObject *py_ped_file_system_type_get(PyObject *, PyObject *);
PyObject *py_ped_file_system_type_get_next(PyObject *, PyObject *);
PyObject *py_ped_file_system_probe_specific(PyObject *, PyObject *);
PyObject *py_ped_file_system_probe(PyObject *, PyObject *);

/* _ped.FileSystemType type is the Python equivalent of PedFileSystemType
 * in libparted */
typedef struct {
    PyObject_HEAD

/* PedFileSystemType members */
    char *name;
} _ped_FileSystemType;

void _ped_FileSystemType_dealloc(_ped_FileSystemType *);
int _ped_FileSystemType_compare(_ped_FileSystemType *, PyObject *);
PyObject *_ped_FileSystemType_richcompare(_ped_FileSystemType *, PyObject *,
                                          int);
PyObject *_ped_FileSystemType_str(_ped_FileSystemType *);
int _ped_FileSystemType_traverse(_ped_FileSystemType *, visitproc, void *);
int _ped_FileSystemType_clear(_ped_FileSystemType *);
PyObject *_ped_FileSystemType_get(_ped_FileSystemType *, void *);

extern PyTypeObject _ped_FileSystemType_Type_obj;

/* _ped.FileSystem type is the Python equiv of PedFileSystem in libparted */
typedef struct {
    PyObject_HEAD

/* PedFileSystem members */
    PyObject *type;                /* _ped.FileSystemType */
    PyObject *geom;                /* _ped.Geometry */
    int checked;

/* store the PedFileSystem from libparted */
    PedFileSystem *ped_filesystem;
} _ped_FileSystem;

void _ped_FileSystem_dealloc(_ped_FileSystem *);
int _ped_FileSystem_compare(_ped_FileSystem *, PyObject *);
PyObject *_ped_FileSystem_richcompare(_ped_FileSystem *, PyObject *, int);
PyObject *_ped_FileSystem_str(_ped_FileSystem *);
int _ped_FileSystem_traverse(_ped_FileSystem *, visitproc, void *);
int _ped_FileSystem_clear(_ped_FileSystem *);
int _ped_FileSystem_init(_ped_FileSystem *, PyObject *, PyObject *);
PyObject *_ped_FileSystem_get(_ped_FileSystem *, void *);

extern PyTypeObject _ped_FileSystem_Type_obj;

#endif /* PYFILESYS_H_INCLUDED */

/* vim:tw=78:ts=4:et:sw=4
 */
07070100115887000081A40000FFFE0000FFFD0000000157CD697A00001C65000000FC0000001000000000000000000000002D00000000pyparted-1466619794.7a0f829/include/pydisk.h/*
 * pydisk.h
 * pyparted type definitions for pydisk.c
 *
 * Copyright (C) 2007-2013 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.
 *
 * Author(s): David Cantrell <dcantrell@redhat.com>
 *            Chris Lumens <clumens@redhat.com>
 *            Alex Skinner <alex@lx.lc>
 */

#ifndef PYDISK_H_INCLUDED
#define PYDISK_H_INCLUDED

#include <Python.h>

#include <parted/parted.h>

/* _ped.Partition type is the Python equivalent of PedPartition
 * in libparted */
typedef struct {
    PyObject_HEAD

/* PedPartition members */
    PyObject *disk;                /* _ped.Disk */
    PyObject *geom;                /* _ped.Geometry */
    int type;                      /* PedPartitionType */
    PyObject *fs_type;             /* _ped.FileSystemType */

/* store the PedPartition from libparted */
    PedPartition *ped_partition;

int _owned;                    /* Belongs to a Disk or not */
} _ped_Partition;

void _ped_Partition_dealloc(_ped_Partition *);
int _ped_Partition_compare(_ped_Partition *, PyObject *);
PyObject *_ped_Partition_richcompare(_ped_Partition *, PyObject *, int);
PyObject *_ped_Partition_str(_ped_Partition *);
int _ped_Partition_traverse(_ped_Partition *, visitproc, void *);
int _ped_Partition_clear(_ped_Partition *);
int _ped_Partition_init(_ped_Partition *, PyObject *, PyObject *);
PyObject *_ped_Partition_get(_ped_Partition *, void *);
int _ped_Partition_set(_ped_Partition *, PyObject *, void *);

extern PyTypeObject _ped_Partition_Type_obj;

/* _ped.Disk type is the Python equivalent of PedDisk in libparted */
typedef struct {
    PyObject_HEAD

/* PedDisk members */
    PyObject *dev;             /* _ped.Device */
    PyObject *type;            /* _ped.DiskType */

/* store the PedDisk from libparted */
    PedDisk *ped_disk;
} _ped_Disk;

void _ped_Disk_dealloc(_ped_Disk *);
int _ped_Disk_compare(_ped_Disk *, PyObject *);
PyObject *_ped_Disk_richcompare(_ped_Disk *, PyObject *, int);
PyObject *_ped_Disk_str(_ped_Disk *);
int _ped_Disk_traverse(_ped_Disk *, visitproc, void *);
int _ped_Disk_clear(_ped_Disk *);
int _ped_Disk_init(_ped_Disk *, PyObject *, PyObject *);

extern PyTypeObject _ped_Disk_Type_obj;

/* _ped.DiskType type is the Python equivalent of PedDiskType in libparted */
typedef struct {
    PyObject_HEAD

/* PedDiskType members */
    char *name;
    long long features;        /* PedDiskTypeFeature */
} _ped_DiskType;

void _ped_DiskType_dealloc(_ped_DiskType *);
int _ped_DiskType_compare(_ped_DiskType *, PyObject *);
PyObject *_ped_DiskType_richcompare(_ped_DiskType *, PyObject *, int);
PyObject *_ped_DiskType_str(_ped_DiskType *);
int _ped_DiskType_traverse(_ped_DiskType *, visitproc, void *);
int _ped_DiskType_clear(_ped_DiskType *);
PyObject *_ped_DiskType_get(_ped_DiskType *, void *);

extern PyTypeObject _ped_DiskType_Type_obj;

/* 1:1 function mappings for disk.h in libparted */
PyObject *py_ped_disk_type_get_next(PyObject *, PyObject *);
PyObject *py_ped_disk_type_get(PyObject *, PyObject *);
PyObject *py_ped_disk_type_check_feature(PyObject *, PyObject *);
PyObject *py_ped_disk_clobber(PyObject *, PyObject *);
PyObject *py_ped_disk_duplicate(PyObject *, PyObject *);
PyObject *py_ped_disk_destroy(PyObject *, PyObject *);
PyObject *py_ped_disk_commit(PyObject *, PyObject *);
PyObject *py_ped_disk_commit_to_dev(PyObject *, PyObject *);
PyObject *py_ped_disk_commit_to_os(PyObject *, PyObject *);
PyObject *py_ped_disk_check(PyObject *, PyObject *);
PyObject *py_ped_disk_print(PyObject *, PyObject *);
PyObject *py_ped_disk_get_primary_partition_count(PyObject *, PyObject *);
PyObject *py_ped_disk_get_last_partition_num(PyObject *, PyObject *);
PyObject *py_ped_disk_get_max_primary_partition_count(PyObject *, PyObject *);
PyObject *py_ped_disk_get_max_supported_partition_count(PyObject *, PyObject *);
PyObject *py_ped_disk_get_partition_alignment(PyObject *, PyObject *);
PyObject *py_ped_disk_max_partition_length(PyObject *, PyObject *);
PyObject *py_ped_disk_max_partition_start_sector(PyObject *, PyObject *);
PyObject *py_ped_disk_set_flag(PyObject *, PyObject *);
PyObject *py_ped_disk_get_flag(PyObject *, PyObject *);
PyObject *py_ped_disk_is_flag_available(PyObject *, PyObject *);
PyObject *py_ped_disk_flag_get_name(PyObject *, PyObject *);
PyObject *py_ped_disk_flag_get_by_name(PyObject *, PyObject *);
PyObject *py_ped_disk_flag_next(PyObject *, PyObject *);
PyObject *py_ped_partition_destroy(_ped_Partition *, PyObject *);
PyObject *py_ped_partition_is_active(_ped_Partition *, PyObject *);
PyObject *py_ped_partition_set_flag(_ped_Partition *, PyObject *);
PyObject *py_ped_partition_get_flag(_ped_Partition *, PyObject *);
PyObject *py_ped_partition_is_flag_available(_ped_Partition *, PyObject *);
PyObject *py_ped_partition_set_system(_ped_Partition *, PyObject *);
PyObject *py_ped_partition_set_name(_ped_Partition *, PyObject *);
PyObject *py_ped_partition_get_name(_ped_Partition *, PyObject *);
PyObject *py_ped_partition_is_busy(_ped_Partition *, PyObject *);
PyObject *py_ped_partition_get_path(_ped_Partition *, PyObject *);
PyObject *py_ped_partition_reset_num(_ped_Partition *, PyObject *);
PyObject *py_ped_partition_type_get_name(PyObject *, PyObject *);
PyObject *py_ped_partition_flag_get_name(PyObject *, PyObject *);
PyObject *py_ped_partition_flag_get_by_name(PyObject *, PyObject *);
PyObject *py_ped_partition_flag_next(PyObject *, PyObject *);
PyObject *py_ped_disk_add_partition(PyObject *, PyObject *);
PyObject *py_ped_disk_remove_partition(PyObject *, PyObject *);
PyObject *py_ped_disk_delete_partition(PyObject *, PyObject *);
PyObject *py_ped_disk_delete_all(PyObject *, PyObject *);
PyObject *py_ped_disk_set_partition_geom(PyObject *, PyObject *);
PyObject *py_ped_disk_maximize_partition(PyObject *, PyObject *);
PyObject *py_ped_disk_get_max_partition_geometry(PyObject *, PyObject *);
PyObject *py_ped_disk_minimize_extended_partition(PyObject *, PyObject *);
PyObject *py_ped_disk_next_partition(PyObject *, PyObject *);
PyObject *py_ped_disk_get_partition(PyObject *, PyObject *);
PyObject *py_ped_disk_get_partition_by_sector(PyObject *, PyObject *);
PyObject *py_ped_disk_extended_partition(PyObject *, PyObject *);
PyObject *py_ped_disk_new_fresh(PyObject *, PyObject *);
PyObject *py_ped_disk_new(PyObject *, PyObject *);

#endif /* PYDISK_H_INCLUDED */

/* vim:tw=78:ts=4:et:sw=4
 */
070701001158A0000081ED0000FFFE0000FFFD0000000157CD697A00000162000000FC0000001000000000000000000000003600000000pyparted-1466619794.7a0f829/tests/pylint/runpylint.py#!/usr/bin/python3

import sys

from pocketlint import PocketLintConfig, PocketLinter

class PypartedLintConfig(PocketLintConfig):
    @property
    def extraArgs(self):
        return ["--extension-pkg-whitelist", "_ped"]

if __name__ == "__main__":
    conf = PypartedLintConfig()
    linter = PocketLinter(conf)
    rc = linter.run()
    sys.exit(rc)
0707010011589F000041ED0000FFFE0000FFFD0000000257CD697A00000000000000FC0000001000000000000000000000002900000000pyparted-1466619794.7a0f829/tests/pylint0707010011588A000081A40000FFFE0000FFFD0000000157CD697A00000000000000FC0000001000000000000000000000002E00000000pyparted-1466619794.7a0f829/tests/__init__.py0707010011588B000081ED0000FFFE0000FFFD0000000157CD697A0000261E000000FC0000001000000000000000000000003600000000pyparted-1466619794.7a0f829/tests/test_parted_disk.py#
# Test cases for the methods in the parted.disk module itself
#
# Copyright (C) 2009  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 parted
import unittest

from tests.baseclass import RequiresDisk

# One class per method, multiple tests per class.  For these simple methods,
# that seems like good organization.  More complicated methods may require
# multiple classes and their own test suite.
@unittest.skip("Unimplemented test case.")
class DiskNewTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskGetSetTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskClobberTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskDuplicateTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskDestroyTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskCommitTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskCommitToDeviceTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskCommitToOSTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskCheckTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskSupportsFeatureTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

class DiskAddPartitionTestCase(RequiresDisk):
    """
        addPartition should return True if partition is added successfully(even
        without committing)
    """
    def runTest(self):
        self.disk.setFlag(parted.DISK_CYLINDER_ALIGNMENT)

length = 100
        geom = parted.Geometry(self.device, start=100, length=length)
        part = parted.Partition(self.disk, parted.PARTITION_NORMAL, geometry=geom)
        constraint = parted.Constraint(exactGeom=geom)
        self.assertTrue(self.disk.addPartition(part, constraint))

@unittest.skip("Unimplemented test case.")
class DiskRemovePartitionTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskDeletePartitionTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskDeleteAllPartitionsTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskSetPartitionGeometryTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskMaximizePartitionTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskCalculateMaxPartitionGeometryTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskMinimizeExtendedPartitionTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskGetPartitionBySectorTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

class DiskGetMaxLogicalPartitionsTestCase(RequiresDisk):
    """
        getMaxLogicalPartitions return int values based on which type of disk
        is used. It search for occurrence of keys in device path(e.g. /dev/sda)
        and compare it with predefined values("sd": 11). As unittest
        environment is using file with generic name(e.g.
        /tmp/temp-device-C64w78), test focus only on type of returned value
    """
    def runTest(self):
        self.assertIsInstance(self.disk.getMaxLogicalPartitions(), int)

class DiskGetMaxSupportedPartitionCountTestCase(RequiresDisk):
    """
        maxSupportedPartitionCount should return value 64, based on default
        value MAX_NUM_PARTS(parted/libparted/arch/linux.c) applied if it cannot
        find value in /sys/block/DEV/ext_range (RequiresDisk implies there is
        no ext_range value). Also see testcase
        DiskGetMaxSupportedPartitionCountTestCase in tests/test__ped_disk ,
        which tests value returned by source C function defined in module _ped
    """
    def runTest(self):
        self.assertEqual(self.disk.maxSupportedPartitionCount, 64)

class DiskMaxPartitionLengthTestCase(RequiresDisk):
    def runTest(self):
        # This test assumes an MSDOS label as given by RequiresDisk
        self.assertEqual(self.disk.maxPartitionLength, 4294967295)

class DiskMaxPartitionStartSectorTestCase(RequiresDisk):
    def runTest(self):
        # This test assumes an MSDOS label as given by RequiresDisk
        self.assertEqual(self.disk.maxPartitionStartSector, 4294967295)

class DiskGetFlagTestCase(RequiresDisk):
    def runTest(self):
        flag = self.disk.getFlag(parted.DISK_CYLINDER_ALIGNMENT)
        self.assertIsInstance(flag, bool)

class DiskSetFlagTestCase(RequiresDisk):
    def runTest(self):
        # This test assumes an MSDOS label as given by RequiresDisk
        self.disk.setFlag(parted.DISK_CYLINDER_ALIGNMENT)
        flag = self.disk.getFlag(parted.DISK_CYLINDER_ALIGNMENT)
        self.assertEqual(flag, True)

class DiskUnsetFlagTestCase(RequiresDisk):
    def runTest(self):
        # This test assumes an MSDOS label as given by RequiresDisk
        self.disk.unsetFlag(parted.DISK_CYLINDER_ALIGNMENT)
        flag = self.disk.getFlag(parted.DISK_CYLINDER_ALIGNMENT)
        self.assertEqual(flag, False)

class DiskIsFlagAvailableTestCase(RequiresDisk):
    def runTest(self):
        # This test assumes an MSDOS label as given by RequiresDisk
        available = self.disk.isFlagAvailable(parted.DISK_CYLINDER_ALIGNMENT)
        self.assertEqual(available, True)

@unittest.skip("Unimplemented test case.")
class DiskGetExtendedPartitionTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskGetLogicalPartitionsTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskGetPrimaryPartitionsTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskGetRaidPartitionsTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskGetLVMPartitionsTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskGetFreeSpaceRegionsTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskGetFreeSpacePartitionsTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskGetFirstPartitionTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskGetPartitionByPathTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskGetPedDiskTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskStrTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")
0707010011588C000081ED0000FFFE0000FFFD0000000157CD697A0000148D000000FC0000001000000000000000000000003800000000pyparted-1466619794.7a0f829/tests/test_parted_device.py#
# Test cases for the methods in the parted.device module itself
#
# Copyright (C) 2009-2011  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 unittest
from tests.baseclass import RequiresDevice

# One class per method, multiple tests per class.  For these simple methods,
# that seems like good organization.  More complicated methods may require
# multiple classes and their own test suite.
@unittest.skip("Unimplemented test case.")
class DeviceNewTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DeviceGetSetTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DeviceOpenTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DeviceCloseTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DeviceDestroyTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DeviceRemoveFromCacheTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DeviceBeginExternalAccessTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DeviceEndExternalAccessTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DeviceReadTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DeviceWriteTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DeviceSyncTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DeviceCheckTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DeviceStartSectorToCylinderTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DeviceEndSectorToCylinderTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DeviceStartCylinderToSectorTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DeviceEndCylinderToSectorTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DeviceGetSizeTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

class DeviceGetLengthTestCase(RequiresDevice):
    def runTest(self):
        self.assertEqual(self.device.getLength(), self.device.length)

@unittest.skip("Unimplemented test case.")
class DeviceGetSizeAsSectorsTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DeviceGetConstraintTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DeviceGetPedDeviceTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DeviceStrTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")
0707010011588D000081ED0000FFFE0000FFFD0000000157CD697A000010CE000000FC0000001000000000000000000000003A00000000pyparted-1466619794.7a0f829/tests/test_parted_geometry.py#
# Test cases for the methods in the parted.geometry module itself
#
# Copyright (C) 2009-2011  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 parted
import unittest

from tests.baseclass import RequiresDevice

# One class per method, multiple tests per class.  For these simple methods,
# that seems like good organization.  More complicated methods may require
# multiple classes and their own test suite.
@unittest.skip("Unimplemented test case.")
class GeometryNewTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class GeometryGetSetTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class GeometryCheckTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class GeometryContainsTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class GeometryContainsSectorTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class GeometryEqualTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class GeometryGetSizeTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

class GeometryGetLengthTestCase(RequiresDevice):
    def runTest(self):
        length = 137
        geom = parted.Geometry(self.device, start=100, length=length)

self.assertEqual(geom.getLength(), geom.length)
        self.assertEqual(geom.getLength(), length)

@unittest.skip("Unimplemented test case.")
class GeometryIntersectTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class GeometryMapTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class GeometryOverlapsWithTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class GeometryReadTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class GeometrySyncTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class GeometryWriteTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class GeometryGetPedGeometryTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class GeometryStrTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")
0707010011588E000081ED0000FFFE0000FFFD0000000157CD697A00001909000000FC0000001000000000000000000000003800000000pyparted-1466619794.7a0f829/tests/test_parted_parted.py#
# Test cases for the methods in the parted module itself
#
# Copyright (C) 2009-2011  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>
#

from __future__ import division

import _ped
import parted
import unittest
from tests.baseclass import RequiresDevice, RequiresDeviceNode

# One class per method, multiple tests per class.  For these simple methods,
# that seems like good organization.  More complicated methods may require
# multiple classes and their own test suite.
class FormatBytesTestCase(unittest.TestCase):
    def runTest(self):
        self.assertRaises(SyntaxError, parted.formatBytes, 57, "GIB")
        self.assertEqual(1e-24, parted.formatBytes(1, "YB"))
        self.assertEqual(1/2**80, parted.formatBytes(1, "YiB"))
        self.assertEqual(1, parted.formatBytes(1, 'B'))
        self.assertEqual(1, parted.formatBytes(1e24, 'YB'))
        self.assertEqual(1, parted.formatBytes(2**80, 'YiB'))

class BytesToSectorsTestCase(unittest.TestCase):
    def runTest(self):
        self.assertRaises(SyntaxError, parted.sizeToSectors, 9, "yb", 1)
        self.assertEqual(int(parted.sizeToSectors(7777.0, "B", 512)),
                             parted.sizeToSectors(7777.0, "B", 512))

class GetLabelsTestCase(unittest.TestCase):
    def runTest(self):
        self.assertGreater(len(parted.getLabels()), 0)
        self.assertSetEqual(parted.getLabels('ppcc'), set())
        self.assertSetEqual(parted.getLabels('sparc6'), set())
        self.assertSetEqual(parted.getLabels('i586'), {'gpt', 'msdos'})
        self.assertSetEqual(parted.getLabels('s390'), {'dasd', 'msdos'})
        self.assertSetEqual(parted.getLabels('s390x'), {'dasd', 'msdos'})
        self.assertSetEqual(parted.getLabels('sparc'), {'sun'})
        self.assertSetEqual(parted.getLabels('sparc64'), {'sun'})
        self.assertSetEqual(parted.getLabels('ppc'), {'amiga', 'gpt', 'mac', 'msdos'})
        self.assertSetEqual(parted.getLabels('ppc64'), {'amiga', 'gpt', 'mac', 'msdos'})
        self.assertSetEqual(parted.getLabels('ppc64le'), {'gpt', 'msdos'})
        self.assertSetEqual(parted.getLabels('alpha'), {'bsd', 'msdos'})
        self.assertSetEqual(parted.getLabels('ia64'), {'gpt', 'msdos'})
        self.assertSetEqual(parted.getLabels('aarch64'), {'gpt', 'msdos'})
        self.assertSetEqual(parted.getLabels('armv7l'), {'gpt', 'msdos'})

class GetDeviceTestCase(RequiresDeviceNode):
    def runTest(self):
        # Check that a DiskException is raised for an invalid path
        self.assertRaises(parted.DeviceException, parted.getDevice, None)
        self.assertRaises(parted.IOException, parted.getDevice, "")
        self.assertRaises(parted.IOException, parted.getDevice, "/dev/whatever")

# Check that we get a parted.Device back
        self.assertIsInstance(parted.getDevice(self.path), parted.Device)

# Make sure the device node paths match
        self.assertEqual(parted.getDevice(self.path).path, self.path)

class GetAllDevicesTestCase(unittest.TestCase):
    def setUp(self):
        self.devices = parted.getAllDevices()

def runTest(self):
        # Check self.devices and see that it's a list
        self.assertEqual(type(self.devices).__name__, 'list')

# And make sure each element of the list is a parted.Device
        for dev in self.devices:
            self.assertIsInstance(dev, parted.Device)

@unittest.skip("Unimplemented test case.")
class ProbeForSpecificFileSystemTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class ProbeFileSystemTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

class FreshDiskTestCase(RequiresDevice):
    def runTest(self):
        # Make sure we get SyntaxError when using an invalid disk type
        self.assertRaises(KeyError, parted.freshDisk, self.device, 'cheese')
        self.assertRaises(KeyError, parted.freshDisk, self.device, 'crackers')

# Create a new disk for each disk type key, verify each one
        # XXX: Skip over dvh for now (SGI disk label), which doesn't seem to have
        # working libparted support.  If anyone with an SGI cares, patches welcome.
        for key in parted.diskType.keys():
            if key in ['dvh', 'aix']:
                continue
            disk = parted.freshDisk(self.device, key)
            self.assertIsInstance(disk, parted.Disk)
            self.assertEqual(disk.type, key)

# Create a new disk each disk type value, verify each one
        for value in parted.diskType.values():
            if value.name in ['dvh', 'aix']:
                continue
            disk = parted.freshDisk(self.device, value)
            self.assertIsInstance(disk, parted.Disk)
            self.assertEqual(parted.diskType[disk.type], value)

@unittest.skip("Unimplemented test case.")
class IsAlignToCylindersTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class ToggleAlignToCylindersTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

class VersionTestCase(unittest.TestCase):
    def runTest(self):
        ver = parted.version()
        self.assertEqual(ver['libparted'], _ped.libparted_version())
        self.assertEqual(ver['pyparted'], _ped.pyparted_version())
0707010011588F000081ED0000FFFE0000FFFD0000000157CD697A00002062000000FC0000001000000000000000000000003400000000pyparted-1466619794.7a0f829/tests/test__ped_disk.py#
# Copyright (C) 2009-2011  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): Chris Lumens <clumens@redhat.com>
#                    David Cantrell <dcantrell@redhat.com>
#

import _ped
import unittest

from tests.baseclass import RequiresDevice, RequiresLabeledDevice, RequiresDisk

# One class per method, multiple tests per class.  For these simple methods,
# that seems like good organization.  More complicated methods may require
# multiple classes and their own test suite.
class DiskNewUnlabeledTestCase(RequiresDevice):
    def runTest(self):
        self.assertRaises(_ped.DiskLabelException, _ped.Disk, self._device)

class DiskNewLabeledTestCase(RequiresLabeledDevice):
    def runTest(self):
        result = _ped.Disk(self._device)
        self.assertIsInstance(result, _ped.Disk)
        self.assertEqual(result.type.name, 'msdos')

@unittest.skip("Unimplemented test case.")
class DiskGetSetTestCase(unittest.TestCase):
    # TODO
    def runTest(self):
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskClobberTestCase(unittest.TestCase):
    # TODO
    def runTest(self):
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskClobberExcludeTestCase(unittest.TestCase):
    # TODO
    def runTest(self):
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskDuplicateTestCase(unittest.TestCase):
    # TODO
    def runTest(self):
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskDestroyTestCase(unittest.TestCase):
    # TODO
    def runTest(self):
        self.fail("Unimplemented test case.")

class DiskCommitTestCase(RequiresDisk):
    def runTest(self):
        self.assertTrue(self._disk.commit())

class DiskCommitToDevTestCase(RequiresDisk):
    def runTest(self):
        self.assertTrue(self._disk.commit_to_dev())

class DiskCommitToOsTestCase(RequiresDisk):
    def runTest(self):
        self.assertTrue(self._disk.commit_to_os())

class DiskCheckTestCase(RequiresDisk):
    def runTest(self):
        self.assertTrue(self._disk.check())

@unittest.skip("Unimplemented test case.")
class DiskPrintTestCase(unittest.TestCase):
    # TODO
    def runTest(self):
        self.fail("Unimplemented test case.")

class DiskGetPrimaryPartitionCountTestCase(RequiresDisk):
    def runTest(self):
        # XXX: this could probably test more
        self.assertEqual(self._disk.get_primary_partition_count(), 0)

class DiskGetLastPartitionNumTestCase(RequiresDisk):
    def runTest(self):
        # XXX: this could probably test more
        self.assertEqual(self._disk.get_last_partition_num(), -1)

class DiskGetMaxPrimaryPartitionCountTestCase(RequiresDisk):
    def runTest(self):
        self.assertEqual(self._disk.get_max_primary_partition_count(), 4)

class DiskGetMaxSupportedPartitionCountTestCase(RequiresDisk):
    def runTest(self):
        self.assertEqual(self._disk.get_max_supported_partition_count(), 64)

class DiskGetPartitionAlignmentTestCase(RequiresDisk):
    def runTest(self):
        alignment = self._disk.get_partition_alignment()
        self.assertIsInstance(alignment, _ped.Alignment)
        # These 2 tests assume an MSDOS label as given by RequiresDisk
        self.assertEqual(alignment.offset, 0)
        self.assertEqual(alignment.grain_size, 1)

class DiskMaxPartitionLengthTestCase(RequiresDisk):
    def runTest(self):
        # This test assumes an MSDOS label as given by RequiresDisk
        self.assertEqual(self._disk.max_partition_length(), 4294967295)

class DiskMaxPartitionStartSectorTestCase(RequiresDisk):
    def runTest(self):
        # This test assumes an MSDOS label as given by RequiresDisk
        self.assertEqual(self._disk.max_partition_start_sector(), 4294967295)

class DiskSetFlagTestCase(RequiresDisk):
    def runTest(self):
        # These 2 tests assume an MSDOS label as given by RequiresDisk
        self._disk.set_flag(_ped.DISK_CYLINDER_ALIGNMENT, 1)
        self.assertEqual(self._disk.get_flag(_ped.DISK_CYLINDER_ALIGNMENT), True)
        self._disk.set_flag(_ped.DISK_CYLINDER_ALIGNMENT, 0)
        self.assertEqual(self._disk.get_flag(_ped.DISK_CYLINDER_ALIGNMENT), False)

class DiskGetFlagTestCase(RequiresDisk):
    def runTest(self):
        flag = self._disk.get_flag(_ped.DISK_CYLINDER_ALIGNMENT)
        self.assertIsInstance(flag, bool)

class DiskIsFlagAvailableTestCase(RequiresDisk):
    def runTest(self):
        # We don't know which flags should be available and which shouldn't,
        # but we can at least check that there aren't any tracebacks from
        # trying all of the valid ones.
        for flag in [_ped.DISK_CYLINDER_ALIGNMENT, _ped.DISK_GPT_PMBR_BOOT]:
            self.assertIsInstance(self._disk.is_flag_available(flag), bool)

# However, an invalid flag should definitely not be available.
        self.assertFalse(self._disk.is_flag_available(1000))

@unittest.skip("Unimplemented test case.")
class DiskAddPartitionTestCase(unittest.TestCase):
    # TODO
    def runTest(self):
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskRemovePartitionTestCase(unittest.TestCase):
    # TODO
    def runTest(self):
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskDeletePartitionTestCase(unittest.TestCase):
    # TODO
    def runTest(self):
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskDeleteAllTestCase(unittest.TestCase):
    # TODO
    def runTest(self):
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskSetPartitionGeomTestCase(unittest.TestCase):
    # TODO
    def runTest(self):
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskMaxmimzePartitionTestCase(unittest.TestCase):
    # TODO
    def runTest(self):
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskGetMaxPartitionGeoemtryTestCase(unittest.TestCase):
    # TODO
    def runTest(self):
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskMinimizeExtendedPartitionTestCase(unittest.TestCase):
    # TODO
    def runTest(self):
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskNextPartitionTestCase(unittest.TestCase):
    # TODO
    def runTest(self):
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskGetPartitionTestCase(unittest.TestCase):
    # TODO
    def runTest(self):
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DiskGetPartitionBySectorTestCase(unittest.TestCase):
    # TODO
    def runTest(self):
        self.fail("Unimplemented test case.")

class DiskExtendedPartitionTestCase(RequiresDisk):
    def runTest(self):
        self.assertRaises(_ped.PartitionException,
                          self._disk.extended_partition)

class DiskStrTestCase(RequiresDisk):
    def runTest(self):
        expected = "_ped.Disk instance --\n  dev: %s  type: %s" % \
                   (repr(self._disk.dev), repr(self._disk.type),)
        self.assertEqual(expected, str(self._disk))
07070100115890000081ED0000FFFE0000FFFD0000000157CD697A000019A3000000FC0000001000000000000000000000003C00000000pyparted-1466619794.7a0f829/tests/test_parted_constraint.py#
# Test cases for the methods in the parted.constraint module itself
#
# Copyright (C) 2009-2011  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 _ped
import parted
import unittest
from tests.baseclass import RequiresDevice

# One class per method, multiple tests per class.  For these simple methods,
# that seems like good organization.  More complicated methods may require
# multiple classes and their own test suite.
class ConstraintNewTestCase(RequiresDevice):
    def runTest(self):
        align1 = parted.Alignment(offset=10, grainSize=5)
        align2 = parted.Alignment(offset=10, grainSize=5)
        geom1 = parted.Geometry(device=self.device, start=0, length=50)
        geom2 = parted.Geometry(device=self.device, start=0, length=100)

# Check that not passing enough args to parted.Constraint.__init__
        # is caught.
        self.assertRaises(parted.ConstraintException, parted.Constraint)
        self.assertRaises(parted.ConstraintException, parted.Constraint,
                          startAlign=align1, endAlign=align2)

# And then the correct ways of creating a _ped.Constraint.
        c = parted.Constraint(minGeom=geom1, maxGeom=geom2)
        self.assertIsInstance(c, parted.Constraint)

c = parted.Constraint(minGeom=geom1)
        self.assertIsInstance(c, parted.Constraint)

c = parted.Constraint(maxGeom=geom2)
        self.assertIsInstance(c, parted.Constraint)

c = parted.Constraint(exactGeom=geom1)
        self.assertIsInstance(c, parted.Constraint)

c = parted.Constraint(device=self.device)
        self.assertIsInstance(c, parted.Constraint)

c = parted.Constraint(startAlign=align1, endAlign=align2,
                              startRange=geom1, endRange=geom2,
                              minSize=10, maxSize=100)
        self.assertIsInstance(c, parted.Constraint)

# Use a _ped.Constraint as the initializer
        pc = _ped.Constraint(align1.getPedAlignment(),
                             align2.getPedAlignment(),
                             geom1.getPedGeometry(),
                             geom2.getPedGeometry(),
                             10, 100)
        c = parted.Constraint(PedConstraint=pc)
        self.assertIsInstance(c, parted.Constraint)
        self.assertEqual(c.getPedConstraint(), pc)

class ConstraintGetSetTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        align1 = parted.Alignment(offset=10, grainSize=5)
        align2 = parted.Alignment(offset=10, grainSize=5)
        geom1 = parted.Geometry(device=self.device, start=0, length=50)
        geom2 = parted.Geometry(device=self.device, start=25, length=50)

self.c = parted.Constraint(startAlign=align1, endAlign=align2,
                                   startRange=geom1, endRange=geom2,
                                   minSize=10, maxSize=100)

def runTest(self):
        # Test that properties work
        self.assertEqual(self.c.minSize, 10)
        self.assertEqual(self.c.maxSize, 100)
        self.assertIsInstance(self.c.startAlign, parted.Alignment)
        self.assertIsInstance(self.c.endAlign, parted.Alignment)
        self.assertIsInstance(self.c.startRange, parted.Geometry)
        self.assertIsInstance(self.c.endRange, parted.Geometry)

# Test that setting directly and getting with getattr works.
        self.c.minSize = 15
        self.c.maxSize = 75

self.assertEqual(getattr(self.c, "minSize"), 15)
        self.assertEqual(getattr(self.c, "maxSize"), 75)
        self.assertIsInstance(getattr(self.c, "startAlign"), parted.Alignment)
        self.assertIsInstance(getattr(self.c, "endAlign"), parted.Alignment)
        self.assertIsInstance(getattr(self.c, "startRange"), parted.Geometry)
        self.assertIsInstance(getattr(self.c, "endRange"), parted.Geometry)

# Test that setting with setattr and getting directly works.
        setattr(self.c, "minSize", 10)
        setattr(self.c, "maxSize", 90)

self.assertEqual(self.c.minSize, 10)
        self.assertEqual(self.c.maxSize, 90)

# Test that values have the right type.
        self.assertRaises(TypeError, setattr, self.c, "minSize", "string")

# Test that looking for invalid attributes fails properly.
        self.assertRaises(AttributeError, getattr, self.c, "blah")

self.assertRaises(AttributeError, setattr, self.c, "startRange", 47)
        self.assertRaises(AttributeError, setattr, self.c, "endRange", 47)

@unittest.skip("Unimplemented test case.")
class ConstraintIntersectTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class ConstraintSolveMaxTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class ConstraintSolveNearestTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class ConstraintIsSolutionTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class ConstraintGetPedConstraintTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class ConstraintStrTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")
07070100115891000081ED0000FFFE0000FFFD0000000157CD697A000025FA000000FC0000001000000000000000000000003900000000pyparted-1466619794.7a0f829/tests/test__ped_alignment.py#
# Copyright (C) 2008-2011  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): Chris Lumens <clumens@redhat.com>
#                    David Cantrell <dcantrell@redhat.com>
#

import _ped
import unittest
from tests.baseclass import RequiresDevice, RequiresDeviceAlignment

# One class per method, multiple tests per class.  For these simple methods,
# that seems like good organization.  More complicated methods may require
# multiple classes and their own test suite.
class AlignmentNewTestCase(unittest.TestCase):
    def runTest(self):
        # Check that not passing args to _ped.Alignment.__init__ is caught.
        self.assertRaises(TypeError, _ped.Alignment)

# And then the correct ways of creating a _ped.Alignment.
        self.assertIsInstance(_ped.Alignment(0, 100), _ped.Alignment)
        self.assertIsInstance(_ped.Alignment(offset=0, grain_size=100), _ped.Alignment)

class AlignmentGetSetTestCase(unittest.TestCase):
    def setUp(self):
        self.a = _ped.Alignment(27, 49)

def runTest(self):
        # Test that passing the args to __init__ works.
        self.assertIsInstance(self.a, _ped.Alignment)
        self.assertEqual(self.a.offset, 27)
        self.assertEqual(self.a.grain_size, 49)

# Test that setting directly and getting with getattr works.
        self.a.offset = 10
        self.a.grain_size = 90

self.assertEqual(getattr(self.a, "offset"), 10)
        self.assertEqual(getattr(self.a, "grain_size"), 90)

# Check that setting with setattr and getting directly works.
        setattr(self.a, "offset", 20)
        setattr(self.a, "grain_size", 80)

self.assertEqual(self.a.offset, 20)
        self.assertEqual(self.a.grain_size, 80)

# Check that values have the right type.
        self.assertRaises(TypeError, setattr, self.a, "offset", "string")

# Check that looking for invalid attributes fails properly.
        self.assertRaises(AttributeError, getattr, self.a, "blah")

class AlignmentDuplicateTestCase(unittest.TestCase):
    def setUp(self):
        self.a = _ped.Alignment(27, 49)
        self.dup = self.a.duplicate()

def runTest(self):
        self.assertEqual(self.a.offset, self.dup.offset)
        self.assertEqual(self.a.grain_size, self.dup.grain_size)

class AlignmentIntersectTestCase(unittest.TestCase):
    def setUp(self):
        self.trivialA = _ped.Alignment(47, 0)
        self.trivialB = _ped.Alignment(47, 0)

self.complexA = _ped.Alignment(512, 3)
        self.complexB = _ped.Alignment(256, 4)

def orderAlignments(self, a, b):
        if a.grain_size < b.grain_size:
            tmp = a
            a = b
            b = tmp

return (a, b)

# from libparted/cs/natmath.c
    def extendedEuclid(self, a, b):
        if b == 0:
            gcd = a
            x = 1
            y = 0
            return (gcd, x, y)

(tmp_gcd, tmp_x, tmp_y) = self.extendedEuclid(b, a % b)
        gcd = tmp_gcd
        x = tmp_y
        y = tmp_x - (a / b) * tmp_y
        return (gcd, x, y)

def runTest(self):
        # trivial test first, result should be a duplicate of trivialA
        trivial = self.trivialA.intersect(self.trivialB)
        self.assertEqual(trivial.offset, self.trivialA.offset)
        self.assertEqual(trivial.grain_size, self.trivialA.grain_size)

# complex test second, see libparted/cs/natmath.c for an explanation
        # of the math behind computing the intersection of two alignments
        (verifyA, verifyB) = self.orderAlignments(self.complexA, self.complexB)
        (gcd, x, _y) = self.extendedEuclid(verifyA.grain_size,
                                           verifyB.grain_size)
        delta_on_gcd = (verifyB.offset - verifyA.offset) / gcd
        new_offset = verifyA.offset + x * delta_on_gcd * verifyA.grain_size
        new_grain_size = verifyA.grain_size * verifyB.grain_size / gcd

intersection = self.complexA.intersect(self.complexB)
        self.assertEqual(new_offset, intersection.offset)
        self.assertEqual(new_grain_size, intersection.grain_size)

class AlignmentAlignUpTestCase(RequiresDeviceAlignment):
    def setUp(self):
        RequiresDeviceAlignment.setUp(self)
        self.trivialA = _ped.Alignment(10, 0)
        self.complexA = _ped.Alignment(512, 34)
        self.geometry = _ped.Geometry(self._device, start=0, length=100)
        self.sector = 47

def runTest(self):
        # trivial test case first, grain_size is zero
        expected = self.closestInsideGeometry(self.trivialA, self.geometry,
                                              self.trivialA.offset)
        result = self.trivialA.align_up(self.geometry, self.sector)
        self.assertEqual(result, expected)

# complex test case second, grain_size is not zero
        tmp = self.roundUpTo(self.sector - self.complexA.offset,
                             self.complexA.grain_size) + self.complexA.offset
        expected = self.closestInsideGeometry(self.complexA, self.geometry, tmp)
        result = self.complexA.align_up(self.geometry, self.sector)
        self.assertEqual(result, expected)

class AlignmentAlignDownTestCase(RequiresDeviceAlignment):
    def setUp(self):
        RequiresDeviceAlignment.setUp(self)
        self.trivialA = _ped.Alignment(10, 0)
        self.complexA = _ped.Alignment(512, 34)
        self.geometry = _ped.Geometry(self._device, start=0, length=100)
        self.sector = 47

def runTest(self):
        # trivial test case first, grain_size is zero
        expected = self.closestInsideGeometry(self.trivialA, self.geometry,
                                              self.trivialA.offset)
        result = self.trivialA.align_down(self.geometry, self.sector)
        self.assertEqual(result, expected)

# complex test case second, grain_size is not zero
        tmp = self.roundDownTo(self.sector - self.complexA.offset,
                               self.complexA.grain_size) + self.complexA.offset
        expected = self.closestInsideGeometry(self.complexA, self.geometry, tmp)
        result = self.complexA.align_down(self.geometry, self.sector)
        self.assertEqual(result, expected)

class AlignmentAlignNearestTestCase(RequiresDeviceAlignment):
    def setUp(self):
        RequiresDeviceAlignment.setUp(self)
        self.trivialA = _ped.Alignment(10, 0)
        self.complexA = _ped.Alignment(512, 34)
        self.geometry = _ped.Geometry(self._device, start=0, length=100)
        self.sector = 47

def runTest(self):
        # trivial test case first, grain_size is zero
        tmp = self.closestInsideGeometry(self.trivialA, self.geometry,
                                         self.trivialA.offset)
        expected = self.closest(self.sector, tmp, tmp)
        result = self.trivialA.align_nearest(self.geometry, self.sector)
        self.assertEqual(result, expected)

# complex test case second, grain_size is not zero
        tmpA = self.roundUpTo(self.sector - self.complexA.offset,
                              self.complexA.grain_size) + self.complexA.offset
        tmpA = self.closestInsideGeometry(self.complexA, self.geometry, tmpA)

tmpB = self.roundDownTo(self.sector - self.complexA.offset,
                                self.complexA.grain_size) + self.complexA.offset
        tmpB = self.closestInsideGeometry(self.complexA, self.geometry, tmpB)

expected = self.closest(self.sector, tmpA, tmpB)
        result = self.complexA.align_nearest(self.geometry, self.sector)
        self.assertEqual(result, expected)

class AlignmentIsAlignedTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        self.g = _ped.Geometry(self._device, start=0, length=100)
        self.a = _ped.Alignment(10, 0)

def runTest(self):
        # Test a couple ways of passing bad arguments.
        self.assertRaises(TypeError, self.a.is_aligned, None, 12)
        self.assertRaises(TypeError, self.a.is_aligned, self.g, None)

# Sector must be inside the geometry.
        self.assertFalse(self.a.is_aligned(self.g, 400))

# If grain_size is 0, sector must be the same as offset.
        self.assertTrue(self.a.is_aligned(self.g, 10))
        self.assertFalse(self.a.is_aligned(self.g, 0))
        self.assertFalse(self.a.is_aligned(self.g, 47))

# If grain_size is anything else, there's real math involved.
        self.a.grain_size = 5
        self.assertTrue(self.a.is_aligned(self.g, 20))
        self.assertFalse(self.a.is_aligned(self.g, 23))

class AlignmentStrTestCase(unittest.TestCase):
    def setUp(self):
        self.alignment = _ped.Alignment(10, 0)

def runTest(self):
        expected = "_ped.Alignment instance --\n  offset: 10  grain_size: 0"
        self.assertEqual(str(self.alignment), expected)
07070100115892000081A40000FFFE0000FFFD0000000157CD697A00000939000000FC0000001000000000000000000000002D00000000pyparted-1466619794.7a0f829/tests/README.rstTesting pyparted
================

Pyparted test suite inherits from the standard :class:`unittest.TestCase` class.
To execute it from inside the source directory run the command::

make test

It is also possible to generate test coverage reports using the Python coverage
tool. To do that execute::

make coverage

To execute the Pylint code analysis tool run::

make check

Running Pylint requires Python3 due to usage of pocket-lint.

Test Suite Architecture
------------------------

Pyparted test suite relies on several base classes listed below. All test
cases inherit from them.

- :class:`unittest.TestCase` - the standard unit test class in Python.
  Used only for base classes described below and for test cases which
  don't need access to filesystems or disks;

- :class:`~tests.baseclass.RequiresDeviceNode` - base class for any test case
  that requires a temporary device node;

- :class:`~tests.baseclass.RequiresDevice` - base class for any test case that
  requires a _ped.Device or parted.Device object first;

- :class:`~tests.baseclass.RequiresFileSystem` - base class for any test case
  that requires a filesystem on a device;

- :class:`~tests.baseclass.RequiresDeviceAlignment`- base class for certain
  alignment tests that require a _ped.Device;

- :class:`~tests.baseclass.RequiresLabeledDevice` - base class for any test
  case that requires a labeled device;

- :class:`~tests.baseclass.RequiresDisk` - base class for any test case that
  requires a _ped.Disk or parted.Disk;

- :class:`~tests.baseclass.RequiresMount` - base class for any test case that
  requires a filesystem made and mounted;

- :class:`~tests.baseclass.RequiresPartition` - base class for any test case
  that requires a _ped.Partition;

- :class:`~tests.baseclass.RequiresDiskTypes` - base class for any test case
  that requires a hash table of all _ped.DiskType objects available;

- :class:`~tests.baseclass.BuildList` - base class for any test case that
  requires a list being built via successive calls of some function. The
  function must raise IndexError when there's no more output to add to the
  return list. This class is most useful for all those _get_next methods.
  It is used in combination with other base classes;

Test scenarios are defined inside the `runTest` method of each test class using
multiple assert statements.
07070100115893000081ED0000FFFE0000FFFD0000000157CD697A00003F4A000000FC0000001000000000000000000000003600000000pyparted-1466619794.7a0f829/tests/test__ped_device.py#
# Copyright (C) 2009-2011  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): Chris Lumens <clumens@redhat.com>
#                    David Cantrell <dcantrell@redhat.com>
#

import _ped
import unittest

from tests.baseclass import RequiresDevice

# One class per method, multiple tests per class.  For these simple methods,
# that seems like good organization.  More complicated methods may require
# multiple classes and their own test suite.
class DeviceNewTestCase(unittest.TestCase):
    def runTest(self):
        # You're not allowed to create a new Device object by hand.
        self.assertRaises(TypeError, _ped.Device)

class DeviceGetSetTestCase(RequiresDevice):
    def runTest(self):
        # All attributes should be readable, but none should be writeable.
        for attr in ["model", "path", "type", "sector_size", "phys_sector_size",
                     "length", "open_count", "read_only", "external_mode",
                     "dirty", "boot_dirty", "host", "did"]:
            self.assertNotEqual(getattr(self._device, attr), None)
            self.assertRaises(AttributeError, setattr, self._device, attr, 47)

class DeviceIsBusyTestCase(RequiresDevice):
    def runTest(self):
        # Devices aren't busy until they're mounted.
        self.assertFalse(self._device.is_busy())

# TODO:  need to figure out how to make a loopback device look mounted to
# libparted
#        self.mkfs()
#        self.doMount()
#        self.assertTrue(self._device.is_busy())

class DeviceOpenTestCase(RequiresDevice):
    def runTest(self):
        self.assertTrue(self._device.open())
        self.assertEqual(self._device.open_count, 1)
        self._device.close()

# Not allowed to open a device that's already been opened for external
        # access, so test that now.
        self._device.begin_external_access()
        self.assertRaises(_ped.IOException, self._device.open)
        self._device.end_external_access()
        self.assertTrue(self._device.open())

# You're allowed to open a device multiple times.  It's already been
        # opened once above.  Try to open it again and make sure the count is
        # is right.
        self.assertTrue(self._device.open())
        self.assertEqual(self._device.open_count, 2)
        self._device.close()
        self._device.close()

class DeviceCloseTestCase(RequiresDevice):
    def runTest(self):
        self._device.open()
        self.assertTrue(self._device.close())
        self.assertEqual(self._device.open_count, 0)

# Not allowed to close a device that's already been opened for external
        # access, so test that now.
        self._device.open()
        self._device.begin_external_access()
        self.assertRaises(_ped.IOException, self._device.close)
        self._device.end_external_access()
        self.assertTrue(self._device.close())

# Test opening a device multiple times and then closing it too many.
        self._device.open()
        self._device.open()
        self.assertEqual(self._device.open_count, 2)
        self._device.close()
        self.assertEqual(self._device.open_count, 1)
        self._device.close()
        self.assertEqual(self._device.open_count, 0)
        self.assertRaises(_ped.IOException, self._device.close)

@unittest.skip("Unimplemented test case.")
class DeviceDestroyTestCase(RequiresDevice):
    def runTest(self):
        # XXX: still broken, need to fix destroy function in pydevice.c
        #self.assertEqual(self._device.destroy(), None)
        self.fail("Unimplemented test case.")

class DeviceCacheRemoveTestCase(RequiresDevice):
    def runTest(self):
        self.assertEqual(self._device.cache_remove(), None)

class DeviceBeginExternalAccessTestCase(RequiresDevice):
    def runTest(self):
        # First test external access on a device that's not open.
        self.assertEqual(self._device.external_mode, 0)
        self.assertTrue(self._device.begin_external_access())
        self.assertEqual(self._device.external_mode, 1)
        self.assertEqual(self._device.open_count, 0)

# Now stop external access, open the device, and re-test.
        self._device.end_external_access()
        self._device.open()
        self.assertEqual(self._device.open_count, 1)
        self.assertTrue(self._device.begin_external_access())
        self.assertEqual(self._device.open_count, 1)
        self._device.end_external_access()
        self._device.close()

class DeviceEndExternalAccessTestCase(RequiresDevice):
    def runTest(self):
        # Attempt to end external access on a device that never had it begun.
        self.assertRaises(_ped.IOException, self._device.end_external_access)

# Now test external access on a device that's not open.
        self._device.begin_external_access()
        self.assertEqual(self._device.external_mode, 1)
        self.assertEqual(self._device.open_count, 0)
        self.assertTrue(self._device.end_external_access())
        self.assertEqual(self._device.external_mode, 0)
        self.assertEqual(self._device.open_count, 0)

# Now on a device that's open.
        self._device.open()
        self._device.begin_external_access()
        self.assertEqual(self._device.external_mode, 1)
        self.assertEqual(self._device.open_count, 1)
        self.assertTrue(self._device.end_external_access())
        self.assertEqual(self._device.external_mode, 0)
        self.assertEqual(self._device.open_count, 1)
        self._device.close()

@unittest.skip("Unimplemented test case.")
class DeviceReadTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class DeviceWriteTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

class DeviceSyncTestCase(RequiresDevice):
    def runTest(self):
        # Can't sync a device that's not open or is in external mode.
        self.assertRaises(_ped.IOException, self._device.sync)

self._device.open()
        self._device.begin_external_access()
        self.assertRaises(_ped.IOException, self._device.sync)

# But this call should work.
        self._device.end_external_access()
        self.assertTrue(self._device.sync())
        self._device.close()

class DeviceSyncFastTestCase(RequiresDevice):
    def runTest(self):
        # Can't sync a device that's not open or is in external mode.
        self.assertRaises(_ped.IOException, self._device.sync_fast)

self._device.open()
        self._device.begin_external_access()
        self.assertRaises(_ped.IOException, self._device.sync_fast)

# But this call should work.
        self._device.end_external_access()
        self.assertTrue(self._device.sync_fast())
        self._device.close()

class DeviceCheckTestCase(RequiresDevice):
    def runTest(self):
        self._device.open()
        self.assertEqual(self._device.check(0, 20), 20)
        self._device.close()

class DeviceGetConstraintTestCase(RequiresDevice):
    def runTest(self):
        # XXX: This test case would be a lot more useful testing on real
        # hardware with unusual sector sizes.
        self.assertIsInstance(self._device.get_constraint(), _ped.Constraint)

class DeviceGetMinimalAlignedConstraintTestCase(RequiresDevice):
    def runTest(self):
        # XXX: This test case would be a lot more useful testing on real
        # hardware with unusual sector sizes.
        constraint = self._device.get_minimal_aligned_constraint()
        self.assertIsInstance(constraint, _ped.Constraint)
        self.assertEqual(constraint.start_align.offset, 0)
        self.assertEqual(constraint.start_align.grain_size, 1)
        self.assertEqual(constraint.end_align.offset, 0)
        self.assertEqual(constraint.end_align.grain_size, 1)

class DeviceGetOptimalAlignedConstraintTestCase(RequiresDevice):
    def runTest(self):
        # XXX: This test case would be a lot more useful testing on real
        # hardware with unusual sector sizes.
        constraint = self._device.get_minimal_aligned_constraint()
        self.assertIsInstance(constraint, _ped.Constraint)
        self.assertEqual(constraint.start_align.offset, 0)
        self.assertEqual(constraint.start_align.grain_size, 1)
        self.assertEqual(constraint.end_align.offset, 0)
        self.assertEqual(constraint.end_align.grain_size, 1)

class DeviceGetMinimumAlignmentTestCase(RequiresDevice):
    def runTest(self):
        # XXX: This test case would be a lot more useful testing on real
        # hardware with unusual sector sizes.
        alignment = self._device.get_minimum_alignment()
        self.assertIsInstance(alignment, _ped.Alignment)
        self.assertEqual(alignment.grain_size, 1)
        self.assertEqual(alignment.offset, 0)

class DeviceGetOptimumAlignmentTestCase(RequiresDevice):
    def runTest(self):
        # XXX: This test case would be a lot more useful testing on real
        # hardware with unusual sector sizes.
        alignment = self._device.get_optimum_alignment()
        self.assertIsInstance(alignment, _ped.Alignment)
        self.assertEqual(alignment.grain_size, 2048)
        self.assertEqual(alignment.offset, 0)

class UnitFormatCustomByteTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        pr = "%f" % (47.0 / self._device.unit_get_size(_ped.UNIT_PERCENT),)
        self.pairs = [(_ped.UNIT_SECTOR, '0s',),
                      (_ped.UNIT_BYTE, '47B',),
                      (_ped.UNIT_KILOBYTE, '0.05kB',),
                      (_ped.UNIT_MEGABYTE, '0.00MB',),
                      (_ped.UNIT_GIGABYTE, '0.00GB',),
                      (_ped.UNIT_TERABYTE, '0.00TB',),
                      (_ped.UNIT_COMPACT, '47.0B',),
                      (_ped.UNIT_CYLINDER, '0cyl',),
                      (_ped.UNIT_CHS, '0,0,0',),
                      (_ped.UNIT_PERCENT, pr[:4] + "%",),
                      (_ped.UNIT_KIBIBYTE, '0.05kiB',),
                      (_ped.UNIT_MEBIBYTE, '0.00MiB',),
                      (_ped.UNIT_GIBIBYTE, '0.00GiB',),
                      (_ped.UNIT_TEBIBYTE, '0.00TiB',)]

def runTest(self):
        for (unit, expected,) in self.pairs:
            self.assertEqual(self._device.unit_format_custom_byte(47, unit),
                              expected)

class UnitFormatByteTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        pr = "%f" % (47.0 / self._device.unit_get_size(_ped.UNIT_PERCENT),)
        self._initialDefault = _ped.unit_get_default()
        self.pairs = [(_ped.UNIT_SECTOR, '0s',),
                      (_ped.UNIT_BYTE, '47B',),
                      (_ped.UNIT_KILOBYTE, '0.05kB',),
                      (_ped.UNIT_MEGABYTE, '0.00MB',),
                      (_ped.UNIT_GIGABYTE, '0.00GB',),
                      (_ped.UNIT_TERABYTE, '0.00TB',),
                      (_ped.UNIT_COMPACT, '47.0B',),
                      (_ped.UNIT_CYLINDER, '0cyl',),
                      (_ped.UNIT_CHS, '0,0,0',),
                      (_ped.UNIT_PERCENT, pr[:4] + "%",),
                      (_ped.UNIT_KIBIBYTE, '0.05kiB',),
                      (_ped.UNIT_MEBIBYTE, '0.00MiB',),
                      (_ped.UNIT_GIBIBYTE, '0.00GiB',),
                      (_ped.UNIT_TEBIBYTE, '0.00TiB',)]

def runTest(self):
        for (unit, expected) in self.pairs:
            _ped.unit_set_default(unit)
            result = self._device.unit_format_byte(47)
            self.assertEqual(result, expected)

def tearDown(self):
        _ped.unit_set_default(self._initialDefault)

class UnitFormatCustomTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        sector_size = self._device.sector_size
        size = self._device.unit_get_size(_ped.UNIT_PERCENT)
        pr = "%f" % ((47.0 * sector_size) / size,)
        self.pairs = [(_ped.UNIT_SECTOR, '47s',),
                      (_ped.UNIT_BYTE, '24064B',),
                      (_ped.UNIT_KILOBYTE, '24.1kB',),
                      (_ped.UNIT_MEGABYTE, '0.02MB',),
                      (_ped.UNIT_GIGABYTE, '0.00GB',),
                      (_ped.UNIT_TERABYTE, '0.00TB',),
                      (_ped.UNIT_COMPACT, '24.1kB',),
                      (_ped.UNIT_CYLINDER, '0cyl',),
                      (_ped.UNIT_CHS, '0,1,15',),
                      (_ped.UNIT_PERCENT, pr[:4] + "%",),
                      (_ped.UNIT_KIBIBYTE, '23.5kiB',),
                      (_ped.UNIT_MEBIBYTE, '0.02MiB',),
                      (_ped.UNIT_GIBIBYTE, '0.00GiB',),
                      (_ped.UNIT_TEBIBYTE, '0.00TiB',)]

def runTest(self):
        for (unit, expected) in self.pairs:
            result = self._device.unit_format_custom(47, unit)
            self.assertEqual(result, expected)

class UnitFormatTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        sector_size = self._device.sector_size
        size = self._device.unit_get_size(_ped.UNIT_PERCENT)
        pr = "%f" % ((47.0 * sector_size) / size,)
        self._initialDefault = _ped.unit_get_default()
        self.pairs = [(_ped.UNIT_SECTOR, '47s',),
                      (_ped.UNIT_BYTE, '24064B',),
                      (_ped.UNIT_KILOBYTE, '24.1kB',),
                      (_ped.UNIT_MEGABYTE, '0.02MB',),
                      (_ped.UNIT_GIGABYTE, '0.00GB',),
                      (_ped.UNIT_TERABYTE, '0.00TB',),
                      (_ped.UNIT_COMPACT, '24.1kB',),
                      (_ped.UNIT_CYLINDER, '0cyl',),
                      (_ped.UNIT_CHS, '0,1,15',),
                      (_ped.UNIT_PERCENT, pr[:4] + "%",),
                      (_ped.UNIT_KIBIBYTE, '23.5kiB',),
                      (_ped.UNIT_MEBIBYTE, '0.02MiB',),
                      (_ped.UNIT_GIBIBYTE, '0.00GiB',),
                      (_ped.UNIT_TEBIBYTE, '0.00TiB',)]

def runTest(self):
        for (unit, expected) in self.pairs:
            _ped.unit_set_default(unit)
            result = self._device.unit_format(47)
            self.assertEqual(result, expected)

def tearDown(self):
        _ped.unit_set_default(self._initialDefault)

@unittest.skip("Unimplemented test case.")
class UnitParseTestCase(unittest.TestCase):
    # TODO
    def runTest(self):
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class UnitParseCustomTestCase(unittest.TestCase):
    # TODO
    def runTest(self):
        self.fail("Unimplemented test case.")

class DeviceStrTestCase(RequiresDevice):
    def runTest(self):
        expected = "_ped.Device instance --\n  model: %s  path: %s  type: %d\n  sector_size: %d  phys_sector_size: %d\n  length: %d  open_count: %d  read_only: %d\n  external_mode: %d  dirty: %d  boot_dirty: %d\n  host: %d  did: %d\n  hw_geom: %s  bios_geom: %s" % (self._device.model, self._device.path, self._device.type, self._device.sector_size, self._device.phys_sector_size, self._device.length, self._device.open_count, self._device.read_only, self._device.external_mode, self._device.dirty, self._device.boot_dirty, self._device.host, self._device.did, repr(self._device.hw_geom), repr(self._device.bios_geom),)
        self.assertEqual(str(self._device), expected)
07070100115894000081ED0000FFFE0000FFFD0000000157CD697A00003874000000FC0000001000000000000000000000003800000000pyparted-1466619794.7a0f829/tests/test__ped_geometry.py#
# Copyright (C) 2008-2016  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): Chris Lumens <clumens@redhat.com>
#

import _ped
import six
from tests.baseclass import RequiresDevice

# One class per method, multiple tests per class.  For these simple methods,
# that seems like good organization.  More complicated methods may require
# multiple classes and their own test suite.
class GeometryNewTestCase(RequiresDevice):
    def runTest(self):
        # Check that not passing args to _ped.Geometry.__init__ is caught.
        self.assertRaises(TypeError, _ped.Geometry)

# Or passing in the parameters in the wrong order.
        self.assertRaises(TypeError, _ped.Geometry, 0, self._device, 100)

# And then the correct ways of creating a _ped.Geometry.
        self.assertIsInstance(_ped.Geometry(self._device, 0, 100), _ped.Geometry)
        self.assertIsInstance(_ped.Geometry(self._device, 0, 100, 101), _ped.Geometry)

class GeometryGetSetTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        self.g = _ped.Geometry(self._device, start=0, length=100)

def runTest(self):
        # Test that passing the kwargs to __init__ works.
        self.assertIsInstance(self.g, _ped.Geometry)
        self.assertEqual(self.g.start, 0)
        self.assertEqual(self.g.length, 100)
        self.assertEqual(self.g.end, 99)

# Test that setting directly and getting with getattr works.
        self.g.start = 10
        self.g.length = 90
        self.g.end = 99

self.assertEqual(getattr(self.g, "start"), 10)
        self.assertEqual(getattr(self.g, "length"), 90)
        self.assertEqual(getattr(self.g, "end"), 99)

# Check that setting with setattr and getting directly works.
        setattr(self.g, "start", 20)
        setattr(self.g, "length", 80)
        setattr(self.g, "end", 99)

self.assertEqual(self.g.start, 20)
        self.assertEqual(self.g.length, 80)
        self.assertEqual(self.g.end, 99)

# Check that values have the right type.
        self.assertRaises(TypeError, setattr, self.g, "start", "string")

# Check that looking for invalid attributes fails properly.
        self.assertRaises(AttributeError, getattr, self.g, "blah")

class GeometryDuplicateTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        self.g = _ped.Geometry(self._device, start=0, length=100)
        self.dup = self.g.duplicate()

def runTest(self):
        self.assertEqual(self.g.start, self.dup.start)
        self.assertEqual(self.g.length, self.dup.length)
        self.assertEqual(self.g.end, self.dup.end)

class GeometryIntersectTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        self.g1 = _ped.Geometry(self._device, start=0, length=100)
        self.g2 = _ped.Geometry(self._device, start=0, length=100)
        self.i = None

def runTest(self):
        # g1 and g2 are the same, so their intersection is the same
        self.i = self.g1.intersect(self.g2)
        self.assertEqual(self.i.start, self.g1.start)
        self.assertEqual(self.i.end, self.g1.end)
        self.assertEqual(self.i.length, self.g1.length)

# g2 is the second half of g1, so their intersection is the same as g2.
        self.g2.set_start(50)
        self.i = self.g1.intersect(self.g2)
        self.assertEqual(self.i.start, self.g2.start)
        self.assertEqual(self.i.end, self.g2.end)
        self.assertEqual(self.i.length, self.g2.length)

# g2 only partially overlaps the end of g1, so they have a more
        # interesting intersection.
        self.g1.set_end(75)
        self.i = self.g1.intersect(self.g2)
        self.assertEqual(self.i.start, self.g2.start)
        self.assertEqual(self.i.end, self.g1.end)
        self.assertEqual(self.i.length, 26)

# g1 and g2 do not overlap at all, so they have no intersection.
        self.g1.set(0, 25)
        self.g2.set(50, 100)
        self.assertRaises(ArithmeticError, self.g1.intersect, self.g2)

class GeometrySetTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        self.g = _ped.Geometry(self._device, start=0, length=100)

def runTest(self):
        self.assertEqual(self.g.start, 0)
        self.assertEqual(self.g.length, 100)

# Setting a negative for either value, or a length past the end of
        # the device should fail.
        self.assertRaises(_ped.CreateException, self.g.set, 100, -1000)

class GeometrySetStartTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        self.g = _ped.Geometry(self._device, start=0, length=100)

def runTest(self):
        self.g.set_start(10)
        self.assertEqual(self.g.start, 10)
        self.assertEqual(self.g.length, 90)
        self.assertEqual(self.g.end, 99)

class GeometrySetEndTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        self.g = _ped.Geometry(self._device, start=0, length=100)

def runTest(self):
        self.g.set_end(50)
        self.assertEqual(self.g.start, 0)
        self.assertEqual(self.g.length, 51)
        self.assertEqual(self.g.end, 50)

# Setting a negative end or or before the start should fail.
        self.assertRaises(_ped.CreateException, self.g.set_end, -1)
        self.g.set_start(10)
        self.assertRaises(_ped.CreateException, self.g.set_end, 5)

class GeometryTestOverlapTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        self.g1 = _ped.Geometry(self._device, start=0, length=100)
        self.g2 = _ped.Geometry(self._device, start=50, length=100)

def runTest(self):
        # g2 occupies the second half of g1, so they overlap.
        self.assertTrue(self.g1.test_overlap(self.g2))

# g2 is entirely contained within g1, so they overlap.
        self.g2.set_end(75)
        self.assertTrue(self.g1.test_overlap(self.g2))

# g1 goes from inside g2 to the end, so they overlap.
        self.g1.set_start(60)
        self.assertTrue(self.g1.test_overlap(self.g2))

# g2 exists entirely before g1, so they do not overlap.
        self.g2.set(10, 10)
        self.assertFalse(self.g1.test_overlap(self.g2))

class GeometryTestInsideTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        self.g1 = _ped.Geometry(self._device, start=0, length=100)
        self.g2 = _ped.Geometry(self._device, start=0, length=100)

def runTest(self):
        # g1 and g2 are the same, so they exist inside each other.
        self.assertTrue(self.g1.test_inside(self.g2))
        self.assertTrue(self.g2.test_inside(self.g1))

# g2 is entirely contained within g1, so it's inside.
        self.g2.set_end(75)
        self.assertTrue(self.g1.test_inside(self.g2))
        self.assertFalse(self.g2.test_inside(self.g1))

# g1 goes from inside g2 to the end, so it's not inside.
        self.g1.set_start(60)
        self.assertFalse(self.g1.test_inside(self.g2))
        self.assertFalse(self.g2.test_inside(self.g1))

# g2 exists entirely before g1, so it's not inside.
        self.g2.set(10, 10)
        self.assertFalse(self.g1.test_inside(self.g2))
        self.assertFalse(self.g2.test_inside(self.g1))

class GeometryTestEqualTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        self.g1 = _ped.Geometry(self._device, start=0, length=100)
        self.g2 = _ped.Geometry(self._device, start=0, length=100)

def runTest(self):
        # g1 and g2 have the same start and end.
        self.assertTrue(self.g1.test_equal(self.g2))

# g1 and g2 have the same end, but different starts.
        self.g2.set_start(5)
        self.assertFalse(self.g1.test_equal(self.g2))

# g1 and g2 have the same start, but different ends.
        self.g2.set_start(5)
        self.g2.set_end(50)
        self.assertFalse(self.g1.test_equal(self.g2))

class GeometryTestSectorInsideTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        self.g = _ped.Geometry(self._device, start=10, length=100)

def runTest(self):
        # First check the boundary conditions.
        self.assertTrue(self.g.test_sector_inside(10))
        self.assertTrue(self.g.test_sector_inside(109))
        self.assertFalse(self.g.test_sector_inside(110))

# Then some sectors that are obviously out.
        self.assertFalse(self.g.test_sector_inside(0))
        self.assertFalse(self.g.test_sector_inside(1000))
        self.assertFalse(self.g.test_sector_inside(-1))

class GeometryReadTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        self.g = _ped.Geometry(self._device, start=10, length=100)

def runTest(self):
        # First try to read from a device that isn't open yet.
        self.assertRaises(_ped.IOException, self.g.read, 0, 10)

# Our initial device is just full of zeros, so this should read a
        # whole lot of nothing.
        self._device.open()
        self.assertEqual(self.g.read(0, 10), "")

# Test bad parameter passing.
        self.assertRaises(_ped.IOException, self.g.read, -10, 10)
        self.assertRaises(_ped.IOException, self.g.read, 0, -10)
        self.assertRaises(TypeError, self.g.read, None, None)

# Can't read past the end of the geometry.
        self.assertRaises(_ped.IOException, self.g.read, 200, 1)
        self.assertRaises(_ped.IOException, self.g.read, 0, 200)

# Now try writing something to the device, then reading to see if
        # we get the same thing back.
        self.g.write("1111111111", 0, 1)
        self.assertEqual(self.g.read(0, 10), "1111111111")

# Write five bytes from the string to the geometry, so there's only
        # one byte present.  So, only one "2" should be there when we read.
        self.g.write("2", 20, 5)
        self.assertEqual(self.g.read(20, 5), "2")
        self.assertEqual(self.g.read(20, 1), "2")

self._device.close()

class GeometrySyncTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        self.g = _ped.Geometry(self._device, start=0, length=100)

def runTest(self):
        self._device.open()

# XXX: I don't know of a better way to test this method.
        self.g.write("1111111111", 0, 1)
        self.assertEqual(self.g.sync(), 1)

self._device.close()

class GeometrySyncFastTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        self.g = _ped.Geometry(self._device, start=0, length=100)

def runTest(self):
        self._device.open()

# XXX: I don't know of a better way to test this method.
        self.g.write("1111111111", 0, 1)
        self.assertEqual(self.g.sync_fast(), 1)

self._device.close()

class GeometryWriteTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        self.g = _ped.Geometry(self._device, start=10, length=100)

def runTest(self):
        # First try to write to a device that isn't open yet.
        self.assertRaises(_ped.IOException, self.g.write, "X", 0, 10)

# Now try a real write and make sure we (1) don't get an error code
        # and (2) the data actually ends up on the device.
        self._device.open()
        self.assertNotEqual(self.g.write("X", 0, 10), 0)
        self.assertEqual(self.g.read(0, 10), "X")
        self.assertNotEqual(self.g.write("XXXXXXXXXX", 0, 10), 0)
        self.assertEqual(self.g.read(0, 10), "XXXXXXXXXX")

# Test bad parameter passing.
        self.assertRaises(_ped.IOException, self.g.write, "X", -10, 10)
        self.assertRaises(_ped.IOException, self.g.write, "X", 0, -10)
        self.assertRaises(TypeError, self.g.write, None, None, None)

# Can't write past the end of the geometry.
        self.assertRaises(_ped.IOException, self.g.write, "X", 200, 1)
        self.assertRaises(_ped.IOException, self.g.write, "X", 0, 200)

self._device.close()

class GeometryCheckTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        self.g = _ped.Geometry(self._device, start=10, length=100)

def runTest(self):
        # trivial test case first
        self.assertRaises(_ped.IOException, self.g.check, 0, 0, 0)

self._device.open()

self.assertEqual(self.g.check(0, 0, 10), 0)
        self.assertEqual(self.g.check(0, 0, 50), 0)

self._device.close()

class GeometryMapTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        self.g1 = _ped.Geometry(self._device, start=10, length=100)
        self.g2 = _ped.Geometry(self._device, start=10, length=90)

def runTest(self):
        # write a word to the device starting at sector 25
        self._device.open()
        self.g1.write("UNITTEST", 25, 8)

val1 = self.g2.read(self.g2.map(self.g1, 25), 8)
        val2 = self.g1.read(25, 8)
        self.assertEqual(val1, val2)

self._device.close()

class GeometryStrTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        self.g = _ped.Geometry(self._device, start=10, length=100)

def runTest(self):
        lines = str(self.g).split('\n')
        self.assertEqual(lines[0], '_ped.Geometry instance --')
        self.assertEqual(lines[1], '  start: 10  end: 109  length: 100')
        six.assertRegex(self, lines[2], '^  device: <_ped.Device object at .*')
07070100115895000081ED0000FFFE0000FFFD0000000157CD697A0000263D000000FC0000001000000000000000000000003900000000pyparted-1466619794.7a0f829/tests/test__ped_partition.py#
# Copyright (C) 2009-2014  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): Chris Lumens <clumens@redhat.com>
#

import os
import _ped
import tempfile

from tests.baseclass import RequiresDisk, RequiresPartition

# One class per method, multiple tests per class.  For these simple methods,
# that seems like good organization.  More complicated methods may require
# multiple classes and their own test suite.
class PartitionNewTestCase(RequiresDisk):
    def runTest(self):
        # Check that not passing args to _ped.Partition.__init__ is caught.
        self.assertRaises(TypeError, _ped.Partition)

# Or passing the arguments in the wrong order.
        self.assertRaises(TypeError, _ped.Partition, _ped.file_system_type_get("ext2"),
                                                     _ped.PARTITION_NORMAL, self._disk, 0, 100)

part = _ped.Partition(self._disk, _ped.PARTITION_NORMAL, 0, 100,
                              _ped.file_system_type_get("ext2"))
        self.assertIsInstance(part, _ped.Partition)

# You don't need to pass a filesystem type at all, since this partition
        # might be FREESPACE or METADATA.
        part = _ped.Partition(self._disk, _ped.PARTITION_NORMAL, 0, 100)
        self.assertIsInstance(part, _ped.Partition)

class PartitionGetSetTestCase(RequiresPartition):
    def runTest(self):
        # Test that passing the kwargs to __init__ works.
        self.assertEqual(self._part.disk, self._disk)
        self.assertIsInstance(self._part.geom, _ped.Geometry)
        self.assertEqual(self._part.type, _ped.PARTITION_NORMAL)
        self.assertEqual(self._part.fs_type.name, "ext2")

# Test that setting the RW attributes directly works.
        self._part.type = _ped.PARTITION_EXTENDED
        self.assertEqual(getattr(self._part, "type"), _ped.PARTITION_EXTENDED)

# Test that setting the RO attributes directly doesn't work.
        exn = (AttributeError, TypeError)
        self.assertRaises(exn, setattr, self._part, "num", 1)
        self.assertRaises(exn, setattr, self._part, "fs_type",
            _ped.file_system_type_get("fat32"))
        self.assertRaises(exn, setattr, self._part, "geom",
                                     _ped.Geometry(self._device, 10, 20))
        self.assertRaises(exn, setattr, self._part, "disk", self._disk)

# Check that values have the right type.
        self.assertRaises(exn, setattr, self._part, "type", "blah")

# Check that looking for invalid attributes fails properly.
        self.assertRaises(AttributeError, getattr, self._part, "blah")

class PartitionDestroyTestCase(RequiresPartition):
    def runTest(self):
        self.assertEqual(self._part.destroy(), None)

class PartitionIsActiveTestCase(RequiresPartition):
    def runTest(self):
        # A partition is active as long as it's not METADATA or FREE.
        for ty in [_ped.PARTITION_NORMAL, _ped.PARTITION_LOGICAL,
                   _ped.PARTITION_EXTENDED, _ped.PARTITION_PROTECTED]:
            self._part.type = ty
            self.assertTrue(self._part.is_active())

for ty in [_ped.PARTITION_FREESPACE, _ped.PARTITION_METADATA]:
            # Can't have a partition of these two types that also has a
            # filesystem type associated with it.  libparted doesn't like
            # that combination.
            self._part = _ped.Partition(self._disk, ty, 0, 100)
            self.assertFalse(self._part.is_active())

class PartitionSetFlagTestCase(RequiresPartition):
    def runTest(self):
        self.assertTrue(self._part.set_flag(_ped.PARTITION_BOOT, 1))
        # try setting unavailable flag
        with self.assertRaises(_ped.PartedException):
            self._part.set_flag(1000, 1)

class PartitionGetFlagTestCase(RequiresPartition):
    def runTest(self):
        self.assertTrue(self._part.set_flag(_ped.PARTITION_BOOT, 1))
        self.assertTrue(self._part.get_flag(_ped.PARTITION_BOOT))

# try getting unavailable flag - doesn't raise an exception
#        with self.assertRaises(_ped.PartedException):
#            self._part.get_flag(1000)

class PartitionIsFlagAvailableTestCase(RequiresPartition):
    def runTest(self):
        # We don't know which flags should be available and which shouldn't,
        # but we can at least check that there aren't any tracebacks from
        # trying all of the valid ones.
        for f in ['PARTITION_BOOT', 'PARTITION_ROOT', 'PARTITION_SWAP',
                  'PARTITION_HIDDEN', 'PARTITION_RAID', 'PARTITION_LVM',
                  'PARTITION_LBA', 'PARTITION_HPSERVICE',
                  'PARTITION_PALO', 'PARTITION_PREP',
                  'PARTITION_MSFT_RESERVED',
                  'PARTITION_APPLE_TV_RECOVERY',
                  'PARTITION_BIOS_GRUB', 'PARTITION_DIAG',
                  'PARTITION_MSFT_DATA', 'PARTITION_IRST',
                  'PARTITION_ESP', 'PARTITION_NONFS']:
            if not hasattr(_ped, f):
                continue
            attr = getattr(_ped, f)
            self.assertIsInstance(self._part.is_flag_available(attr), bool)

# However, an invalid flag should definitely not be available.
        self.assertFalse(self._part.is_flag_available(1000))

# Partitions that are inactive should not have any available flags.
        self._part = _ped.Partition(self._disk, _ped.PARTITION_FREESPACE, 0, 100)
        self.assertRaises(_ped.PartitionException, self._part.is_flag_available,
                          _ped.PARTITION_BOOT)

class PartitionSetSystemTestCase(RequiresPartition):
    def runTest(self):
        self.assertTrue(self._part.set_system(_ped.file_system_type_get("fat32")))

self.assertRaises(TypeError, self._part.set_system, 47)

# Partitions that are inactive cannot have the system type set.
        self._part = _ped.Partition(self._disk, _ped.PARTITION_FREESPACE, 0, 100)
        self.assertRaises(_ped.PartitionException, self._part.set_system,
                          _ped.file_system_type_get("ext2"))

class PartitionSetNameTestCase(RequiresPartition):
    def runTest(self):
        # The DOS disklabel does not support naming.
        self.assertRaises(_ped.PartitionException, self._part.set_name, "blah")

# These should work.
        self._disk = _ped.disk_new_fresh(self._device, _ped.disk_type_get("mac"))
        self._part = _ped.Partition(self._disk, _ped.PARTITION_NORMAL, 0, 100,
                                    _ped.file_system_type_get("fat32"))
        self.assertTrue(self._part.set_name("blah"))
        self.assertEqual(self._part.get_name(), "blah")

# Partitions that are inactive won't work.
        self._part = _ped.Partition(self._disk, _ped.PARTITION_FREESPACE, 0, 100)
        self.assertRaises(_ped.PartitionException, self._part.get_name)

class PartitionGetNameTestCase(RequiresPartition):
    def runTest(self):
        # The DOS disklabel does not support naming.
        self.assertRaises(_ped.PartitionException, self._part.get_name)

# Partitions that are inactive won't work either.
        self._part = _ped.Partition(self._disk, _ped.PARTITION_FREESPACE, 0, 100)
        self.assertRaises(_ped.PartitionException, self._part.get_name)

# Mac disk labels do support naming, but there still has to be a name.
        self._disk = _ped.disk_new_fresh(self._device, _ped.disk_type_get("mac"))
        self._part = _ped.Partition(self._disk, _ped.PARTITION_NORMAL, 0, 100,
                                    _ped.file_system_type_get("fat32"))
        self.assertEqual(self._part.get_name(), "untitled")

# Finally, Mac disk labels with a name will work.
        self._part.set_name("blah")
        self.assertEqual(self._part.get_name(), "blah")

class PartitionIsBusyTestCase(RequiresPartition):
    def setUp(self):
        self.addCleanup(self.removeMountpoint)
        RequiresPartition.setUp(self)
        self.mountpoint = None

def doMount(self):
        self.mountpoint = tempfile.mkdtemp()
        os.system("mount -o loop %s %s" % (self.path, self.mountpoint))

def mkfs(self):
        os.system("mkfs.ext2 -F -q %s" % self.path)

def removeMountpoint(self):
        if self.mountpoint:
            os.system("umount %s" % self.mountpoint)
            os.rmdir(self.mountpoint)

def runTest(self):
        # partitions aren't busy until they're mounted.
        self.assertFalse(self._part.is_busy())

# TODO:  need to figure out how to make a loopback device look mounted to
# libparted
#        self.mkfs()
#        self.doMount()
#        self.assertTrue(self._part.is_busy())

class PartitionGetPathTestCase(RequiresPartition):
    def runTest(self):
        self.assertNotEqual(self._part.get_path(), "")

class PartitionStrTestCase(RequiresPartition):
    def runTest(self):
        self.assertTrue(str(self._part).startswith("_ped.Partition instance"))
07070100115896000081ED0000FFFE0000FFFD0000000157CD697A000007EB000000FC0000001000000000000000000000003C00000000pyparted-1466619794.7a0f829/tests/test_parted_filesystem.py#
# Test cases for the methods in the parted.filesystem module itself
#
# Copyright (C) 2009-2011  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 unittest

# One class per method, multiple tests per class.  For these simple methods,
# that seems like good organization.  More complicated methods may require
# multiple classes and their own test suite.
@unittest.skip("Unimplemented test case.")
class FileSystemNewTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class FileSystemGetSetTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class FileSystemGetPedFileSystemTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class FileSystemStrTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")
07070100115897000081ED0000FFFE0000FFFD0000000157CD697A000009F6000000FC0000001000000000000000000000003B00000000pyparted-1466619794.7a0f829/tests/test__ped_chsgeometry.py#
# Copyright (C) 2008-2011  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): Chris Lumens <clumens@redhat.com>
#                    David Cantrell <dcantrell@redhat.com>
#

import _ped
import unittest

from tests.baseclass import RequiresDevice

# One class per method, multiple tests per class.  For these simple methods,
# that seems like good organization.  More complicated methods may require
# multiple classes and their own test suite.
class CHSGeometryNewTestCase(unittest.TestCase):
    def runTest(self):
        # You're not allowed to create a new CHSGeometry object by hand.
        self.assertRaises(TypeError, _ped.CHSGeometry)

class CHSGeometryGetSetTestCase(RequiresDevice):
    def runTest(self):
        # A device has a CHSGeometry, so we can use that to attempt accessing
        # parameters.
        chs = self._device.hw_geom
        self.assertIsInstance(chs, _ped.CHSGeometry)

# All attributes are read-only.
        self.assertRaises(AttributeError, setattr, chs, "cylinders", 47)
        self.assertRaises(AttributeError, setattr, chs, "heads", 47)
        self.assertRaises(AttributeError, setattr, chs, "sectors", 47)

self.assertIsInstance(chs.cylinders, int)
        self.assertIsInstance(chs.heads, int)
        self.assertIsInstance(chs.sectors, int)

class CHSGeometryStrTestCase(RequiresDevice):
    def runTest(self):
        expected = "_ped.CHSGeometry instance --\n  cylinders: %d  heads: %d  sectors: %d" % (self._device.hw_geom.cylinders, self._device.hw_geom.heads, self._device.hw_geom.sectors,)
        result = str(self._device.hw_geom)
        self.assertEqual(result, expected)
07070100115898000081ED0000FFFE0000FFFD0000000157CD697A000049D7000000FC0000001000000000000000000000003300000000pyparted-1466619794.7a0f829/tests/test__ped_ped.py#
# Test cases for the methods in the _ped module itself - just the pyunit
# and pynatmath files.
#
# Copyright (C) 2008-2014  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): Chris Lumens <clumens@redhat.com>
#                    David Cantrell <dcantrell@redhat.com>
#

import os
import _ped
import unittest

from tests.baseclass import BuildList, RequiresDevice, RequiresFileSystem

# One class per method, multiple tests per class.  For these simple methods,
# that seems like good organization.  More complicated methods may require
# multiple classes and their own test suite.
class PartitionFlagGetNameTestCase(unittest.TestCase):
    def runTest(self):
        for f in ['PARTITION_BOOT', 'PARTITION_ROOT', 'PARTITION_SWAP',
                  'PARTITION_HIDDEN', 'PARTITION_RAID', 'PARTITION_LVM',
                  'PARTITION_LBA', 'PARTITION_HPSERVICE',
                  'PARTITION_PALO', 'PARTITION_PREP',
                  'PARTITION_MSFT_RESERVED',
                  'PARTITION_APPLE_TV_RECOVERY',
                  'PARTITION_BIOS_GRUB', 'PARTITION_DIAG',
                  'PARTITION_MSFT_DATA', 'PARTITION_IRST',
                  'PARTITION_ESP', 'PARTITION_NONFS']:
            if not hasattr(_ped, f):
                continue
            attr = getattr(_ped, f)
            self.assertNotEqual(_ped.partition_flag_get_name(attr), "", "Could not get name for flag _ped.%s" % f)

self.assertRaises(ValueError, _ped.partition_flag_get_name, -1)
        self.assertRaises(ValueError, _ped.partition_flag_get_name, 1000)

class PartitionFlagGetByNameTestCase(unittest.TestCase):
    def runTest(self):
        for f in ["boot", "root", "swap", "hidden", "raid", "lvm", "lba",
                  "hp-service", "palo", "prep", "msftres", "bios_grub",
                  "msftdata", "irst", "esp", "nonfs"]:
            self.assertNotEqual(_ped.partition_flag_get_by_name(f), "", "Could not get flag %s" % f)

self.assertEqual(_ped.partition_flag_get_by_name("nosuchflag"), 0)

class PartitionFlagNextTestCase(unittest.TestCase):
    def runTest(self):
        # We should get TypeError when the parameter is invalid
        self.assertRaises(TypeError, _ped.partition_flag_next)
        self.assertRaises(TypeError, _ped.partition_flag_next, 'blah')

# First flag is 0, keep getting flags until we loop back around
        # to zero.  Make sure each flag we get is an integer.
        flag = _ped.partition_flag_next(0)
        self.assertEqual(type(flag).__name__, 'int')

while True:
            flag = _ped.partition_flag_next(flag)
            if not flag:
                break
            self.assertEqual(type(flag).__name__, 'int')

class DiskFlagGetNameTestCase(unittest.TestCase):
    def runTest(self):
        for f in [_ped.DISK_CYLINDER_ALIGNMENT]:
            self.assertNotEqual(_ped.disk_flag_get_name(f), "", "Could not get name for flag %s" % f)

self.assertRaises(ValueError, _ped.disk_flag_get_name, -1)
        self.assertRaises(ValueError, _ped.disk_flag_get_name, 1000)

class DiskFlagGetByNameTestCase(unittest.TestCase):
    def runTest(self):
        for f in ["cylinder_alignment"]:
            self.assertNotEqual(_ped.disk_flag_get_by_name(f), 0, "Could not get flag %s" % f)

self.assertEqual(_ped.disk_flag_get_by_name("nosuchflag"), 0)

class DiskFlagNextTestCase(unittest.TestCase):
    def runTest(self):
        # We should get TypeError when the parameter is invalid
        self.assertRaises(TypeError, _ped.disk_flag_next)
        self.assertRaises(TypeError, _ped.disk_flag_next, 'blah')

# First flag is 0, keep getting flags until we loop back around
        # to zero.  Make sure each flag we get is an integer.
        flag = _ped.disk_flag_next(0)
        self.assertEqual(type(flag).__name__, 'int')

while True:
            flag = _ped.disk_flag_next(flag)
            if not flag:
                break
            self.assertEqual(type(flag).__name__, 'int')

class ConstraintNewFromMinMaxTestCase(RequiresDevice):
    def runTest(self):
        self.assertRaises(TypeError, _ped.constraint_new_from_min_max, None)

# min is required to be within max, so test various combinations of
        # that not being the case.
        self.assertRaises(_ped.CreateException, _ped.constraint_new_from_min_max,
                          _ped.Geometry(self._device, 0, 10),
                          _ped.Geometry(self._device, 15, 25))
        self.assertRaises(_ped.CreateException, _ped.constraint_new_from_min_max,
                          _ped.Geometry(self._device, 10, 20),
                          _ped.Geometry(self._device, 15, 25))

# Now test a correct call.
        minimum = _ped.Geometry(self._device, 10, 20)
        maximum = _ped.Geometry(self._device, 0, 30)
        constraint = _ped.constraint_new_from_min_max(minimum, maximum)

self.assertIsInstance(constraint, _ped.Constraint)
        self.assertTrue(constraint.is_solution(_ped.Geometry(self._device, 10, 20)))
        self.assertFalse(constraint.is_solution(_ped.Geometry(self._device, 11, 20)))
        self.assertTrue(constraint.is_solution(_ped.Geometry(self._device, 5, 25)))
        self.assertTrue(constraint.is_solution(_ped.Geometry(self._device, 0, 30)))
        self.assertFalse(constraint.is_solution(_ped.Geometry(self._device, 0, 35)))

class ConstraintNewFromMinTestCase(RequiresDevice):
    def runTest(self):
        self.assertRaises(TypeError, _ped.constraint_new_from_min, None)

minimum = _ped.Geometry(self._device, 10, 20)
        constraint = _ped.constraint_new_from_min(minimum)

self.assertIsInstance(constraint, _ped.Constraint)
        self.assertTrue(constraint.is_solution(_ped.Geometry(self._device, 10, 20)))
        self.assertTrue(constraint.is_solution(_ped.Geometry(self._device, 5, 25)))
        self.assertFalse(constraint.is_solution(_ped.Geometry(self._device, 11, 19)))
        self.assertFalse(constraint.is_solution(_ped.Geometry(self._device, 15, 25)))

class ConstraintNewFromMaxTestCase(RequiresDevice):
    def runTest(self):
        self.assertRaises(TypeError, _ped.constraint_new_from_max, None)

maximum = _ped.Geometry(self._device, 10, 20)
        constraint = _ped.constraint_new_from_max(maximum)

self.assertIsInstance(constraint, _ped.Constraint)
        self.assertTrue(constraint.is_solution(_ped.Geometry(self._device, 10, 20)))
        self.assertFalse(constraint.is_solution(_ped.Geometry(self._device, 5, 25)))
        self.assertTrue(constraint.is_solution(_ped.Geometry(self._device, 11, 19)))
        self.assertFalse(constraint.is_solution(_ped.Geometry(self._device, 15, 25)))

class ConstraintAnyTestCase(RequiresDevice):
    def runTest(self):
        self.assertRaises(TypeError, _ped.constraint_any, None)

constraint = _ped.constraint_any(self._device)
        self.assertIsInstance(constraint, _ped.Constraint)

for testGeom in [_ped.Geometry(self._device, 0, 5),
                         _ped.Geometry(self._device, 10, 25),
                         _ped.Geometry(self._device, 0, 100)]:
            self.assertTrue(constraint.is_solution(testGeom))

class ConstraintExactTestCase(RequiresDevice):
    def runTest(self):
        geom = _ped.Geometry(self._device, 0, 100)

self.assertRaises(TypeError, _ped.constraint_exact, None)

constraint = _ped.constraint_exact(geom)
        self.assertIsInstance(constraint, _ped.Constraint)

for testGeom in [_ped.Geometry(self._device, 1, 100),
                         _ped.Geometry(self._device, 0, 99),
                         _ped.Geometry(self._device, 10, 20),
                         _ped.Geometry(self._device, 50, 101)]:
            self.assertFalse(constraint.is_solution(testGeom))

self.assertTrue(constraint.is_solution(_ped.Geometry(self._device, 0, 100)))

class DeviceGetTestCase(RequiresDevice):
    def runTest(self):
        # Try getting the device we just made.
        self.assertIsInstance(_ped.device_get(self.path), _ped.Device)

# Try getting a device that doesn't exist.
        self.assertRaises(_ped.IOException, _ped.device_get, "/blah/whatever")
        self.assertRaises(_ped.IOException, _ped.device_get, "")
        self.assertRaises(_ped.DeviceException, _ped.device_get, None)

@unittest.skipUnless(os.geteuid() == 0, 'Requires root')
class DeviceGetNextTestCase(unittest.TestCase, BuildList):
    def runTest(self):
        # Make sure there are some devices in the system first and then
        # make a list out of them.  That's easier to work with.
        _ped.device_probe_all()
        lst = self.getDeviceList(_ped.device_get_next)

# Now the test cases.
        self.assertGreater(len(lst), 0)
        self.assertRaises(TypeError, _ped.device_get_next, None)

for ele in lst:
            self.assertIsInstance(ele, _ped.Device)

self.assertRaises(IndexError, _ped.device_get_next, lst[-1])

class DeviceProbeAllTestCase(RequiresDevice, BuildList):
    def runTest(self):
        # Since we inherit from RequiresDevice, we can test that the temp
        # device we created is in the results list.  I can't really think of
        # any other way to test this method except by getting a list of devices
        # via some other mechanism and comparing that to the device_probe_all
        # results.
        _ped.device_probe_all()
        lst = self.getDeviceList(_ped.device_get_next)

self.assertGreater(len(lst), 0)
        self.assertGreater(
            len([e for e in lst if e.path.startswith("/tmp/temp-device-")]), 0)

class DeviceFreeAllTestCase(RequiresDevice):
    def runTest(self):
        _ped.device_probe_all()
        self.assertEqual(_ped.device_free_all(), None)

class DiskTypeGetTestCase(unittest.TestCase):
    def runTest(self):
        for d in ["aix", "amiga", "bsd", "dvh", "gpt", "loop", "mac", "msdos",
                  "pc98","sun"]:
            t = _ped.disk_type_get(d)
            self.assertIsInstance(t, _ped.DiskType)
            self.assertEqual(t.name, d)

self.assertRaises(_ped.UnknownTypeException, _ped.disk_type_get, "nosuch")

class DiskTypeGetNextTestCase(unittest.TestCase, BuildList):
    def runTest(self):
        lst = self.getDeviceList(_ped.disk_type_get_next)
        self.assertGreater(len(lst), 0)
        self.assertRaises(TypeError, _ped.device_get_next, None)

for ele in lst:
            self.assertIsInstance(ele, _ped.DiskType)

self.assertRaises(IndexError, _ped.disk_type_get_next, lst[-1])

class FileSystemProbeTestCase(RequiresFileSystem):
    def runTest(self):
        ty = _ped.file_system_probe(self._geometry)

for name in self._fileSystemType.keys():
            if name == 'ext2':
                self.assertEqual(ty.name, name)
            else:
                self.assertNotEqual(ty.name, name)

class FileSystemProbeSpecificTestCase(RequiresFileSystem):
    def runTest(self):
        for (name, ty,) in self._fileSystemType.items():
            if name == 'ext2':
                result = _ped.file_system_probe_specific(ty, self._geometry)

# XXX: this should work
                # we're getting
                #     ValueError: object comparing to must be a _ped.Geometry
                # at runtime.  works fine in pdb.
                #self.assertEqual(result, self._geometry)

self.assertIsInstance(result, _ped.Geometry)
                self.assertEqual(result.start, self._geometry.start)
                self.assertLessEqual(result.end, self._geometry.end)
                self.assertLessEqual(result.length, self._geometry.length)
                self.assertEqual(result.dev, self._device)
            else:
                result = _ped.file_system_probe_specific(ty, self._geometry)
                self.assertEqual(result, None)

class FileSystemTypeGetTestCase(unittest.TestCase):
    def runTest(self):
        for f in ["affs0", "amufs", "apfs1", "asfs", "btrfs", "ext2", "ext3", "ext4", "fat16",
                  "fat32", "hfs", "hfs+", "hfsx", "hp-ufs", "jfs", "linux-swap",
                  "ntfs", "reiserfs", "sun-ufs", "xfs"]:
            # may be missing some filesystem types depending on the parted
            # build on the test system
            try:
                t = _ped.file_system_type_get(f)
                self.assertIsInstance(t, _ped.FileSystemType, "Could not get fs type %s" % t)
            except _ped.UnknownTypeException:
                pass

self.assertRaises(_ped.UnknownTypeException, _ped.file_system_type_get, "nosuch")

class FileSystemTypeGetNextTestCase(unittest.TestCase, BuildList):
    def runTest(self):
        lst = self.getDeviceList(_ped.file_system_type_get_next)
        self.assertGreater(len(lst), 0)
        self.assertRaises(TypeError, _ped.file_system_type_get_next, None)

for ele in lst:
            self.assertIsInstance(ele, _ped.FileSystemType)

self.assertRaises(IndexError, _ped.file_system_type_get_next, lst[-1])

class PartitionTypeGetNameTestCase(unittest.TestCase):
    def runTest(self):
        for t in [_ped.PARTITION_METADATA, _ped.PARTITION_FREESPACE,
                  _ped.PARTITION_EXTENDED, _ped.PARTITION_LOGICAL]:
            self.assertNotEqual(_ped.partition_type_get_name(t), "", "Could not get name for flag %s" % t)

class UnitSetDefaultTestCase(unittest.TestCase):
    def setUp(self):
        self._initialDefault = _ped.unit_get_default()

def tearDown(self):
        _ped.unit_set_default(self._initialDefault)

def runTest(self):
        for v in [_ped.UNIT_BYTE, _ped.UNIT_CHS, _ped.UNIT_COMPACT,
                  _ped.UNIT_CYLINDER, _ped.UNIT_GIBIBYTE, _ped.UNIT_GIGABYTE,
                  _ped.UNIT_KIBIBYTE, _ped.UNIT_KILOBYTE, _ped.UNIT_MEBIBYTE,
                  _ped.UNIT_MEGABYTE, _ped.UNIT_PERCENT, _ped.UNIT_SECTOR,
                  _ped.UNIT_TEBIBYTE, _ped.UNIT_TERABYTE]:
            _ped.unit_set_default(v)
            self.assertEqual(_ped.unit_get_default(), v, "Could not set unit default to %s" % v)

self.assertRaises(ValueError, _ped.unit_set_default, -1)
        self.assertRaises(ValueError, _ped.unit_set_default, 1000)

class UnitGetDefaultTestCase(unittest.TestCase):
    def runTest(self):
        self.assertGreaterEqual(_ped.unit_get_default(), 0)

class UnitGetSizeTestCase(RequiresDevice):
    def runTest(self):
        self.assertEqual(self._device.unit_get_size(_ped.UNIT_SECTOR), 512)
        self.assertEqual(self._device.unit_get_size(_ped.UNIT_BYTE), 1)
        self.assertEqual(self._device.unit_get_size(_ped.UNIT_KILOBYTE), 1000)
        self.assertEqual(self._device.unit_get_size(_ped.UNIT_MEGABYTE), 1000000)
        self.assertEqual(self._device.unit_get_size(_ped.UNIT_GIGABYTE), 1000000000)
        self.assertEqual(self._device.unit_get_size(_ped.UNIT_TERABYTE), 1000000000000)
        self.assertEqual(self._device.unit_get_size(_ped.UNIT_KIBIBYTE), 1024)
        self.assertEqual(self._device.unit_get_size(_ped.UNIT_MEBIBYTE), 1048576)
        self.assertEqual(self._device.unit_get_size(_ped.UNIT_GIBIBYTE), 1073741824)
        self.assertEqual(self._device.unit_get_size(_ped.UNIT_TEBIBYTE), 1099511627776)
        self.assertEqual(self._device.unit_get_size(_ped.UNIT_CYLINDER), 65536)
        self.assertEqual(self._device.unit_get_size(_ped.UNIT_CHS), 512)
        self.assertEqual(self._device.unit_get_size(_ped.UNIT_PERCENT), self._device.length * self._device.sector_size // 100)
        self.assertRaises(ValueError, self._device.unit_get_size, _ped.UNIT_COMPACT)

class UnitGetNameTestCase(unittest.TestCase):
    def runTest(self):
        self.assertEqual(_ped.unit_get_name(_ped.UNIT_BYTE), 'B')
        self.assertEqual(_ped.unit_get_name(_ped.UNIT_CHS), 'chs')
        self.assertEqual(_ped.unit_get_name(_ped.UNIT_COMPACT), 'compact')
        self.assertEqual(_ped.unit_get_name(_ped.UNIT_CYLINDER), 'cyl')
        self.assertEqual(_ped.unit_get_name(_ped.UNIT_GIBIBYTE), 'GiB')
        self.assertEqual(_ped.unit_get_name(_ped.UNIT_GIGABYTE), 'GB')
        self.assertEqual(_ped.unit_get_name(_ped.UNIT_KIBIBYTE), 'kiB')
        self.assertEqual(_ped.unit_get_name(_ped.UNIT_KILOBYTE), 'kB')
        self.assertEqual(_ped.unit_get_name(_ped.UNIT_MEBIBYTE), 'MiB')
        self.assertEqual(_ped.unit_get_name(_ped.UNIT_MEGABYTE), 'MB')
        self.assertEqual(_ped.unit_get_name(_ped.UNIT_PERCENT), '%')
        self.assertEqual(_ped.unit_get_name(_ped.UNIT_SECTOR), 's')
        self.assertEqual(_ped.unit_get_name(_ped.UNIT_TEBIBYTE), 'TiB')
        self.assertEqual(_ped.unit_get_name(_ped.UNIT_TERABYTE), 'TB')

self.assertRaises(ValueError, _ped.unit_get_name, -1)
        self.assertRaises(ValueError, _ped.unit_get_name, 1000)

class UnitGetByNameTestCase(unittest.TestCase):
    def runTest(self):
        self.assertEqual(_ped.unit_get_by_name('B'), _ped.UNIT_BYTE)
        self.assertEqual(_ped.unit_get_by_name('chs'), _ped.UNIT_CHS)
        self.assertEqual(_ped.unit_get_by_name('compact'), _ped.UNIT_COMPACT)
        self.assertEqual(_ped.unit_get_by_name('cyl'), _ped.UNIT_CYLINDER)
        self.assertEqual(_ped.unit_get_by_name('GiB'), _ped.UNIT_GIBIBYTE)
        self.assertEqual(_ped.unit_get_by_name('GB'), _ped.UNIT_GIGABYTE)
        self.assertEqual(_ped.unit_get_by_name('kiB'), _ped.UNIT_KIBIBYTE)
        self.assertEqual(_ped.unit_get_by_name('kB'), _ped.UNIT_KILOBYTE)
        self.assertEqual(_ped.unit_get_by_name('MiB'), _ped.UNIT_MEBIBYTE)
        self.assertEqual(_ped.unit_get_by_name('MB'), _ped.UNIT_MEGABYTE)
        self.assertEqual(_ped.unit_get_by_name('%'), _ped.UNIT_PERCENT)
        self.assertEqual(_ped.unit_get_by_name('s'), _ped.UNIT_SECTOR)
        self.assertEqual(_ped.unit_get_by_name('TiB'), _ped.UNIT_TEBIBYTE)
        self.assertEqual(_ped.unit_get_by_name('TB'), _ped.UNIT_TERABYTE)

self.assertRaises(_ped.UnknownTypeException, _ped.unit_get_by_name, "blargle")
07070100115899000081ED0000FFFE0000FFFD0000000157CD697A00000AB8000000FC0000001000000000000000000000003A00000000pyparted-1466619794.7a0f829/tests/test__ped_filesystem.py#
# Copyright (C) 2009-2011  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): Chris Lumens <clumens@redhat.com>
#                    David Cantrell <dcantrell@redhat.com>
#
import sys
import _ped
from tests.baseclass import RequiresFileSystem

with self.assertRaises(TypeError):
            _ped.FileSystem(type=None, geom=None)
            _ped.FileSystem(type=fstype, geom=None)

fs = _ped.FileSystem(type=fstype, geom=self._geometry)
        self.assertIsInstance(fs, _ped.FileSystem)

class FileSystemGetSetTestCase(RequiresFileSystem):
    def runTest(self):
        fstype = _ped.file_system_type_get("ext2")
        fs = _ped.FileSystem(type=fstype, geom=self._geometry)

self.assertIsInstance(fs, _ped.FileSystem)
        self.assertEqual(fs.type, fstype)
        self.assertEqual(getattr(fs, "type"), fstype)
        # read-only attribute
        if sys.version_info[0] == 3:
            self.assertRaises(AttributeError, setattr, fs, "type", fstype)
        else:
            self.assertRaises(TypeError, setattr, fs, "type", fstype)
        self.assertRaises(AttributeError, getattr, fs, "junk")

class FileSystemStrTestCase(RequiresFileSystem):
    def runTest(self):
        fstype = _ped.file_system_type_get("ext2")
        fs = _ped.FileSystem(type=fstype, geom=self._geometry)
        # don't use assertEqual b/c __str__ includes memory addresses of
        # fstype and geom objects. This is easier.
        self.assertTrue(str(fs).startswith("_ped.FileSystem instance --"))
0707010011589A000081ED0000FFFE0000FFFD0000000157CD697A00001244000000FC0000001000000000000000000000003800000000pyparted-1466619794.7a0f829/tests/test__ped_disktype.py#
# Copyright (C) 2009-2011  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): Chris Lumens <clumens@redhat.com>
#                    David Cantrell <dcantrell@redhat.com>
#

import _ped
import sys
import unittest
from tests.baseclass import RequiresDiskTypes

# One class per method, multiple tests per class.  For these simple methods,
# that seems like good organization.  More complicated methods may require
# multiple classes and their own test suite.
class DiskTypeNewTestCase(unittest.TestCase):
    def runTest(self):
        # You're not allowed to create a new DiskType object by hand.
        self.assertRaises(TypeError, _ped.DiskType)

class DiskTypeGetSetTestCase(RequiresDiskTypes):
    def runTest(self):
        # All attributes are read-only.
        for name in self.disktype.keys():
            t = self.disktype[name]

self.assertRaises(AttributeError, setattr, t, "name", "fakename")
            self.assertRaises(AttributeError, setattr, t, "features", 47)

if sys.version_info >= (3,):
                bigint = int
                uni = str
            else:
                bigint = long       # pylint: disable=undefined-variable
                uni = unicode       # pylint: disable=undefined-variable
            self.assertIsInstance(t.name, uni)
            self.assertEqual(t.name, name)
            self.assertIsInstance(t.features, bigint)

class DiskTypeCheckFeatureTestCase(RequiresDiskTypes):
    def runTest(self):
        # The following types have no features [that libparted supports]
        for name in ['aix', 'sun', 'bsd', 'loop']:
            self.assertFalse(self.disktype[name].check_feature(_ped.DISK_TYPE_EXTENDED))
            self.assertFalse(self.disktype[name].check_feature(_ped.DISK_TYPE_PARTITION_NAME))

# The following types support DISK_TYPE_EXTENDED
        for name in ['msdos']:
            self.assertTrue(self.disktype[name].check_feature(_ped.DISK_TYPE_EXTENDED))
            self.assertFalse(self.disktype[name].check_feature(_ped.DISK_TYPE_PARTITION_NAME))

# The following types support DISK_TYPE_PARTITION_NAME
        for name in ['amiga', 'gpt', 'mac', 'pc98']:
            self.assertFalse(self.disktype[name].check_feature(_ped.DISK_TYPE_EXTENDED))
            self.assertTrue(self.disktype[name].check_feature(_ped.DISK_TYPE_PARTITION_NAME))

# The following types support all features
        for name in ['dvh']:
            self.assertTrue(self.disktype[name].check_feature(_ped.DISK_TYPE_EXTENDED))
            self.assertTrue(self.disktype[name].check_feature(_ped.DISK_TYPE_PARTITION_NAME))

class DiskTypeStrTestCase(RequiresDiskTypes):
    def runTest(self):
        self.assertEqual(str(self.disktype['msdos']), '_ped.DiskType instance --\n  name: msdos  features: 1')
        self.assertEqual(str(self.disktype['aix']), '_ped.DiskType instance --\n  name: aix  features: 0')
        self.assertEqual(str(self.disktype['sun']), '_ped.DiskType instance --\n  name: sun  features: 0')
        self.assertEqual(str(self.disktype['amiga']), '_ped.DiskType instance --\n  name: amiga  features: 2')
        self.assertEqual(str(self.disktype['gpt']), '_ped.DiskType instance --\n  name: gpt  features: 2')
        self.assertEqual(str(self.disktype['mac']), '_ped.DiskType instance --\n  name: mac  features: 2')
        self.assertEqual(str(self.disktype['bsd']), '_ped.DiskType instance --\n  name: bsd  features: 0')
        self.assertEqual(str(self.disktype['pc98']), '_ped.DiskType instance --\n  name: pc98  features: 2')
        self.assertEqual(str(self.disktype['loop']), '_ped.DiskType instance --\n  name: loop  features: 0')
        self.assertEqual(str(self.disktype['dvh']), '_ped.DiskType instance --\n  name: dvh  features: 3')
0707010011589B000081A40000FFFE0000FFFD0000000157CD697A00001B77000000FC0000001000000000000000000000002F00000000pyparted-1466619794.7a0f829/tests/baseclass.py#
# Copyright (C) 2008-2011  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): Chris Lumens <clumens@redhat.com>
#                    David Cantrell <dcantrell@redhat.com>

import _ped
import parted
import os
import tempfile
import unittest

# Base class for any test case that requires a temp device node
class RequiresDeviceNode(unittest.TestCase):
    def setUp(self):
        self.addCleanup(self.removeTempDevice)

(fd, self.path) = tempfile.mkstemp(prefix="temp-device-")
        f = os.fdopen(fd)
        f.seek(140000)
        os.write(fd, b"0")

def removeTempDevice(self):
        if self.path and os.path.exists(self.path):
            os.unlink(self.path)

# Base class for any test case that requires a _ped.Device or parted.Device
# object first.
class RequiresDevice(RequiresDeviceNode):
    def setUp(self):
        RequiresDeviceNode.setUp(self)
        self._device = _ped.device_get(self.path)
        self.device = parted.getDevice(self.path)

# Base class for any test case that requires a filesystem on a device.
class RequiresFileSystem(unittest.TestCase):
    def setUp(self):
        self.addCleanup(self.removeTempDevice)

self._fileSystemType = {}
        ty = _ped.file_system_type_get_next()
        self._fileSystemType[ty.name] = ty

while True:
            try:
                ty = _ped.file_system_type_get_next(ty)
                self._fileSystemType[ty.name] = ty
            except (IndexError, TypeError, _ped.UnknownTypeException):
                break

(fd, self.path,) = tempfile.mkstemp(prefix="temp-device-")
        f = os.fdopen(fd)
        f.seek(140000)
        os.write(fd, b"0")
        f.close()

os.system("mke2fs -F -q %s" % (self.path,))

self._device = _ped.device_get(self.path)
        self._geometry = _ped.Geometry(self._device, 0, self._device.length - 1)

def removeTempDevice(self):
        if self.path and os.path.exists(self.path):
            os.unlink(self.path)

# Base class for certain alignment tests that require a _ped.Device
class RequiresDeviceAlignment(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)

def roundDownTo(self, sector, grain_size):
        if sector < 0:
            shift = sector % grain_size + grain_size
        else:
            shift = sector % grain_size

return sector - shift

def roundUpTo(self, sector, grain_size):
        if sector % grain_size:
            return self.roundDownTo(sector, grain_size) + grain_size
        else:
            return sector

def closestInsideGeometry(self, alignment, geometry, sector):
        if alignment.grain_size == 0:
            if alignment.is_aligned(geometry, sector) and \
               ((geometry is None) or geometry.test_sector_inside(sector)):
                return sector
            else:
                return -1

if sector < geometry.start:
            sector += self.roundUpTo(geometry.start - sector,
                                     alignment.grain_size)

if sector > geometry.end:
            sector -= self.roundUpTo(sector - geometry.end,
                                     alignment.grain_size)

if not geometry.test_sector_inside(sector):
            return -1

return sector

def closest(self, sector, a, b):
        if a == -1:
            return b

if b == -1:
            return a

if abs(sector - a) < abs(sector - b):
            return a
        else:
            return b

# Base class for any test case that requires a labeled device
class RequiresLabeledDevice(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        os.system("parted -s %s mklabel msdos" % (self.path,))

# Base class for any test case that requires a _ped.Disk or parted.Disk.
class RequiresDisk(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        self._disk = _ped.disk_new_fresh(self._device, _ped.disk_type_get("msdos"))
        self.disk = parted.Disk(PedDisk=self._disk)

# Base class for any test case that requires a filesystem made and mounted.
class RequiresMount(RequiresDevice):
    def setUp(self):
        self.addCleanup(self.removeMountpoint)
        RequiresDevice.setUp(self)
        self.mountpoint = None

def mkfs(self):
        os.system("mkfs.ext2 -F -q %s" % self.path)

def doMount(self):
        self.mountpoint = tempfile.mkdtemp()
        os.system("mount -o loop %s %s" % (self.path, self.mountpoint))

def removeMountpoint(self):
        if self.mountpoint and os.path.exists(self.mountpoint):
            os.system("umount %s" % self.mountpoint)
            os.rmdir(self.mountpoint)

# Base class for any test case that requires a _ped.Partition.
class RequiresPartition(RequiresDisk):
    def setUp(self):
        RequiresDisk.setUp(self)
        self._part = _ped.Partition(disk=self._disk, type=_ped.PARTITION_NORMAL,
                                    start=0, end=100, fs_type=_ped.file_system_type_get("ext2"))

# Base class for any test case that requires a hash table of all
# _ped.DiskType objects available
class RequiresDiskTypes(unittest.TestCase):
    def setUp(self):
        self.disktype = {}
        ty = _ped.disk_type_get_next()
        self.disktype[ty.name] = ty

while True:
            try:
                ty = _ped.disk_type_get_next(ty)
                self.disktype[ty.name] = ty
            except (IndexError, TypeError, _ped.UnknownTypeException):
                break

# Base class for any test case that requires a list being built via successive
# calls of some function.  The function must raise IndexError when there's no
# more output to add to the return list.  This class is most useful for all
# those _get_next methods.
class BuildList:
    def getDeviceList(self, func):
        lst = []
        prev = None

while True:
            try:
                if not prev:
                    prev = func()
                else:
                    prev = func(prev)

lst.append(prev)
            except IndexError:
                break

return lst
0707010011589C000081ED0000FFFE0000FFFD0000000157CD697A0000156B000000FC0000001000000000000000000000003B00000000pyparted-1466619794.7a0f829/tests/test_parted_alignment.py#
# Test cases for the methods in the parted.alignment module itself
#
# Copyright (C) 2009-2011  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 _ped
import parted
import unittest
from tests.baseclass import RequiresDevice

def runTest(self):
        # Check that not passing args to parted.Alignment.__init__ is caught.
        self.assertRaises(parted.AlignmentException, parted.Alignment)

# And then the correct ways of creating a parted.Alignment
        a = parted.Alignment(offset=0, grainSize=100)
        self.assertIsInstance(a, parted.Alignment)

b = parted.Alignment(PedAlignment=self.pa)
        self.assertIsInstance(b, parted.Alignment)

# Test for _ped.Alignment equality
        self.assertEqual(b.getPedAlignment(), self.pa)

class AlignmentGetSetTestCase(unittest.TestCase):
    def setUp(self):
        self.a = parted.Alignment(offset=27, grainSize=49)

def runTest(self):
        # Test that passing the args to __init__ works.
        self.assertIsInstance(self.a, parted.Alignment)
        self.assertEqual(self.a.offset, 27)
        self.assertEqual(self.a.grainSize, 49)

# Test that setting directly and getting with getattr works.
        self.a.offset = 10
        self.a.grainSize = 90

self.assertEqual(getattr(self.a, "offset"), 10)
        self.assertEqual(getattr(self.a, "grainSize"), 90)

# Check that setting with setattr and getting directly works.
        setattr(self.a, "offset", 20)
        setattr(self.a, "grainSize", 80)

self.assertEqual(self.a.offset, 20)
        self.assertEqual(self.a.grainSize, 80)

# Check that values have the right type.
        self.assertRaises(TypeError, setattr, self.a, "offset", "string")

# Check that looking for invalid attributes fails properly.
        self.assertRaises(AttributeError, getattr, self.a, "blah")

@unittest.skip("Unimplemented test case.")
class AlignmentIntersectTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class AlignmentAlignUpTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class AlignmentAlignDownTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class AlignmentAlignNearestTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

class AlignmentIsAlignedTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        self.g = parted.Geometry(device=self.device, start=0, length=100)
        self.a = parted.Alignment(offset=10, grainSize=0)

def runTest(self):
        # Test a couple ways of passing bad arguments.
        self.assertRaises(TypeError, self.a.isAligned, None, 12)
        self.assertRaises(TypeError, self.a.isAligned, self.g, None)

# Sector must be inside the geometry.
        self.assertFalse(self.a.isAligned(self.g, 400))

# If grain_size is 0, sector must be the same as offset.
        self.assertTrue(self.a.isAligned(self.g, 10))
        self.assertFalse(self.a.isAligned(self.g, 0))
        self.assertFalse(self.a.isAligned(self.g, 47))

# If grain_size is anything else, there's real math involved.
        self.a.grainSize = 5
        self.assertTrue(self.a.isAligned(self.g, 20))
        self.assertFalse(self.a.isAligned(self.g, 23))

class AlignmentGetPedAlignmentTestCase(unittest.TestCase):
    def setUp(self):
        self.pa = _ped.Alignment(0, 100)
        self.alignment = parted.Alignment(PedAlignment=self.pa)

def runTest(self):
        # Test to make sure we get a _ped.Alignment
        self.assertIsInstance(self.alignment.getPedAlignment(), _ped.Alignment)

# Test for _ped.Alignment equality
        self.assertEqual(self.alignment.getPedAlignment(), self.pa)

@unittest.skip("Unimplemented test case.")
class AlignmentStrTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")
0707010011589D000081ED0000FFFE0000FFFD0000000157CD697A000026A4000000FC0000001000000000000000000000003A00000000pyparted-1466619794.7a0f829/tests/test__ped_constraint.py#
# Copyright (C) 2009-2011  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): Chris Lumens <clumens@redhat.com>
#                    David Cantrell <dcantrell@redhat.com>
#

import _ped

from tests.baseclass import RequiresDevice

# One class per method, multiple tests per class.  For these simple methods,
# that seems like good organization.  More complicated methods may require
# multiple classes and their own test suite.
class ConstraintNewTestCase(RequiresDevice):
    def runTest(self):
        align1 = _ped.Alignment(10, 5)
        align2 = _ped.Alignment(10, 5)
        geom1 = _ped.Geometry(self._device, 0, 50)
        geom2 = _ped.Geometry(self._device, 25, 50)

# Check that not passing enough args to _ped.Constraint.__init__ is caught.
        self.assertRaises(TypeError, _ped.Constraint)
        self.assertRaises(TypeError, _ped.Constraint, align1, align2)

# Or the parameters in the wrong order.
        self.assertRaises(TypeError, _ped.Constraint, align1, align2, 10, 100,
                          geom1, geom2)

# And then the correct way of creating a _ped.Constraint.
        c = _ped.Constraint(align1, align2, geom1, geom2, 10, 100)
        self.assertIsInstance(c, _ped.Constraint)

class ConstraintGetSetTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        align1 = _ped.Alignment(10, 5)
        align2 = _ped.Alignment(10, 5)
        geom1 = _ped.Geometry(self._device, 0, 50)
        geom2 = _ped.Geometry(self._device, 25, 50)

self.c = _ped.Constraint(align1, align2, geom1, geom2, min_size=10,
                                 max_size=100)

def runTest(self):
        # Test that passing the kwargs to __init__ works.
        self.assertEqual(self.c.min_size, 10)
        self.assertEqual(self.c.max_size, 100)
        self.assertIsInstance(self.c.start_align, _ped.Alignment)
        self.assertIsInstance(self.c.end_align, _ped.Alignment)
        self.assertIsInstance(self.c.start_range, _ped.Geometry)
        self.assertIsInstance(self.c.end_range, _ped.Geometry)

# Test that setting directly and getting with getattr works.
        self.c.min_size = 15
        self.c.max_size = 75

self.assertEqual(getattr(self.c, "min_size"), 15)
        self.assertEqual(getattr(self.c, "max_size"), 75)
        self.assertIsInstance(getattr(self.c, "start_align"), _ped.Alignment)
        self.assertIsInstance(getattr(self.c, "end_align"), _ped.Alignment)
        self.assertIsInstance(getattr(self.c, "start_range"), _ped.Geometry)
        self.assertIsInstance(getattr(self.c, "end_range"), _ped.Geometry)

# Test that setting with setattr and getting directly works.
        setattr(self.c, "min_size", 10)
        setattr(self.c, "max_size", 90)

self.assertEqual(self.c.min_size, 10)
        self.assertEqual(self.c.max_size, 90)

# Test that values have the right type.
        self.assertRaises(TypeError, setattr, self.c, "min_size", "string")

# Test that looking for invalid attributes fails properly.
        self.assertRaises(AttributeError, getattr, self.c, "blah")

# We really shouldn't be allowed to overwrite objects stored in a
        # _ped.Constraint, but for now there's no way to prevent it.
        self.c.end_range = 47
        self.assertEqual(self.c.end_range, 47)

class ConstraintDuplicateTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        align1 = _ped.Alignment(10, 0)
        align2 = _ped.Alignment(10, 0)
        geom1 = _ped.Geometry(self._device, 0, 50)
        geom2 = _ped.Geometry(self._device, 25, 50)

self.c = _ped.Constraint(align1, align2, geom1, geom2, min_size=10,
                                 max_size=100)
        self.dup = self.c.duplicate()

def runTest(self):
        self.assertEqual(self.c.min_size, self.dup.min_size)
        self.assertEqual(self.c.max_size, self.dup.max_size)

# duplicate methods should do a deepcopy, so self.dup should have
        # different references, but the same contents.
        self.assertNotEqual(repr(self.c), repr(self.dup))

self.assertNotEqual(repr(self.c.start_align), repr(self.dup.start_align))
        self.assertEqual(self.c.start_align.offset, self.dup.start_align.offset)
        self.assertEqual(self.c.start_align.grain_size, self.dup.start_align.grain_size)

self.assertNotEqual(repr(self.c.end_align), repr(self.dup.end_align))
        self.assertEqual(self.c.end_align.offset, self.dup.end_align.offset)
        self.assertEqual(self.c.end_align.grain_size, self.dup.end_align.grain_size)

self.assertNotEqual(repr(self.c.start_range), repr(self.dup.start_range))
        self.assertNotEqual(repr(self.c.start_range.dev), repr(self.dup.start_range.dev))
        self.assertEqual(self.c.start_range.dev.path, self.dup.start_range.dev.path)
        self.assertEqual(self.c.start_range.start, self.dup.start_range.start)
        self.assertEqual(self.c.start_range.length, self.dup.start_range.length)
        self.assertEqual(self.c.start_range.end, self.dup.start_range.end)

self.assertNotEqual(repr(self.c.end_range), repr(self.dup.end_range))
        self.assertNotEqual(repr(self.c.end_range.dev), repr(self.dup.end_range.dev))
        self.assertEqual(self.c.end_range.dev.path, self.dup.end_range.dev.path)
        self.assertEqual(self.c.end_range.start, self.dup.end_range.start)
        self.assertEqual(self.c.end_range.length, self.dup.end_range.length)
        self.assertEqual(self.c.end_range.end, self.dup.end_range.end)

class ConstraintIntersectTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        align1 = _ped.Alignment(10, 0)
        align2 = _ped.Alignment(10, 0)
        geom1 = _ped.Geometry(self._device, 0, 50)
        geom2 = _ped.Geometry(self._device, 25, 50)

self.c1 = _ped.Constraint(align1, align2, geom1, geom2, min_size=10,
                                  max_size=100)

geom3 = _ped.Geometry(self._device, 10, 50)
        geom4 = _ped.Geometry(self._device, 30, 40)
        self.c2 = _ped.Constraint(align1, align2, geom3, geom4, min_size=10,
                                  max_size=100)

def runTest(self):
        startAlign = self.c1.start_align.intersect(self.c2.start_align)
        endAlign = self.c1.end_align.intersect(self.c2.end_align)
        startRange = self.c1.start_range.intersect(self.c2.start_range)
        endRange = self.c1.end_range.intersect(self.c2.end_range)
        minSize = max(self.c1.min_size, self.c2.min_size)
        maxSize = min(self.c1.max_size, self.c2.max_size)

if not startAlign or not endAlign or not startRange or not endRange:
            expected = None
        else:
            expected = _ped.Constraint(startAlign, endAlign,
                                       startRange, endRange,
                                       min_size=minSize, max_size=maxSize)

result = self.c1.intersect(self.c2)
        self.assertEqual(result, expected)

class ConstraintSolveMaxTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        self.c1 = self._device.get_constraint()

def runTest(self):
        result = self.c1.solve_max()
        self.assertEqual(result.dev, self._device)
        self.assertGreaterEqual(result.length, self._device.length - 1)

class ConstraintSolveNearestTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        self.c1 = self._device.get_constraint()
        self.g1 = _ped.Geometry(self._device, 1, 8)

def runTest(self):
        result = self.c1.solve_nearest(self.g1)
        self.assertEqual(result, self.g1)

class ConstraintIsSolutionTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        self.c1 = self._device.get_constraint()
        self.g1 = _ped.Geometry(self._device, 1, 8)

def runTest(self):
        self.assertTrue(self.c1.is_solution(self.g1))

class ConstraintStrTestCase(RequiresDevice):
    def setUp(self):
        RequiresDevice.setUp(self)
        align1 = _ped.Alignment(10, 0)
        align2 = _ped.Alignment(10, 0)
        geom1 = _ped.Geometry(self._device, 0, 50)
        geom2 = _ped.Geometry(self._device, 25, 50)

self.c1 = _ped.Constraint(align1, align2, geom1, geom2, min_size=10,
                                  max_size=100)
    def runTest(self):
        result = str(self.c1).split('\n')

self.assertEqual(result[0], '_ped.Constraint instance --')
        self.assertTrue(result[1].startswith('  start_align: <_ped.Alignment object at '))
        self.assertNotEqual(result[1].find('  end_align: <_ped.Alignment object at '), -1)
        self.assertTrue(result[2].startswith('  start_range: <_ped.Geometry object at '))
        self.assertNotEqual(result[2].find('  end_range: <_ped.Geometry object at '), -1)
        self.assertEqual(result[3], '  min_size: 10  max_size: 100')
0707010011589E000081ED0000FFFE0000FFFD0000000157CD697A00000822000000FC0000001000000000000000000000003E00000000pyparted-1466619794.7a0f829/tests/test__ped_filesystemtype.py#
# Copyright (C) 2009-2011  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): Chris Lumens <clumens@redhat.com>
#
import _ped
import unittest

# One class per method, multiple tests per class.  For these simple methods,
# that seems like good organization.  More complicated methods may require
# multiple classes and their own test suite.
class FileSystemTypeNewTestCase(unittest.TestCase):
    def runTest(self):
        # You can't create a FileSystemType by hand.
        self.assertRaises(TypeError, _ped.FileSystemType)

class FileSystemTypeGetSetTestCase(unittest.TestCase):
    def runTest(self):
        fstype = _ped.file_system_type_get("ext3")

self.assertIsInstance(fstype, _ped.FileSystemType)
        self.assertEqual(fstype.name, "ext3")
        self.assertEqual(getattr(fstype, "name"), "ext3")
        self.assertRaises(AttributeError, setattr, fstype, "name", "vfat")
        self.assertRaises(AttributeError, getattr, fstype, "junk")

class FileSystemTypeStrTestCase(unittest.TestCase):
    def runTest(self):
        fstype = _ped.file_system_type_get("ext3")

self.assertEqual(str(fstype), "_ped.FileSystemType instance --\n  name: ext3")
070701001158A1000081ED0000FFFE0000FFFD0000000157CD697A0000275A000000FC0000001000000000000000000000003B00000000pyparted-1466619794.7a0f829/tests/test_parted_partition.py#
# Test cases for the methods in the parted.partition module itself
#
# Copyright (C) 2009-2011  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 parted
import unittest

from tests.baseclass import RequiresDisk

# One class per method, multiple tests per class.  For these simple methods,
# that seems like good organization.  More complicated methods may require
# multiple classes and their own test suite.

class PartitionNewTestCase(RequiresDisk):
    """
        PartitionNew tests if parted.Partition:
        1) raises user defined exception if called without arguments
        2) if parted.Partition is instantiable with argument fs
        3) if parted.Partition is instantiable without argument fs
    """
    def setUp(self):
        super(PartitionNewTestCase, self).setUp()
        self.geom = parted.Geometry(self.device, start=100, length=100)
        self.fs = parted.FileSystem(type='ext2', geometry=self.geom)
        self.part = parted.Partition(self.disk, parted.PARTITION_NORMAL,
                                geometry=self.geom, fs=self.fs)

def runTest(self):
        # Check that not passing args to parted.Partition.__init__ is caught.
        with self.assertRaises((parted.PartitionException,)):
            parted.Partition()

self.assertIsInstance(self.part, parted.Partition)
        # You don't need to pass a filesystem type at all, since this partition
        # might be FREESPACE or METADATA.
        part_nofs = parted.Partition(self.disk, parted.PARTITION_NORMAL,
                                geometry=self.geom)
        self.assertIsInstance(part_nofs, parted.Partition)

class PartitionGetSetTestCase(PartitionNewTestCase):
    """
        PartitionGetSet tests "part" instance
        of class parted.Partition(created in baseclass)
        for basic get and set operations on its attributes.
    """
    def runTest(self):
        # Test that passing the kwargs to __init__ works.
        self.assertEqual(self.part.disk, self.disk)
        self.assertIsInstance(self.part.geometry, parted.Geometry)
        self.assertEqual(self.part.type, parted.PARTITION_NORMAL)
        self.assertEqual(self.part.fileSystem.type, "ext2")

# Test that setting the RW attributes directly works.
        self.part.type = parted.PARTITION_EXTENDED
        self.assertEqual(self.part.type, parted.PARTITION_EXTENDED)

# Test that setting the RO attributes directly doesn't work.
        exn = (AttributeError, TypeError)
        with self.assertRaises(exn):
            self.part.number = 1
        with self.assertRaises(exn):
            self.part.active = True
        with self.assertRaises(exn):
            self.part.name = "blah"
        with self.assertRaises(exn):
            self.part.type = "blah"
        with self.assertRaises(exn):
            self.part.geometry = parted.Geometry(self.device, start=10, length=20)
        with self.assertRaises(exn):
            self.part.fileSystem = parted.FileSystem(type='ext4', geometry=self.geom)
        with self.assertRaises(exn):
            self.part.disk = self.disk

# Check that looking for invalid attributes fails properly.
        with self.assertRaises((AttributeError)):
            print(self.part.blah)

class PartitionSetFlagTestCase(PartitionNewTestCase):
    """
        Method setFlag should return True, if flag was set to "on" state.
        Next few flag testcases will inherit from setUp.
        This testcase checks if method setFlag returns:
        1)correct bool when state of BOOT and RAID flags is set to "on"
        on partition.
        2)raises user defined exception on unavailable flag
        See parted/include/parted/disk.in.h for flag numbers.
        Partition flags are dependent on disklabel. In this case msdos label is
        used, see parted library libparted/labels/dos.c for flags availability.
    """
    def setUp(self):
        super(PartitionSetFlagTestCase, self).setUp()
        self.neg_msg = "Method returns unexpected bool value"
        self.flag_set = self.part.setFlag(1)
        self.flag_set1 = self.part.setFlag(5)

def runTest(self):
        self.assertTrue(self.flag_set, self.neg_msg)
        self.assertTrue(self.flag_set1, self.neg_msg)
        with self.assertRaises((parted.PartitionException,)):
            self.part.setFlag(2)

class PartitionGetFlagTestCase(PartitionSetFlagTestCase):
    """
        Method getFlag should return correct bool value depending on flag
        setting(flag is off=>False; on=>True).
        This testcase checks if method getFlag returns:
        1)correct bools when checks state of BOOT(on), RAID(on) and LVM(off)
        flags.
    """
    def runTest(self):
        self.assertTrue(self.part.getFlag(1), self.neg_msg)
        self.assertTrue(self.part.getFlag(5), self.neg_msg)
        self.assertFalse(self.part.getFlag(6), self.neg_msg)

class PartitionUnsetFlagTestCase(PartitionSetFlagTestCase):
    """
        Method unsetFlag should set flag to "off" state and return True on
        success. PartitionException should be raised on error.
        This testcase checks if method unsetFlag returns:
        1)correct bool value when flag is unset and if flag is in state 'off'
        2)raises user defined exception on unavailable flag
    """
    def runTest(self):
        self.assertTrue(self.part.unsetFlag(1), self.neg_msg)
        self.assertFalse(self.part.getFlag(1), self.neg_msg)

with self.assertRaises((parted.PartitionException,)):
            self.part.unsetFlag(2)

class PartitionIsFlagAvailableTestCase(PartitionNewTestCase):
    '''
        Method isFlagAvailable should return bool value whenever flag is
        available according to chosen disk label setting and disk proportions
        itself.
        This testcase checks if method isFlagAvailable returns:
        1)bool value without traceback
        2)false on nonexistent flag
        3)raises user defined exception when called on inactive partition
    '''
    def runTest(self):
        for f in ['PARTITION_BOOT', 'PARTITION_ROOT', 'PARTITION_SWAP',
                  'PARTITION_HIDDEN', 'PARTITION_RAID', 'PARTITION_LVM',
                  'PARTITION_LBA', 'PARTITION_HPSERVICE',
                  'PARTITION_PALO', 'PARTITION_PREP',
                  'PARTITION_MSFT_RESERVED',
                  'PARTITION_APPLE_TV_RECOVERY',
                  'PARTITION_BIOS_GRUB', 'PARTITION_DIAG',
                  'PARTITION_MSFT_DATA', 'PARTITION_IRST',
                  'PARTITION_ESP', 'PARTITION_NONFS']:
            if not hasattr(parted, f):
                continue
            attr = getattr(parted, f)
            self.assertIsInstance(self.part.isFlagAvailable(attr), bool)

self.assertFalse(self.part.isFlagAvailable(1000))

with self.assertRaises((parted.PartitionException,)):
            self.part = parted.Partition(self.disk, parted.PARTITION_FREESPACE,
            geometry=self.geom)
            self.part.isFlagAvailable(parted.PARTITION_BOOT)

class PartitionGetFlagsAsStringTestCase(PartitionSetFlagTestCase):
    '''
        Method getFlagsAsString should return all flags which are in state "on"
        as comma separated list.
    '''
    def runTest(self):
        self.assertEqual(self.part.getFlagsAsString(), 'boot, raid')

@unittest.skip("Unimplemented test case.")
class PartitionGetMaxGeometryTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class PartitionNextPartitionTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class PartitionGetSizeTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

class PartitionGetLengthTestCase(RequiresDisk):
    def runTest(self):
        length = 100
        geom = parted.Geometry(self.device, start=100, length=length)
        part = parted.Partition(self.disk, parted.PARTITION_NORMAL, geometry=geom)
        constraint = parted.Constraint(exactGeom=geom)
        self.disk.addPartition(part, constraint)
        self.disk.commit()
        part = self.disk.partitions[0]

self.assertEqual(part.getLength(), part.geometry.length)
        self.assertEqual(part.getLength(), length)

@unittest.skip("Unimplemented test case.")
class PartitionGetMaxAvailableSizeTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class PartitionGetDeviceNodeNameTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class PartitionGetPedPartitionTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")

@unittest.skip("Unimplemented test case.")
class PartitionStrTestCase(unittest.TestCase):
    def runTest(self):
        # TODO
        self.fail("Unimplemented test case.")
07070100115820000041ED0000FFFE0000FFFD0000000257CD697A00000000000000FC0000001000000000000000000000002500000000pyparted-1466619794.7a0f829/examples07070100115824000041ED0000FFFE0000FFFD0000000457CD697A00000000000000FC0000001000000000000000000000002000000000pyparted-1466619794.7a0f829/src0707010011583D000041ED0000FFFE0000FFFD0000000857CD697A00000000000000FC0000001000000000000000000000002100000000pyparted-1466619794.7a0f829/.git07070100115868000041ED0000FFFE0000FFFD0000000457CD697A00000000000000FC0000001000000000000000000000002400000000pyparted-1466619794.7a0f829/include07070100115889000041ED0000FFFE0000FFFD0000000357CD697A00000000000000FC0000001000000000000000000000002200000000pyparted-1466619794.7a0f829/tests0707010011581B000081A40000FFFE0000FFFD0000000157CD697A00000C71000000FC0000001000000000000000000000002500000000pyparted-1466619794.7a0f829/setup.py# setup.py script for pyparted
# Copyright (C) 2011-2013 Red Hat, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty 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., 675 Mass Ave, Cambridge, MA 02139, USA.
#
# Author(s): David Cantrell <dcantrell@redhat.com>
#            Alex Skinner <alex@lx.lc>
#
# pylint: skip-file

import subprocess
import glob
import os
import platform
import sys
from distutils.ccompiler import new_compiler
from distutils.errors import CompileError
from distutils.errors import LinkError
from distutils.core import setup
from distutils.core import Extension
from distutils.version import LooseVersion

pyparted_version = '3.10.7'
python_version = sys.version_info

need_libparted_version = '2.3'
need_python_version = (2, 7)

if python_version < need_python_version:
    raise RuntimeError("pyparted requires Python version %d.%d or higher"
                       % need_python_version)
# Recipe from:
# http://code.activestate.com/recipes/502261-python-distutils-pkg-config/
def pkgconfig(*packages, **kwargs):
    flag_map = {'-I': 'include_dirs', '-L': 'library_dirs', '-l': 'libraries'}
    for token in subprocess.check_output(["pkg-config", "--libs", "--cflags"] + list(packages)).decode('utf-8').split():

kwargs.setdefault(flag_map.get(token[:2]), []).append(token[2:])
    return kwargs

def check_mod_version(module, version):
    modversion = subprocess.check_output(["pkg-config", "--modversion", module]).decode('utf-8').split()[0]
    if not LooseVersion(modversion) >= LooseVersion(version):
        sys.stderr.write("*** Minimum required %s version: %s, found: %s\n" % (module, version, modversion,))
        sys.exit(1)
    return

check_mod_version('libparted', need_libparted_version)

# This list is in the format necessary for the define_macros parameter
# for an Extension() module definition.  See:
# http://docs.python.org/distutils/setupscript.html#preprocessor-options
features = [('PYPARTED_VERSION', "\"%s\"" % pyparted_version)]

setup(name='pyparted',
      version=pyparted_version,
      author='pyparted Development Team',
      author_email='pyparted-devel@redhat.com',
      url='https://fedorahosted.org/pyparted/',
      description='Python bindings for GNU parted',
      license='GPLv2+',
      packages=['parted'],
      package_dir={'parted': 'src/parted'},
      ext_modules=[Extension('_ped',
                             glob.glob(os.path.join('src', '*.c')),
                             define_macros=features,
                             **pkgconfig('libparted',
                                         include_dirs=['include']))
                  ])
0707010011581C000081A40000FFFE0000FFFD0000000157CD697A00000229000000FC0000001000000000000000000000002400000000pyparted-1466619794.7a0f829/RELEASEInstructions for making a new release:

1) git checkout master
2) git clean -d -x -f         # I hope you've commited or stashed everything
                              # you are working on
2) git fetch
3) git rebase origin
4) make bumpver
5) git commit -a -m "New version."
6) git clean -d -x -f
7) make release

If packaging in RPM format, you might find the 'make rpmlog' target useful.
It gives you an RPM spec file formatted changelog block that contains the
git shortlog entries of all changes since the last tag.

8) git push
9) git push --tags
0707010011581D000081A40000FFFE0000FFFD0000000157CD697A00000097000000FC0000001000000000000000000000002800000000pyparted-1466619794.7a0f829/MANIFEST.ininclude AUTHORS BUGS COPYING HACKING NEWS RELEASE TODO
include MANIFEST.in
include Makefile
recursive-include include *.h
recursive-include tests *.py
0707010011581E000081A40000FFFE0000FFFD0000000157CD697A000000CE000000FC0000001000000000000000000000002400000000pyparted-1466619794.7a0f829/AUTHORSDavid Cantrell <dcantrell@redhat.com>
Chris Lumens <clumens@redhat.com>
David Campbell <davekong@archlinux.us>

Python 3 Porting:
Alex Skinner <alex@lx.lc>
Gabriel de Perthuis <g2p.code+pyparted@gmail.com>
0707010011581F000081A40000FFFE0000FFFD0000000157CD697A00000D65000000FC0000001000000000000000000000002100000000pyparted-1466619794.7a0f829/TODO- Methods in the parted module that just return data and take in no
  parameters...make those read-only properties and get rid of the
  method.  Since we have more or less established the API now, mark
  the methods as Deprecated and leave them around for a release
  before removing them.

- add parted.Device.toSectors() method that takes in a size specification,
  such as 10.5MB, as a string and converts that size to a sector count
  based on the sector size of that Device

- use disttools from Python to do as much work as possible

- Walk through all of the src/py*.c files and make sure libparted exceptions
  are captured and filtered back up through Python.  Will need to define some
  sane Python exception classes for libparted's exceptions.

- Handle exceptions from libparted and pass to Python as necessary.  The
  PED_ASSERT things are where libparted aborts, so we may want to catch things
  before it goes in to libparted so we can throw an exception rather than
  letting the library abort().  The ped_exception_throw() instances are all
  libparted's own exception-like system.

- Handle exceptions throughout the _ped module code.  Unique exceptions as
  much as possible.

- Figure out what, if anything, we can do with timers.  They are optional in
  libparted, but do we want to support them in pyparted?

- Error handling in the get and set methods.

- Free memory in error handling cases.

- Exception handling:
      - Audit error messages to make them more useful.

- All test cases with '# TODO' in the runTest() method.  Be sure to uncomment
  them once you have written the test.

- Make sure PyTypeObjects that have a tp_init are allocating memory that the
  garbage collector knows about.  I'm not sure if PyType_GenericAlloc or
  PyType_GenericNew do this.

- Coding policy that we need to make sure we're doing:
  If object creation fails, we need to use PyObject_GC_Del() to destroy it
  before throwing an exception at the user.  For all other instances where
  we need to delete or destroy the object, use Py_XDECREF().  Once the ref
  count is zero, the GC will take over and run dealloc() for that object,
  which will eventually run PyObject_GC_Del().  Basically, we should only
  be using PyObject_GC_Del() in the convert functions or in __init__
  constructors where we are making a new object for the user.

NOTE: If we need to destroy an object due to creation failure and the
  object we are creating has other PyObject members, call Py_XDECREF on
  those members rather than destroing them.  We can't ensure that there
  will be no other references to those members, so let the normal object
  destructor handle PyObject members, but forcefully destroy the object
  we are trying to create.

- destroy() methods don't seem to be destroying the Python object.

- Make sure this new code works in Python 3000

- Look through all PyTypeObject objects and see where we can expand
  their functionality.  Can we add str() support, for instance.

- Move the constraint functions presently in _ped to be in the __init_()
  method for _ped.Constraint, similar to what was done for _ped_Disk_init:
      constraint_new_from_min_max
      constraint_new_from_min
      constraint_new_from_max
      constraint_any
      constraint_exact

- parted module:
      - Write docstrings for everything

- autoconf
      - More detailed API checks for libparted and Python

... and much much more
07070100115822000081A40000FFFE0000FFFD0000000157CD697A00000206000000FC0000001000000000000000000000002100000000pyparted-1466619794.7a0f829/NEWSpyparted-2.1.0
--------------

pyparted supports new libparted API functions, but those functions are not
yet available in an official release on ftp.gnu.org.  On Fedora systems, the
parted-1.9.0-23 package and later revisions contain the necessary API support.

pyparted-2.0.0
--------------

Complete rewrite of pyparted.  There are now two Python modules exposing the
pyparted API:

_ped       Low level module interfacing with libparted.
    parted     Higher level module written in Python building on _ped.
07070100115866000081A40000FFFE0000FFFD0000000157CD697A0000171E000000FC0000001000000000000000000000002400000000pyparted-1466619794.7a0f829/HACKINGContributing to pyparted

This guide helps explain how to get your contributions accepted in to the
project.  Coding style, patch generation, and how to submit patches are
all discussed here.

CODING STYLE FOR C

Please follow the coding style you see in the C source files here.  The project
is developed on Linux, which gcc is the compiler.  That affords us a lot of
flexibility with regards to standards, but try to adhere to ISO C99 whenever
possible and avoid using gcc extensions.  There is a possibility that this
project may need to be ported to a non-gcc compiler.

Here are the major coding style highlights for this project:

1) Indentation is four spaces.  Please do not use tab and do not use more
   or less than 4 spaces.  A lot of the source files have vim control
   settings at the bottom so if you are using vim, the indentation will
   automatically be set up properly with the Tab key.  However, if you are
   unlucky and do not have vim, just make sure you use 4 spaces for indent.
   Editor hints will be accepted for other editors, so long as the additions
   to the source files are minimal (i.e., we're not looking for editor
   configuration files).

Examples:

GOOD:
       int main(int argc, char **argv) {
           int i;
           i = EXIT_SUCCESS;

if (i == -1) {
               return EXIT_FAILURE;
           }

return i;
       }

2) Spaces after keywords.  Do not place an open paren next to 'if' or 'for'.
   Examples:

GOOD:

if (i < j) {
       for (i=0; i < 30; i++) {

BAD:

if(i < j) {
       for(i=0; i < 30; i++) {

3) Open brace stays on the same line for the function declaration or
   statement it belongs to.  Examples:

GOOD:

if (i < j ) {

BAD:

if (i < j)
       {

4) No brace-less blocks.  If an 'if' test just requires one statement in
   the block, do still wrap it in braces.  This is to maintain consistency
   with all blocks in the code.  Examples:

GOOD:

if (i < j) {
           printf("i is less than j!\n");
       }

BAD:

if (i < j)
           printf("i is less than j!\n");

5) No K&R style function declarations.  Examples:

GOOD:

int main(int argc, char **argv) {

BAD:

int main(argc, argv)
           int argc;
           char **argv;
       {

6) Let expressions breathe.  There's no reason to remove all spaces from
   a complex expression.  Examples:

GOOD:

i = (a + b) << c >> d | e * f;

BAD:

i = (a+b)<<c>>d|e*f;

7) Function declarations have the return type on the same line as the
   function.  For long argument lists, wrap them to line up with the
   parens.  There is no space between the function name and the open
   paren.  Examples:

GOOD:

int main(int argc, char **argv) {

void check_a_variable(int a, char b, int c, struct astruct,
                             int *d, char *e, void *buf) {

BAD:

int
       main (int argc, char **argv)
       {

8) Name variables and functions using lowercase names and underscores rather
   than CamelCase.  Examples:

GOOD:

int c;
       char *host_name = NULL;
       void function_name(int argument);

BAD:

int counterForCountingThings;
       char *hostName = NULL;
       void functionName(int argument);

CODING STYLE FOR PYTHON

First, read PEP-8:  http://www.python.org/dev/peps/pep-0008/

Second, please follow the coding style you see in the Python source files here.
Here are the major coding style highlights for this project:

1) 4-space indentation.  Do not use tabs in Python code.

2) Use CamelCase for class names.

3) For method names, the standard CamelCase naming with the first
   character being lowercase is preferred.

4) Use properties instead of get/set methods.

5) Use _ to prefix class variables accessed via properties.

6) Hide anything with __ prefixes if it does not need to be fully public.

7) List one module per import statement.  Do not use a comma to list several
   modules on one import line.

GENERATING PATCHES

When you make changes to the code, you should generate a patch to send
upstream.  Before editing, it's a good idea to copy the original source
file to a new name so you can edit the other copy.  Here is a basic
workflow:

$ cd pyparted-VERSION/src
    $ cp -p _pedmodule.c _pedmodule.c.orig
    $ vim _pedmodule.c                     # make your changes

Generating a patch is done using GNU diffutils or a diff(1) command
capable of producing a unified diff:

$ diff -u _pedmodule.c.orig _pedmodule.c > mypatch

Submit the 'mypatch' file and explain your changes and why we should merge
your changes.

If you are making a lot of changes to many files, it's probably easier to
use the git version control system.  You can clone the upstream repository
and commit your changes locally and then generate a set of diffs against
the latest upstream code.

$ git clone https://github.com/rhinstaller/pyparted.git
    $ cd pyparted
    $ # make your changes to files here
    $ git add FILE           # repeat this add/commit process for
    $ git commit             # each logical change to the code
    $ git fetch
    $ git rebase origin
    $ git format-patch origin

The output of git format-patch will be a set of files containing a patch
for each add/commit you made locally.  The patches will be made against
the latest upstream.  Submit your patch files upstream.

SUBMITTING PATCHES

The best way to submit patches is to fork the repo on github and send a pull
request with your changes:

https://github.com/rhinstaller/pyparted

Attach your patch and explanation and it'll be reviewed.  There may be some
back and forth as your patch is reviewed and considered for inclusion.

Alternatively, you can email the project maintainer(s) directly.  The git log
and AUTHORS file contain email addresses of those who work on pyparted.
07070100115867000081A40000FFFE0000FFFD0000000157CD697A00000B45000000FC0000001000000000000000000000002300000000pyparted-1466619794.7a0f829/READMEpyparted
Python bindings for libparted
-----------------------------

OVERVIEW

pyparted is a set of native Python bindings for libparted.  libparted is the
library portion of the GNU parted project.  With pyparted, you can write
applications that interact with disk partition tables and filesystems.

The Python bindings are implemented in two layers.  Since libparted itself
is written in C without any real implementation of objects, a simple 1:1
mapping of externally accessible libparted functions was written.  This
mapping is provided in the _ped Python module.  You can use that module if
you want to, but it's really just meant for the larger parted module.

_ped       libparted Python bindings, direct 1:1: function mapping
    parted     Native Python code building on _ped, complete with classes,
               exceptions, and advanced functionality.

The _ped module is written and maintained by hand.  I chose to do this
rather than rely on a tool like SWIG or Pyrex for several reasons.  Mostly
because I was the GNU parted maintainer, but also because libparted is sort
of complex.  It's a lowlevel system tool and I found it doesn't translate
well in the tools I tried.  This is nothing against those tools, I just
don't think libparted is ideal to go through SWIG or Pyrex.  By writing my
own bindings, I can also find bugs in libparted that I may have overlooked
before.  See the WHY file for more explanation as to why I wrote the
bindings by hand.

HISTORY

pyparted started life at Red Hat and continues there today.  The main reason
for writing it was to let anaconda (the Red Hat installation program, now
used by RHEL and Fedora and many other distributions) interact with
libparted.  Anaconda is written in Python, so native bindings made sense.

pyparted went through many rewrites, but the end result was always the same.
And incomplete API via Python with just enough provided for anaconda to do
its job.

The latest iteration of pyparted aims to be a complete API mapping and even
provide a nice set of classes so that people might want to integrate it in
to other installers or even write other applications (maybe a Python based
alternative to parted(8) or fdisk(8)).

EXAMPLES

Example code is provided in the examples directory.  These may help provide a
gentle introduction to the usage concepts of pyparted.  More examples are always
welcome, as are improved explanatory commentary for those that exist.

QUESTIONS

If you are reporting a pyparted failure in Fedora, it's most useful if
you file a bug at http://bugzilla.redhat.com/ against the appropriate
Fedora release you are using.

Alternatively, you can file bugs directly on the project page:
http://fedorahosted.org/pyparted/

If you just have questions about pyparted, you can email us directly
using the contact information in the AUTHORS file.  We will do our best
to help you.
07070100115888000081A40000FFFE0000FFFD0000000157CD697A00000CAD000000FC0000001000000000000000000000002500000000pyparted-1466619794.7a0f829/Makefile#
# Makefile for pyparted
# Copyright (C) 2007-2015  Red Hat, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty 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., 675 Mass Ave, Cambridge, MA 02139, USA.
#
# Author(s): David Cantrell <dcantrell@redhat.com>
#

PYTHON       ?= python

DESTDIR      ?= /

PACKAGE       = $(shell $(PYTHON) setup.py --name)
VERSION       = $(shell $(PYTHON) setup.py --version)

TAG           = v$(VERSION)

COVERAGE=coverage
ifeq ($(PYTHON),python3)
COVERAGE=coverage3
endif

default: all

all:
	@$(PYTHON) setup.py build

test: all
	@env PYTHONPATH=$$(find $$(pwd) -name "*.so" | head -n 1 | xargs dirname):src/parted:src \
	$(PYTHON) -m unittest discover -v

coverage: all
	@echo "*** Running unittests with $(COVERAGE) for $(PYTHON) ***"
	@env PYTHONPATH=$$(find $$(pwd) -name "*.so" | head -n 1 | xargs dirname):src/parted:src \
	$(COVERAGE) run --branch -m unittest discover -v
	$(COVERAGE) report --include="build/lib.*/parted/*" --show-missing
	$(COVERAGE) report --include="build/lib.*/parted/*" > coverage-report.log

check: clean
	env PYTHON=python3 $(MAKE) ; \
	env PYTHON=python3 PYTHONPATH=$$(find $$(pwd) -name "*.so" | head -n 1 | xargs dirname):src/parted:src \
	tests/pylint/runpylint.py

dist:
	@$(PYTHON) setup.py sdist

tag: dist
	@if [ -z "$(GPGKEY)" ]; then \
		echo "GPGKEY environment variable missing, please set this to the key ID" ; \
		echo "you want to use to tag the repository." ; \
		exit 1 ; \
	fi
	@git tag -u $(GPGKEY) -m "Tag as $(TAG)" -f $(TAG)
	@echo "Tagged as $(TAG) (GPG signed)"

release: tag
	( cd dist ; gzip -dc $(PACKAGE)-$(VERSION).tar.gz | tar -xvf - )
	( cd dist/$(PACKAGE)-$(VERSION) && $(PYTHON) setup.py build ) || exit 1
	rm -rf dist MANIFEST
	@echo
	@echo "$(PACKAGE)-$(VERSION) can be pushed to the git repo:"
	@echo "    git push && git push --tags"
	@echo

rpmlog:
	@prevtag="$$(git tag -l | grep -v "^start$$" | tail -n 2 | head -n 1)" ; \
	git log --pretty="format:- %s (%ae)" $${prevtag}.. | \
	sed -e 's/@.*)/)/' | \
	sed -e 's/%/%%/g' | \
	grep -v "New version" | \
	fold -s -w 77 | \
	while read line ; do \
		if [ ! "$$(echo $$line | cut -c-2)" = "- " ]; then \
			echo "  $$line" ; \
		else \
			echo "$$line" ; \
		fi ; \
	done

bumpver:
	@OLDSUBVER=$$(echo $(VERSION) | rev | cut -d '.' -f 1 | rev) ; \
	NEWSUBVER=$$(($${OLDSUBVER} + 1)) ; \
	BASEVER="$$(echo $(VERSION) | sed -e "s|\.$${OLDSUBVER}$$||g")" ; \
	NEWVERSION="$${BASEVER}.$${NEWSUBVER}" ; \
	sed -i "s/pyparted_version = '$(VERSION)'/pyparted_version = '$${NEWVERSION}'/" setup.py ; \
	echo "New version is $${NEWVERSION}"

install: all
	@$(PYTHON) setup.py install --root $(DESTDIR) -c -O1

clean:
	-rm -r build

ci: check coverage
070701001158A2000081A40000FFFE0000FFFD0000000157CD697A0000463E000000FC0000001000000000000000000000002400000000pyparted-1466619794.7a0f829/COPYING		    GNU GENERAL PUBLIC LICENSE
		       Version 2, June 1991

Copyright (C) 1989, 1991 Free Software Foundation, Inc.
                          675 Mass Ave, Cambridge, MA 02139, USA
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

Preamble

The licenses for most software are designed to take away your
freedom to share and change it.  By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users.  This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it.  (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.)  You can apply it to
your programs, too.

When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.

To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.

For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have.  You must make sure that they, too, receive or can get the
source code.  And you must show them these terms so they know their
rights.

We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.

Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software.  If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.

Finally, any free program is threatened constantly by software
patents.  We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary.  To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.

The precise terms and conditions for copying, distribution and
modification follow.

GNU GENERAL PUBLIC LICENSE
   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License.  The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language.  (Hereinafter, translation is included without limitation in
the term "modification".)  Each licensee is addressed as "you".

Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope.  The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.

1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.

You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.

2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:

a) You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.

b) You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.

c) If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based on
    the Program is not required to print an announcement.)

These requirements apply to the modified work as a whole.  If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works.  But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.

Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.

In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.

3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:

a) Accompany it with the complete corresponding machine-readable
    source code, which must be distributed under the terms of Sections
    1 and 2 above on a medium customarily used for software interchange; or,

b) Accompany it with a written offer, valid for at least three
    years, to give any third party, for a charge no more than your
    cost of physically performing source distribution, a complete
    machine-readable copy of the corresponding source code, to be
    distributed under the terms of Sections 1 and 2 above on a medium
    customarily used for software interchange; or,

c) Accompany it with the information you received as to the offer
    to distribute corresponding source code.  (This alternative is
    allowed only for noncommercial distribution and only if you
    received the program in object code or executable form with such
    an offer, in accord with Subsection b above.)

The source code for a work means the preferred form of the work for
making modifications to it.  For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable.  However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.

If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.

4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License.  Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.

5. You are not required to accept this License, since you have not
signed it.  However, nothing else grants you permission to modify or
distribute the Program or its derivative works.  These actions are
prohibited by law if you do not accept this License.  Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.

6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions.  You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.

7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all.  For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.

If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.

It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices.  Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.

This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.

8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded.  In such case, this License incorporates
the limitation as if written in the body of this License.

9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time.  Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.

Each version is given a distinguishing version number.  If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation.  If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.

10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission.  For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this.  Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.

NO WARRANTY

11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.

12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.

END OF TERMS AND CONDITIONS

Appendix: How to Apply These Terms to Your New Programs

If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.

To do so, attach the following notices to the program.  It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.

<one line to give the program's name and a brief idea of what it does.>
    Copyright (C) 19yy  <name of author>

This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty 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., 675 Mass Ave, Cambridge, MA 02139, USA.

Also add information on how to contact you by electronic and paper mail.

If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:

Gnomovision version 69, Copyright (C) 19yy name of author
    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.

The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License.  Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.

You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary.  Here is a sample; alter the names:

Yoyodyne, Inc., hereby disclaims all copyright interest in the program
  `Gnomovision' (which makes passes at compilers) written by James Hacker.

<signature of Ty Coon>, 1 April 1989
  Ty Coon, President of Vice

This General Public License does not permit incorporating your program into
proprietary programs.  If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library.  If this is what you want to do, use the GNU Library General
Public License instead of this License.
07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!

Places

File _service:obs_scm:pyparted-1466619794.7a0f829.obscpio of Package python3-pyparted

Places