golden hour

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

File/Folder	Size	Actions
Errors.py	4.26 KB
Errors.pyc	9.08 KB
__init__.py	304.17 KB
__init__.pyc	199.58 KB
callbacks.py	5.64 KB
callbacks.pyc	6.23 KB
comps.py	31.59 KB
comps.pyc	26.87 KB
config.py	49.89 KB
config.pyc	48.02 KB
constants.py	4.94 KB
constants.pyc	3.46 KB
depsolve.py	74.05 KB
depsolve.pyc	46.75 KB
drpm.py	12.65 KB
drpm.pyc	10.69 KB
failover.py	5 KB
failover.pyc	5.24 KB
fssnapshots.py	10.16 KB
fssnapshots.pyc	9.75 KB
history.py	61.13 KB
history.pyc	53.31 KB
i18n.py	20.44 KB
i18n.pyc	16.05 KB
igroups.py	9.31 KB
igroups.pyc	10.22 KB
logginglevels.py	7.9 KB
logginglevels.pyc	6.51 KB
mdparser.py	6.26 KB
mdparser.pyc	7.58 KB
metalink.py	9.19 KB
metalink.pyc	8.84 KB
misc.py	39.57 KB
misc.pyc	39.58 KB
packageSack.py	40.79 KB
packageSack.pyc	41.88 KB
packages.py	84.1 KB
packages.pyc	84.51 KB
parser.py	7.97 KB
parser.pyc	6.5 KB
pgpmsg.py	53.5 KB
pgpmsg.pyc	38.27 KB
pkgtag_db.py	4.86 KB
pkgtag_db.pyc	5.06 KB
plugins.py	28.1 KB
plugins.pyc	29.1 KB
repoMDObject.py	11.23 KB
repoMDObject.pyc	9.17 KB
repos.py	16.53 KB
repos.pyc	17.38 KB
rpmsack.py	70.25 KB
rpmsack.pyc	58.36 KB
rpmtrans.py	24.84 KB
rpmtrans.pyc	22.54 KB
sqlitesack.py	69.76 KB
sqlitesack.pyc	53.75 KB
sqlutils.py	6.27 KB
sqlutils.pyc	5.6 KB
transactioninfo.py	33.78 KB
transactioninfo.pyc	30.29 KB
update_md.py	25.9 KB
update_md.pyc	21.72 KB
updateinfo.py	18.29 KB
updateinfo.pyc	16.36 KB
yumRepo.py	83.85 KB
yumRepo.pyc	64.83 KB

Edit: plugins.py

#! /usr/bin/python -tt
# 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 Library 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
# Copyright 2005 Duke University

import os
import glob
import imp
import warnings
import atexit
import gettext
import logging
import logginglevels
from constants import *
import config 
from config import ParsingError, ConfigParser
import Errors
from parser import ConfigPreProcessor

from textwrap import fill
import fnmatch

from weakref import proxy as weakref

from yum import _

from yum.i18n import utf8_width

# TODO: expose rpm package sack objects to plugins (once finished)
# TODO: allow plugins to use the existing config stuff to define options for
# their own configuration files (would replace confString() etc).
# TODO: expose progress bar interface
# TODO "log" slot? To allow plugins to do customised logging/history (say to a
# SQL db)
# TODO: consistent case of YumPlugins methods
# TODO: allow plugins to extend shell commands
# TODO: allow plugins to define new repository types
# TODO: More developer docs:  use epydoc as API begins to stablise

# The API_VERSION constant defines the current plugin API version. It is used
# to decided whether or not plugins can be loaded. It is compared against the
# 'requires_api_version' attribute of each plugin. The version number has the
# format: "major_version.minor_version".
# 
# For a plugin to be loaded the major version required by the plugin must match
# the major version in API_VERSION. Additionally, the minor version in
# API_VERSION must be greater than or equal the minor version required by the
# plugin.
# 
# If a change to yum is made that break backwards compatibility wrt the plugin
# API, the major version number must be incremented and the minor version number
# reset to 0. If a change is made that doesn't break backwards compatibility,
# then the minor number must be incremented.
API_VERSION = '2.7'

class DeprecatedInt(int):
    """A simple int subclass that is used to check when a deprecated
    constant is used.
    """

# Plugin types
TYPE_CORE = 0
TYPE_INTERACTIVE = 1
TYPE_INTERFACE = DeprecatedInt(1)
ALL_TYPES = (TYPE_CORE, TYPE_INTERACTIVE)

