Class Hierarchy

• UserDict.DictMixin
  • _emerge.BlockerCache: This caches blockers of installed packages so that dep_check does not have to be done for every single installed package on every invocation of emerge.
  • portage.FetchlistDict: This provide a mapping interface to retrieve fetch lists.
  • portage.cache.mappings.LazyLoad: Lazy loading of values for a dict
  • portage.cache.mappings.ProtectedDict: given an initial dict, this wraps that dict storing changes in a secondary dict, protecting the underlying dict from changes
• portage.glsa.Glsa: This class is a wrapper for the XML data and provides methods to access and display the contained data.
• formatter.NullWriter: Minimal writer interface to use in testing & inheritance.
  • formatter.DumbWriter: Simple writer class which writes output on the file object passed in as the file parameter or, if file is omitted, on standard output.
    • portage.output.StyleWriter: This is just a DumbWriter with a hook in the new_styles() method that passes a styles tuple as a single argument to a callable style_listener attribute.
• markupbase.ParserBase: Parser base class which provides some common support methods used by the SGML/HTML and XHTML parsers.
  • HTMLParser.HTMLParser: Find tags and other markup and call handler functions.
    • portage.getbinpkg.ParseLinks: Parser class that overrides HTMLParser to grab all anchors from an html page and provide suffix and prefix limitors
• ConfigParser.RawConfigParser
  • ConfigParser.ConfigParser
    • ConfigParser.SafeConfigParser
      • portage.sets.SetConfig
• UserDict.UserDict
  • portage.env.config.ConfigLoaderKlass: A base class stub for things to inherit from.
    • portage.env.config.PackageKeywordsFile: Inherits from ConfigLoaderKlass; implements a file-based backend.
    • portage.env.config.PackageMaskFile: A class that implements a file-based package.mask
    • portage.env.config.PackageUseFile: Inherits from PackageUse; implements a file-based backend.
    • portage.env.config.PortageModulesFile: File Class for /etc/portage/modules
  • portage.env.config.GenericFile: Inherits from ConfigLoaderKlass, attempts to use all known loaders until it gets <something> in data.