# Mapping of slots to conduit classes
SLOT_TO_CONDUIT = {
    'config': 'ConfigPluginConduit',
    'postconfig': 'PostConfigPluginConduit',
    'init': 'InitPluginConduit',
    'args': 'ArgsPluginConduit',
    'predownload': 'DownloadPluginConduit',
    'postdownload': 'DownloadPluginConduit',
    'prelistenabledrepos': 'PreRepoSetupPluginConduit',
    'prereposetup': 'PreRepoSetupPluginConduit',
    'postreposetup': 'PostRepoSetupPluginConduit',
    'close': 'PluginConduit',
    'clean': 'PluginConduit',
    'pretrans': 'MainPluginConduit',
    'posttrans': 'MainPluginConduit',
    'preverifytrans': 'MainPluginConduit',
    'postverifytrans': 'MainPluginConduit',
    'exclude': 'MainPluginConduit',
    'preresolve': 'DepsolvePluginConduit',
    'postresolve': 'DepsolvePluginConduit',
    'historybegin': 'HistoryPluginConduit',
    'historyend': 'HistoryPluginConduit',
    'compare_providers': 'CompareProvidersPluginConduit',
    'verify_package': 'VerifyPluginConduit',
    }

# Enumerate all slot names
SLOTS = sorted(SLOT_TO_CONDUIT.keys())

class PluginYumExit(Exception):
    """Exception that can be raised by plugins to signal that yum should stop."""

def __init__(self, value="", translation_domain=""):
        self.value = value
        self.translation_domain = translation_domain
    def __str__(self):
        if self.translation_domain:
            return gettext.dgettext(self.translation_domain, self.value)
        else:
            return self.value
    
class YumPlugins:
    """Manager class for Yum plugins."""

def __init__(self, base, searchpath, optparser=None, types=None, 
            pluginconfpath=None,disabled=None,enabled=None):
        '''Initialise the instance.

@param base: The
        @param searchpath: A list of paths to look for plugin modules.
        @param optparser: The OptionParser instance for this run (optional).
            Use to allow plugins to extend command line options.
        @param types: A sequence specifying the types of plugins to load.
            This should be sequnce containing one or more of the TYPE_...
            constants. If None (the default), all plugins will be loaded.
        @param pluginconfpath: A list of paths to look for plugin configuration
            files. Defaults to "/etc/yum/pluginconf.d".
        '''
        if not pluginconfpath:
            pluginconfpath = ['/etc/yum/pluginconf.d']

self.searchpath = searchpath
        self.pluginconfpath = pluginconfpath
        self.base = weakref(base)
        self.optparser = optparser
        self.cmdline = (None, None)
        self.verbose_logger = logging.getLogger("yum.verbose.YumPlugins")
        self.disabledPlugins = disabled
        self.enabledPlugins  = enabled
        if types is None:
            types = ALL_TYPES
        if not isinstance(types, (list, tuple)):
            types = (types,)

if id(TYPE_INTERFACE) in [id(t) for t in types]:
            self.verbose_logger.log(logginglevels.INFO_2,
                    'Deprecated constant TYPE_INTERFACE during plugin '
                    'initialization.\nPlease use TYPE_INTERACTIVE instead.')

self._importplugins(types)

self.cmdlines = {}

# Call close handlers when yum exit's
        atexit.register(self.run, 'close')

# Let plugins register custom config file options
        self.run('config')

def run(self, slotname, **kwargs):
        """Run all plugin functions for the given slot.

:param slotname: a string representing the name of the slot to
           run the plugins for
        :param kwargs: keyword arguments that will be simply passed on
           to the plugins
        """
        # Determine handler class to use
        conduitcls = SLOT_TO_CONDUIT.get(slotname, None)
        if conduitcls is None:
            raise ValueError('unknown slot name "%s"' % slotname)
        conduitcls = eval(conduitcls)       # Convert name to class object

for modname, func in self._pluginfuncs[slotname]:
            self.verbose_logger.log(logginglevels.DEBUG_4,
                                    'Running "%s" handler for "%s" plugin',
                                    slotname, modname)
    
            _, conf = self._plugins[modname]
            func(conduitcls(self, self.base, conf, **kwargs))

def _importplugins(self, types):
        '''Load plugins matching the given types.
        '''

# Initialise plugin dict
        self._plugins = {}
        self._pluginfuncs = {}
        for slot in SLOTS:
            self._pluginfuncs[slot] = []

# Import plugins 
        self._used_disable_plugin = set()
        self._used_enable_plugin  = set()
        for dir in self.searchpath:
            if not os.path.isdir(dir):
                continue
            for modulefile in sorted(glob.glob('%s/*.py' % dir)):
                self._loadplugin(modulefile, types)

# If we are in verbose mode we get the full 'Loading "blah" plugin' lines
        if (self._plugins and
            not self.verbose_logger.isEnabledFor(logginglevels.DEBUG_3)):
            # Mostly copied from YumOutput._outKeyValFill()
            key = _("Loaded plugins: ")
            val = ", ".join(sorted(self._plugins))
            nxt = ' ' * (utf8_width(key) - 2) + ': '
            width = 80
            if hasattr(self.base, 'term'):
                width = self.base.term.columns
            self.verbose_logger.log(logginglevels.INFO_2,
                                    fill(val, width=width, initial_indent=key,
                                         subsequent_indent=nxt))

if self.disabledPlugins:
            for wc in self.disabledPlugins:
                if wc not in self._used_disable_plugin:
                    self.verbose_logger.log(logginglevels.INFO_2,
                                            _("No plugin match for: %s") % wc)
        del self._used_disable_plugin
        if self.enabledPlugins:
            for wc in self.enabledPlugins:
                if wc not in self._used_enable_plugin:
                    self.verbose_logger.log(logginglevels.INFO_2,
                                            _("No plugin match for: %s") % wc)
        del self._used_enable_plugin

@staticmethod
    def _plugin_cmdline_match(modname, plugins, used):
        """ Check if this plugin has been temporary enabled/disabled. """
        if plugins is None:
            return False

for wc in plugins:
            if fnmatch.fnmatch(modname, wc):
                used.add(wc)
                return True

return False

def _loadplugin(self, modulefile, types):
        '''Attempt to import a plugin module and register the hook methods it
        uses.
        '''
        dir, modname = os.path.split(modulefile)
        modname = modname.split('.py')[0]

#  This should really work like enable/disable repo. and be based on the
        # cmd line order ... but the API doesn't really allow that easily.
        # FIXME: Fix for 4.* (lol)
        # Do disabled cmd line checks before loading the module code.
        if (self._plugin_cmdline_match(modname, self.disabledPlugins,
                                       self._used_disable_plugin) and
            not self._plugin_cmdline_match(modname, self.enabledPlugins,
                                           self._used_enable_plugin)):
            return

conf = self._getpluginconf(modname)
        if (not conf or
            (not config.getOption(conf, 'main', 'enabled',
                                  config.BoolOption(False)) and
             not self._plugin_cmdline_match(modname, self.enabledPlugins,
                                            self._used_enable_plugin))):
            self.verbose_logger.debug(_('Not loading "%s" plugin, as it is disabled'), modname)
            return

try:
            fp, pathname, description = imp.find_module(modname, [dir])
            try:
                module = imp.load_module(modname, fp, pathname, description)
            finally:
                fp.close()
        except:
            if self.verbose_logger.isEnabledFor(logginglevels.DEBUG_4):
                raise # Give full backtrace:
            self.verbose_logger.error(_('Plugin "%s" can\'t be imported') %
                                      modname)
            return

# Check API version required by the plugin
        if not hasattr(module, 'requires_api_version'):
            self.verbose_logger.error(
                _('Plugin "%s" doesn\'t specify required API version') %
                modname)
            return
        if not apiverok(API_VERSION, module.requires_api_version):
            self.verbose_logger.error(
                _('Plugin "%s" requires API %s. Supported API is %s.') % (
                    modname,
                    module.requires_api_version,
                    API_VERSION,
                    ))
            return

# Check plugin type against filter
        plugintypes = getattr(module, 'plugin_type', ALL_TYPES)
        if not isinstance(plugintypes, (list, tuple)):
            plugintypes = (plugintypes,)

if len(plugintypes) < 1:
            return
        for plugintype in plugintypes:
            if id(plugintype) == id(TYPE_INTERFACE):
                self.verbose_logger.log(logginglevels.INFO_2,
                        'Plugin "%s" uses deprecated constant '
                        'TYPE_INTERFACE.\nPlease use TYPE_INTERACTIVE '
                        'instead.', modname)

if plugintype not in types:
                return