• object: The most base type
  • portage.dep.Atom: For compatibility with existing atom string manipulation code, this class emulates most of the str methods that are useful with atoms.
  • exceptions.BaseException: Common base class for all exceptions
    • exceptions.Exception: Common base class for all non-exit exceptions.
      • portage.cache.cache_errors.CacheError
        • portage.cache.cache_errors.CacheCorruption
        • portage.cache.cache_errors.GeneralCacheCorruption
        • portage.cache.cache_errors.InitializationError
        • portage.cache.cache_errors.InvalidRestriction
        • portage.cache.cache_errors.ReadOnlyRestriction
      • portage.glsa.GlsaArgumentException
      • portage.glsa.GlsaFormatException
      • portage.glsa.GlsaTypeException
      • portage.env.loaders.LoaderError
      • portage.exception.PortageException: General superclass for portage exceptions
        • _emerge.BinpkgFetcher.AlreadyLocked
        • _emerge.EbuildBuildDir.AlreadyLocked
        • portage.exception.CommandNotFound: A required binary was not available or executable
        • portage.exception.CorruptionError: Corruption indication
        • portage.manifest.FileNotInManifestException
        • portage.exception.IncorrectParameter: A parameter of the wrong type was passed
        • portage.exception.InvalidData: An incorrect formatting was passed instead of the expected one
        • portage.exception.InvalidDataType: An incorrect type was passed instead of the expected one
        • portage.exception.InvalidDependString: An invalid depend string has been encountered
        • portage.exception.InvalidLocation: Data was not found when it was expected to exist or was specified incorrectly
          • portage.exception.DirectoryNotFound: A directory was not found when it was expected to exist
          • portage.exception.FileNotFound: A file was not found when it was expected to exist
        • portage.exception.InvalidVersionString: An invalid version string has been encountered
        • portage.exception.MissingParameter: A parameter is required for the action requested but was not passed
        • portage.exception.OperationNotPermitted
        • portage.exception.ParseError: An error was generated while attempting to parse the request
        • portage.exception.PermissionDenied
        • portage.exception.PortagePackageException: Malformed or missing package data
          • portage.exception.InvalidAtom: Malformed atom spec
          • portage.exception.InvalidPackageName: Malformed package name
          • portage.exception.PackageNotFound: Missing Ebuild or Binary
          • portage.exception.PackageSetNotFound: Missing package set
          • portage.exception.UnsupportedAPIException: Unsupported API
        • portage.exception.ReadOnlyFileSystem: Read-only file system
        • portage.exception.SecurityViolation: An incorrect formatting was passed instead of the expected one
        • portage.exception.SignatureException: Signature was not present in the checked file
          • portage.exception.DigestException: A problem exists in the digest
          • portage.exception.InvalidSignature: Signature was checked and was not a valid, current, nor trusted signature
          • portage.exception.MissingSignature: Signature was not present in the checked file
          • portage.exception.UntrustedSignature: Signature was not certified to the desired security level
        • portage.exception.TryAgain
        • _emerge.UninstallFailure: An instance of this class is raised by unmerge() when an uninstallation fails.
        • _emerge.depgraph.UnsatisfiedResumeDep: A dependency of a resume list is not installed.
        • _emerge.depgraph._internal_exception
          • _emerge.depgraph._serialize_tasks_retry: This is raised by the _serialize_tasks() method when it needs to be called again for some reason.
          • _emerge.depgraph._unknown_internal_error: Used by the depgraph internally to terminate graph creation.
        • _emerge.Scheduler._pkg_failure: An instance of this class is raised by unmerge() when an uninstallation fails.
      • portage.sets.SetConfigError
      • exceptions.StandardError: Base class for all standard Python exceptions that do not represent interpreter exiting.
        • exceptions.AssertionError: Assertion failed.
        • sqlite3.Error
          • sqlite3.DatabaseError
            • sqlite3.DataError
            • sqlite3.IntegrityError
            • sqlite3.InternalError
            • sqlite3.NotSupportedError
            • sqlite3.OperationalError
            • sqlite3.ProgrammingError
          • sqlite3.InterfaceError
        • sqlite3.Warning
  • _emerge.BlockerDB
  • _emerge.BlockerCache.BlockerData
  • sqlite3.Cache
  • portage.env.config.ConfigLoaderKlass: A base class stub for things to inherit from.
    • portage.env.config.PackageKeywordsFile: Inherits from ConfigLoaderKlass; implements a file-based backend.
    • portage.env.config.PackageMaskFile: A class that implements a file-based package.mask
    • portage.env.config.PackageUseFile: Inherits from PackageUse; implements a file-based backend.
    • portage.env.config.PortageModulesFile: File Class for /etc/portage/modules
  • portage.util.ConfigProtect
  • sqlite3.Connection: SQLite database connection object.
  • portage.output.ConsoleStyleFile: A file-like object that behaves something like the colorize() function.
  • sqlite3.Cursor: SQLite database cursor class.
  • portage.env.loaders.DataLoader
    • portage.env.loaders.EnvLoader: Class to access data in the environment
    • portage.env.loaders.FileLoader: Class to access data in files
      • portage.env.loaders.ItemFileLoader: Class to load data from a file full of items one per line
      • portage.env.loaders.KeyListFileLoader: Class to load data from a file full of key [list] tuples
      • portage.env.loaders.KeyValuePairFileLoader: Class to load data from a file full of key=value pairs
    • portage.env.loaders.TestTextLoader: You give it some data, it 'loads' it for you, no filesystem access
  • _emerge.DependencyArg
    • _emerge.AtomArg
    • _emerge.PackageArg
    • _emerge.SetArg
  • portage.news.DisplayRestriction: A base restriction object representing a restriction of display.
    • portage.news.DisplayInstalledRestriction: An Installation restriction where a particular item shall only be displayed if the user has that item installed.
    • portage.news.DisplayKeywordRestriction: A keyword restriction where a particular item shall only be displayed if the user is running a specific keyword.
    • portage.news.DisplayProfileRestriction: A profile restriction where a particular item shall only be displayed if the user is running a specific profile.
  • portage.output.EOutput: Performs fancy terminal formatting for status and informational messages.
  • portage.gpg.FileChecker
  • _emerge.JobStatusDisplay
  • repoman.checks.LineCheck: Run a check on a line of an ebuild.
    • repoman.checks.DeprecatedBindnowFlags: Check for calls to the deprecated bindnow-flags function.
    • repoman.checks.EMakeParallelDisabled: Check for emake -j1 calls which disable parallelization.
    • repoman.checks.EbuildAssignment: Ensure ebuilds don't assign to readonly variables.
    • repoman.checks.EbuildHeader: Ensure ebuilds have proper headers Copyright header errors CVS header errors License header errors
    • repoman.checks.EbuildNestedDie: Check ebuild for nested die statements (die statements in subshells
    • repoman.checks.EbuildPatches: Ensure ebuilds use bash arrays for PATCHES to ensure white space safety
    • repoman.checks.EbuildQuote: Ensure ebuilds have valid quoting around things like D,FILESDIR, etc...
    • repoman.checks.EbuildQuotedA: Ensure ebuilds have no quoting around ${A}
    • repoman.checks.EbuildUselessCdS: Check for redundant cd ${S} statements
    • repoman.checks.EbuildUselessDodoc: Check ebuild for useless files in dodoc arguments.
    • repoman.checks.EbuildWhitespace: Ensure ebuilds have proper whitespacing
    • repoman.checks.IUseUndefined: Make sure the ebuild defines IUSE (style guideline says to define IUSE even when empty).
    • repoman.checks.InheritAutotools: Make sure appropriate functions are called in ebuilds that inherit autotools.eclass.
  • portage.dbapi.vartree.LinkageMap: Models dynamic linker dependencies.
  • portage.manifest.Manifest
  • portage.manifest.ManifestEntry
    • portage.manifest.Manifest2Entry
  • portage.news.NewsItem: This class encapsulates a GLEP 42 style news item.
  • portage.news.NewsManager: This object manages GLEP 42 style news items.
  • portage.util.ObjectProxy: Object that acts as a proxy to another object, forwarding attribute accesses and method calls.
    • portage._LegacyGlobalProxy: Instances of these serve as proxies to global variables that are initialized on demand.
    • portage._MtimedbProxy: The mtimedb is independent from the portdb and other globals.
    • portage._PortdbProxy: The portdb is initialized separately from the rest of the variables, since sometimes the other variables are needed while the portdb is not.
  • _emerge.PackageCounters
  • portage.getbinpkg.PackageIndex
  • portage.sets.base.PackageSet
    • portage.sets.dbapi.CategorySet
    • portage.sets.shell.CommandOutputSet: This class creates a PackageSet from the output of a shell command.
    • portage.sets.files.ConfigFileSet
    • portage.sets.dbapi.DowngradeSet
    • portage.sets.base.EditablePackageSet
      • portage.sets.base.InternalPackageSet
      • portage.sets.files.StaticFileSet
      • portage.sets.files.WorldSet
    • portage.sets.dbapi.EverythingSet
      • portage.sets.dbapi.VariableSet
    • portage.sets.libs.LibraryConsumerSet
      • portage.sets.libs.PreservedLibraryConsumerSet
    • portage.sets.dbapi.OwnerSet
    • portage.sets.profiles.PackagesSystemSet
    • portage.sets.security.SecuritySet
      • portage.sets.security.AffectedSet
        • portage.sets.security.NewAffectedSet
      • portage.sets.security.NewGlsaSet
  • _emerge.PollConstants: Provides POLL* constants that are equivalent to those from the select module, for use by PollSelectAdapter.
    • _emerge.PollSelectAdapter: Use select to emulate a poll object, for systems that don't support poll().
  • _emerge.PollScheduler
    • _emerge.MetadataRegen
    • _emerge.QueueScheduler: Add instances of SequentialTaskQueue and then call run().
    • _emerge.Scheduler
  • sqlite3.PrepareProtocol
  • portage.dbapi.vartree.PreservedLibsRegistry: This class handles the tracking of preserved library objects
  • portage.output.ProgressBar: The interface is copied from the ProgressBar class from the EasyDialogs module (which is Mac only).
    • portage.output.TermProgressBar: A tty progress bar similar to wget's.
  • _emerge.RepoDisplay
  • _emerge.RootConfig: This is used internally by depgraph to track information about a particular $ROOT.
  • sqlite3.Row
  • _emerge.SlotObject
    • _emerge.AbstractDepPriority
      • _emerge.DepPriority: This class generates an integer priority level based of various attributes of the dependency relationship.
        • _emerge.BlockerDepPriority
      • _emerge.UnmergeDepPriority
    • _emerge.AsynchronousTask: Subclasses override _wait() and _poll() so that calls to public methods can be wrapped for implementing hooks such as exit listener notification.
      • _emerge.BinpkgVerifier
      • _emerge.CompositeTask
        • _emerge.Binpkg
        • _emerge.EbuildBuild
        • _emerge.EbuildExecuter
        • _emerge.EbuildPhase
        • _emerge.MergeListItem: TODO: For parallel scheduling, everything here needs asynchronous execution support (start, poll, and wait methods).
        • _emerge.TaskSequence: A collection of tasks that executes sequentially.
      • _emerge.PackageMerge: TODO: Implement asynchronous merge so that the scheduler can run while a merge is executing.
      • _emerge.PackageUninstall
      • _emerge.PipeReader: Reads output from one or more files and saves it in memory, for retrieval via the getvalue() method.
      • _emerge.SubProcess
        • _emerge.EbuildMetadataPhase: Asynchronous interface for the ebuild "depend" phase which is used to extract metadata from the ebuild.
        • _emerge.SpawnProcess: Constructor keyword args are passed into portage.process.spawn().
          • _emerge.BinpkgExtractorAsync
          • _emerge.BinpkgFetcher
          • _emerge.EbuildFetcher
          • _emerge.EbuildProcess
            • _emerge.EbuildBinpkg: This assumes that src_install() has successfully completed.
          • _emerge.MiscFunctionsProcess: Spawns misc-functions.sh with an existing ebuild environment.
    • _emerge.Dependency
    • _emerge.EbuildBuildDir
    • _emerge.EbuildFetchPretend
    • _emerge.EbuildMerge
    • _emerge.SequentialTaskQueue
    • _emerge.Task
      • _emerge.Blocker
      • _emerge.Package
    • _emerge.Scheduler._binpkg_opts_class
    • _emerge.Scheduler._build_opts_class
    • _emerge.Scheduler._emerge_log_class
    • _emerge.Scheduler._failed_pkg
    • _emerge.Scheduler._fetch_iface_class
    • _emerge.Scheduler._iface_class
    • _emerge.Scheduler._pkg_count_class
    • _emerge.PollScheduler._sched_iface_class
  • sqlite3.Statement
  • _emerge.TaskScheduler: A simple way to handle scheduling of AsynchrousTask instances.
  • unittest.TestCase: A class whose instances are single test cases.
    • portage.tests.TestCase: We need a way to mark a unit test as "ok to fail" This way someone can add a broken test and mark it as failed and then fix the code later.
      • portage.tests.dep.test_match_from_list.AtomCmpEqualGlob: A simple testcase for =* glob matching
      • portage.tests.bin.setup_env.BinTestCase
        • portage.tests.bin.test_dobin.DoBin
        • portage.tests.bin.test_dodir.DoDir
      • portage.tests.sets.shell.testShell.CommandOutputSetTestCase: Simple Test Case for CommandOutputSet
      • portage.tests.sets.files.testConfigFileSet.ConfigFileSetTestCase: Simple Test Case for ConfigFileSet
      • portage.tests.dep.test_dep_getcpv.DepGetCPV: A simple testcase for isvalidatom
      • portage.tests.dep.test_dep_getslot.DepGetSlot: A simple testcase for isvalidatom
      • portage.tests.dep.test_dep_getusedeps.DepGetUseDeps: A simple testcase for dep_getusedeps
      • portage.tests.dep.test_get_operator.GetOperator
      • portage.tests.util.test_grabdict.GrabDictTestCase
      • portage.tests.dep.test_isjustname.IsJustName
      • portage.tests.dep.test_isvalidatom.IsValidAtom: A simple testcase for isvalidatom
      • portage.tests.news.test_NewsItem.NewsItemTestCase: These tests suck: they use your running config instead of making their own
      • portage.tests.util.test_normalizedPath.NormalizePathTestCase
      • portage.tests.env.config.test_PackageKeywordsFile.PackageKeywordsFileTestCase
      • portage.tests.env.config.test_PackageMaskFile.PackageMaskFileTestCase
      • portage.tests.env.config.test_PackageUseFile.PackageUseFileTestCase
      • portage.tests.process.test_poll.PipeReaderTestCase
      • portage.tests.env.config.test_PortageModulesFile.PortageModulesFileTestCase
      • portage.tests.ebuild.test_spawn.SpawnTestCase
      • portage.tests.util.test_stackDictList.StackDictListTestCase
      • portage.tests.util.test_stackDicts.StackDictsTestCase
      • portage.tests.util.test_stackLists.StackListsTestCase
      • portage.tests.sets.files.testStaticFileSet.StaticFileSetTestCase: Simple Test Case for StaticFileSet
      • portage.tests.util.test_uniqueArray.UniqueArrayTestCase
      • portage.tests.util.test_varExpand.VarExpandTestCase
      • portage.tests.versions.test_vercmp.VerCmpTestCase: A simple testCase for portage.versions.vercmp()
      • portage.tests.xpak.test_decodeint.testDecodeIntTestCase
  • unittest.TestResult: Holder for test result information.
    • unittest._TextTestResult: A test result class that can print formatted text results to a stream.
      • portage.tests.TextTestResult: We need a subclass of unittest._TextTestResult to handle tests with TODO
  • unittest.TextTestRunner: A test runner class that displays results in textual form.
    • portage.tests.TextTestRunner: We subclass unittest.TextTestRunner to output SKIP for tests that fail but are skippable
  • portage.dbapi.vartree.LinkageMap._ObjectKey: Helper class used as _obj_properties keys for objects.
  • _emerge._PackageMetadataWrapperBase
    • _emerge._PackageMetadataWrapper: Detect metadata updates and synchronize Package attributes.
  • portage.dep._use_dep._conditionals_class
  • _emerge.SpawnProcess._files_dict
  • _emerge.EbuildMetadataPhase._files_dict
  • _emerge.Package._iuse
  • portage.dbapi.vartree.vardbapi._owners_cache: This class maintains an hash table that serves to index package contents by mapping the basename of file to a list of possible packages that own it.
  • portage.dbapi.vartree.vardbapi._owners_db
  • _emerge.Scheduler._task_queues_class
  • _emerge.Package._use
  • portage.dep._use_dep
  • portage.dbapi.bintree.binarytree: this tree scans for a list of all packages available in PKGDIR
  • portage.eclass_cache.cache: Maintains the cache information about eclasses used in ebuild.
  • portage.config: This class encompasses the main portage configuration.
  • portage.cache.template.database
    • portage.cache.fs_template.FsBased: template wrapping fs needed options, and providing _ensure_access as a way to attempt to ensure files have the specified owners/perms
      • portage.cache.flat_list.database
      • portage.cache.sqlite.database
      • portage.cache.flat_hash.database
        • portage.cache.metadata.database
      • portage.cache.anydbm.database
    • portage.cache.sql_template.SQLDatabase: template class for RDBM based caches
    • portage.cache.metadata_overlay.database
    • portage.cache.volatile.database
  • portage.dbapi
    • _emerge.PackageVirtualDbapi: A dbapi-like interface class that represents the state of the installed package database as new packages are installed, replacing any packages that previously existed in the same slot.
    • _emerge.depgraph._dep_check_composite_db: A dbapi-like interface that is optimized for use in dep_check() calls.
  • portage.dbapi.dbapi
  • portage.dbapi.vartree.dblink: This class provides an interface to the installed package database At present this is implemented as a text backend in /var/db/pkg.
  • _emerge.depgraph
  • dict: dict() -> new empty dictionary.
    • portage.util.LazyItemsDict: A mapping object that behaves like a standard dict except that it allows for lazy initialization of values via callable objects.
    • portage.MtimeDB
    • _emerge.depgraph._package_cache
  • portage.digraph
  • file: file(name[, mode[, buffering]]) -> file object
    • portage.util._insert_newline_eof: Read functions insert anywhere from 0 and 2 newlines just before eof.
    • portage.util.atomic_ofstream: Write a file atomically via os.rename().
  • list: list() -> new list list(sequence) -> new list initialized from sequence's items
    • portage.dep.paren_normalize: Take a dependency structure as returned by paren_reduce or use_reduce and generate an equivalent structure that has no redundant lists.
  • portage.dbapi.porttree.portagetree
  • portage.debug.prefix_trimmer
  • portage.cache.util.quiet_mirroring
    • portage.cache.util.non_quiet_mirroring
  • _emerge.search
  • _emerge.stdout_spinner
  • portage.xpak.tbz2
  • portage.dbapi.virtual.testdbapi: A dbapi instance with completely fake functions to get by hitting disk TODO(antarus): This class really needs to be rewritten to have better stubs; but these work for now.
  • portage.debug.trace_handler
  • type: type(object) -> the object's type type(name, bases, dict) -> a new type
    • portage.dep._AtomCache: Cache Atom instances from constructor calls and reuse identical instances when available.
  • portage.vartree: this tree will scan a var/db/pkg database located at root (passed to init)
    • _emerge.FakeVartree: This is implements an in-memory copy of a vartree instance that provides all the interfaces required for use by the depgraph.
  • portage.dbapi.vartree.vartree: this tree will scan a var/db/pkg database located at root (passed to init)
• shlex.shlex: A lexical analyzer class for simple shell-like syntaxes.
  • portage.util._tolerant_shlex