self.verbose_logger.log(logginglevels.DEBUG_3, _('Loading "%s" plugin'),
                                modname)

# Store the plugin module and its configuration file
        if modname not in self._plugins:
            self._plugins[modname] = (module, conf)
        else:
            raise Errors.ConfigError(_('Two or more plugins with the name "%s" ' \
                    'exist in the plugin search path') % modname)
        
        for slot in SLOTS:
            funcname = slot+'_hook'
            if hasattr(module, funcname):
                self._pluginfuncs[slot].append(
                        (modname, getattr(module, funcname))
                        )

def _getpluginconf(self, modname):
        '''Parse the plugin specific configuration file and return a
        IncludingConfigParser instance representing it. Returns None if there
        was an error reading or parsing the configuration file.
        '''
        for dir in self.pluginconfpath:
            conffilename = os.path.join(dir, modname + ".conf")
            if os.access(conffilename, os.R_OK):
                # Found configuration file
                break
            self.verbose_logger.log(logginglevels.INFO_2, _("Configuration file %s not found") % conffilename)
        else: # for
            # Configuration files for the plugin not found
            self.verbose_logger.log(logginglevels.INFO_2, _("Unable to find configuration file for plugin %s")
                % modname)
            return None
        parser = ConfigParser()
        confpp_obj = ConfigPreProcessor(conffilename)
        try:
            parser.readfp(confpp_obj)
        except ParsingError, e:
            raise Errors.ConfigError("Couldn't parse %s: %s" % (conffilename,
                str(e)))
        return parser

def setCmdLine(self, opts, commands):
        """Set the parsed command line options so that plugins can
        access them.

:param opts: a dictionary containing the values of the command
           line options
        :param commands: a list of command line arguments passed to yum
        """
        self.cmdline = (opts, commands)

class DummyYumPlugins:
    """This class provides basic emulation of the :class:`YumPlugins`
    class. It exists so that calls to plugins.run() don't fail if
    plugins aren't in use.
    """
    def run(self, *args, **kwargs):
        """Do nothing.  All arguments are unused."""

pass

def setCmdLine(self, *args, **kwargs):
        """Do nothing.  All arguments are unused."""

pass

class PluginConduit:
    """A conduit class to transfer information between yum and the
    plugin.
    """
    def __init__(self, parent, base, conf):
        self._parent = parent
        self._base = base
        self._conf = conf

self.logger = logging.getLogger("yum.plugin")
        self.verbose_logger = logging.getLogger("yum.verbose.plugin")

def info(self, level, msg):
        """Send an info message to the logger.

:param level: the level of the message to send
        :param msg: the message to send
        """
        converted_level = logginglevels.logLevelFromDebugLevel(level)
        self.verbose_logger.log(converted_level, msg)

def error(self, level, msg):
        """Send an error message to the logger.

:param level: the level of the message to send
        :param msg: the message to send
        """
        converted_level = logginglevels.logLevelFromErrorLevel(level)
        self.logger.log(converted_level, msg)

def promptYN(self, msg, prompt=None):
        """Return a yes or no response, either from assumeyes already
        being set, or from prompting the user.

:param msg: the message to show to the user
        :param prompt: the question to ask the user (optional); defaults to 'Is this ok [y/N]: '
        :return: 1 if the response is yes, and 0 if the response is no
        """
        self.info(2, msg)
        if self._base.conf.assumeno:
            return False
        if self._base.conf.assumeyes:
            return True
        else:
            kwargs = {'prompt': prompt} if prompt else {}
            return bool(self._base.userconfirm(**kwargs))

def getYumVersion(self):
        """Return a string representing the current version of yum."""

import yum
        return yum.__version__

def getOptParser(self):
        """Return the :class:`optparse.OptionParser` instance for this
        execution of Yum.  In the "config" and "init" slots a plugin
        may add extra options to this instance to extend the command
        line options that Yum exposes.  In all other slots a plugin
        may only read the :class:`OptionParser` instance.  Any
        modification of the instance at this point will have no
        effect.  See the
        :func:`PreRepoSetupPluginConduit.getCmdLine` method for
        details on how to retrieve the parsed values of command line
        options.

:return: the global :class:`optparse.OptionParser` instance used by
           Yum. May be None if an OptionParser isn't in use
        """
        # ' xemacs highlighting hack
        # This isn't API compatible :(
        # return self._parent.optparser.plugin_option_group
        return self._parent.optparser

def confString(self, section, opt, default=None):
        """Read a string value from the plugin's own configuration file.

:param section: configuration file section to read
        :param opt: option name to read
        :param default: value to read if the option is missing
        :return: string option value read, or default if option was missing
        """
        # ' xemacs highlighting hack
        return config.getOption(self._conf, section, opt, config.Option(default))

def confInt(self, section, opt, default=None):
        """Read an integer value from the plugin's own configuration file.

:param section: configuration file section to read
        :param opt: option name to read
        :param default: value to read if the option is missing

:return: the integer option value read, or *default* if the
            option was missing or could not be parsed
        """
        return config.getOption(self._conf, section, opt, config.IntOption(default))

def confFloat(self, section, opt, default=None):
        """Read a float value from the plugin's own configuration file.

:param section: configuration file section to read
        :param opt: option name to read
        :param default: value to read if the option is missing
        :return: float option value read, or *default* if the option was
            missing or could not be parsed
        """
        return config.getOption(self._conf, section, opt, config.FloatOption(default))

def confBool(self, section, opt, default=None):
        """Read a boolean value from the plugin's own configuration file

:param section: configuration file section to read
        :param opt: option name to read
        :param default: value to read if the option is missing
        :return: boolean option value read, or *default* if the option
            was missing or could not be parsed
        """
        return config.getOption(self._conf, section, opt, config.BoolOption(default))

def confList(self, section, opt, default=None):
        """Read a boolean value from the plugin's own configuration file

def registerPackageName(self, name):
        """Register the name of a package to use.

:param name: the name of the package to register
        """
        self._base.run_with_package_names.add(name)

class ConfigPluginConduit(PluginConduit):
    """A conduit for use in the config slot."""

def registerOpt(self, name, valuetype, where, default):
        """Deprecated.  Register a yum configuration file option.

:param name: name of the new option
        :param valuetype: option type (PLUG_OPT_BOOL, PLUG_OPT_STRING, etc.)
        :param where: where the option should be available in the config file
            (PLUG_OPT_WHERE_MAIN, PLUG_OPT_WHERE_REPO, etc)
        :param default: default value for the option if it is not set by the user
        """
        warnings.warn('registerOpt() will go away in a future version of Yum.\n'
                'Please manipulate config.YumConf and config.RepoConf directly.',
                DeprecationWarning)

type2opt =  {
            PLUG_OPT_STRING: config.Option,
            PLUG_OPT_INT: config.IntOption,
            PLUG_OPT_BOOL: config.BoolOption,
            PLUG_OPT_FLOAT: config.FloatOption,
            }

if where == PLUG_OPT_WHERE_MAIN:
            setattr(config.YumConf, name, type2opt[valuetype](default))

elif where == PLUG_OPT_WHERE_REPO:
            setattr(config.RepoConf, name, type2opt[valuetype](default))

elif where == PLUG_OPT_WHERE_ALL:
            option = type2opt[valuetype](default)
            setattr(config.YumConf, name, option)
            setattr(config.RepoConf, name, config.Inherit(option))

def registerCommand(self, command):
        """Register a new command.

:param command: the command to register
        :raises: :class:`yum.Errors.ConfigError` if the registration
           of commands is not supported
        """
        if hasattr(self._base, 'registerCommand'):
            self._base.registerCommand(command)
        else:
            raise Errors.ConfigError(_('registration of commands not supported'))

class PostConfigPluginConduit(ConfigPluginConduit):
    """Conduit for use in the postconfig slot."""

def getConf(self):
        """Return a dictionary containing the values of the
        configuration options.

:return: a dictionary containing the values of the
           configuration options
        """
        return self._base.conf

class InitPluginConduit(PluginConduit):
    """Conduit for use in the init slot."""

def getConf(self):
        """Return a dictionary containing the values of the
        configuration options.

:return: a dictionary containing the values of the
           configuration options
        """
        return self._base.conf

def getRepos(self):
        """Return Yum's container object for all configured repositories.

:return: Yum's :class:`yum.repos.RepoStorage` instance
        """
        return self._base.repos

class ArgsPluginConduit(InitPluginConduit):
    """Conduit for dealing with command line arguments."""

def __init__(self, parent, base, conf, args):
        InitPluginConduit.__init__(self, parent, base, conf)
        self._args = args

def getArgs(self):
        """Return a list of the command line arguments passed to yum.

:return: a list of the command line arguments passed to yum
        """
        return self._args

class PreRepoSetupPluginConduit(InitPluginConduit):
    """Conduit for use in the prererosetup slot."""

def getCmdLine(self):
        """Return parsed command line options.

:return: (options, commands) as returned by :class:`OptionParser.parse_args()`
        """
        return self._parent.cmdline

def getRpmDB(self):
        """Return a representation of the local RPM database. This
        allows querying of installed packages.

:return: a :class:`yum.rpmUtils.RpmDBHolder` instance
        """
        return self._base.rpmdb

class PostRepoSetupPluginConduit(PreRepoSetupPluginConduit):
    """Conduit for use in the postreposetup slot."""

def getGroups(self):
        """Return group information.

:return: :class:`yum.comps.Comps` instance
        """
        return self._base.comps

class DownloadPluginConduit(PostRepoSetupPluginConduit):
    """Conduit for use in the download slots."""

def __init__(self, parent, base, conf, pkglist, errors=None):
        PostRepoSetupPluginConduit.__init__(self, parent, base, conf)
        self._pkglist = pkglist
        self._errors = errors

def getDownloadPackages(self):
        """Return a list of package objects representing packages to be
        downloaded.

:return: a list of package object representing packages to be
           downloaded
        """
        return self._pkglist

def getErrors(self):
        """Return a dictionary of download errors. 
        
        :return: a dictionary of download errors. This dictionary is
           indexed by package object. Each element is a list of
           strings describing the error
        """
        if not self._errors:
            return {}
        return self._errors

class MainPluginConduit(PostRepoSetupPluginConduit):
    """Main conduit class for plugins.  Many other conduit classes
    will inherit from this class.
    """
    def getPackages(self, repo=None):
        """Return a list of packages.

:param repo: the repo to return a packages from
        :return: a list of package objects
        """
        if repo:
            arg = repo.id
        else:
            arg = None
        return self._base.pkgSack.returnPackages(arg)

def getPackageByNevra(self, nevra):
        """Retrieve a package object from the packages loaded by Yum using
        nevra information.
        
        :param nevra: a tuple holding (name, epoch, version, release, arch)
            for a package
        :return: a :class:`yum.packages.PackageObject` instance (or subclass)
        """
        return self._base.getPackageObject(nevra)

def delPackage(self, po):
        """Delete the given package from the package sack.

:param po: the package object to delete
        """
        po.repo.sack.delPackage(po)

def getTsInfo(self):
        """Return transaction set.

:return: the transaction set
        """
        return self._base.tsInfo

class DepsolvePluginConduit(MainPluginConduit):
    """Conduit for use in solving dependencies."""

def __init__(self, parent, base, conf, rescode=None, restring=[]):
        MainPluginConduit.__init__(self, parent, base, conf)
        self.resultcode = rescode
        self.resultstring = restring

@property
    def missing_requires(self):
        """Boolean indicating if depsolving failed due to missing dependencies."""
        return self._base._missing_requires

def pretty_output_restring(self):
        return '\n'.join(prefix % msg for prefix, msg in self._base.pretty_output_restring(self.resultstring))

class CompareProvidersPluginConduit(MainPluginConduit):
    """Conduit to compare different providers of packages."""

def __init__(self, parent, base, conf, providers_dict={}, reqpo=None):
        MainPluginConduit.__init__(self, parent, base, conf)
        self.packages = providers_dict
        self.reqpo = reqpo

class HistoryPluginConduit(MainPluginConduit):
    """Conduit to access information about the yum history."""

def __init__(self, parent, base, conf, rescode=None, restring=[]):
        MainPluginConduit.__init__(self, parent, base, conf)
        self.history = self._base.history

class VerifyPluginConduit(MainPluginConduit):
    """Conduit to verify packages."""

def __init__(self, parent, base, conf, verify_package):
        MainPluginConduit.__init__(self, parent, base, conf)
        self.verify_package = verify_package

def parsever(apiver):
    """Parse a string representing an api version.

:param apiver: a string representing an api version
    :return: a tuple containing the major and minor version numbers
    """
    maj, min = apiver.split('.')
    return int(maj), int(min)

def apiverok(a, b):
    """Return true if API version "a" supports API version "b"

:param a: a string representing an api version
    :param b: a string representing an api version

:return: whether version *a* supports version *b*
    """
    a = parsever(a)
    b = parsever(b)

if a[0] != b[0]:
        return 0

if a[1] >= b[1]:
        return 1

return 0