Package util

Sets up basic logging of portage activities
Args:
        level: the level to emit messages at ('info', 'debug', 'warning' ...)
Returns:
        None

Show a message for the given level as defined by the logging module (default is 0). When level >= logging.WARNING then the message is sent to stderr, otherwise it is sent to stdout. The noiselevel is passed directly to writemsg().

Parameters:

• msg (str) - a message string, including newline if appropriate
• level (int) - a numeric logging level (see the logging module)
• noiselevel (int) - passed directly to writemsg

Performs a function on each value of each key in a dictlist. Returns a new dictlist.

Stacks an array of dict-types into one array. Optionally merging or
overwriting matching key/value pairs for the dict[key]->list.
Returns a single dict. Higher index in lists is preferenced.

Example usage:
   >>> from portage.util import stack_dictlist
        >>> print stack_dictlist( [{'a':'b'},{'x':'y'}])
        >>> {'a':'b','x':'y'}
        >>> print stack_dictlist( [{'a':'b'},{'a':'c'}], incremental = True )
        >>> {'a':['b','c'] }
        >>> a = {'KEYWORDS':['x86','alpha']}
        >>> b = {'KEYWORDS':['-x86']}
        >>> print stack_dictlist( [a,b] )
        >>> { 'KEYWORDS':['x86','alpha','-x86']}
        >>> print stack_dictlist( [a,b], incremental=True)
        >>> { 'KEYWORDS':['alpha'] }
        >>> print stack_dictlist( [a,b], incrementals=['KEYWORDS'])
        >>> { 'KEYWORDS':['alpha'] }

@param original_dicts a list of (dictionary objects or None)
@type list
@param incremental True or false depending on whether new keys should overwrite
   keys which already exist.
@type boolean
@param incrementals A list of items that should be incremental (-foo removes foo from
   the returned dict).
@type list
@param ignore_none Appears to be ignored, but probably was used long long ago.
@type boolean

Stacks an array of dict-types into one array. Optionally merging or overwriting matching key/value pairs for the dict[key]->string. Returns a single dict.

Stacks an array of list-types into one array. Optionally removing distinct values using '-value' notation. Higher index is preferenced.

all elements must be hashable.

This function grabs the lines in a file, normalizes whitespace and returns lines in a dictionary

@param myfilename: file to process
@type myfilename: string (path)
@param juststrings: only return strings
@type juststrings: Boolean (integer)
@param empty: Ignore certain lines
@type empty: Boolean (integer)
@param recursive: Recursively grab ( support for /etc/portage/package.keywords/* and friends )
@type recursive: Boolean (integer)
@param incremental: Append to the return list, don't overwrite
@type incremental: Boolean (integer)
@rtype: Dictionary
@return:
1.  Returns the lines in a file in a dictionary, for example:
        'sys-apps/portage x86 amd64 ppc'
        would return
        { "sys-apps/portage" : [ 'x86', 'amd64', 'ppc' ]

List unique elements, preserving order. Remember all elements ever seen. Taken from itertools documentation.

Apply user, group, and mode bits to a file if the existing bits do not already match. The default behavior is to force an exact match of mode bits. When mask=0 is specified, mode bits on the target file are allowed to be a superset of the mode argument (via logical OR). When mask>0, the mode bits that the target file is allowed to have are restricted via logical XOR. Returns True if the permissions were modified and False otherwise.

A wrapper around apply_secpass_permissions that applies permissions recursively. If optional argument onerror is specified, it should be a function; it will be called with one argument, a PortageException instance. Returns True if all permissions are applied and False if some are left unapplied.

A wrapper around apply_permissions that uses secpass and simple logic to apply as much of the permissions as possible without generating an obviously avoidable permission exception. Despite attempts to avoid an exception, it's possible that one will be raised anyway, so be prepared. Returns True if all permissions are applied and False if some are left unapplied.

Create a directory and call apply_permissions. Returns True if a directory is created or the permissions needed to be modified, and False otherwise.

This function's handling of EEXIST errors makes it useful for atomic directory creation, in which multiple processes may be competing to create the same directory.

Resolves a config-protect filename for merging, optionally using the last filename if the md5 matches. If force is True, then a new filename will be generated even if mydest does not exist yet. (dest,md5) ==> 'string' --- path_to_target_filename (dest) ==> ('next', 'highest') --- next_target and most-recent_target

Return a tuple of configuration files that needs to be updated. The tuple contains lists organized like this: [ protected_dir, file_list ] If the protected config isn't a protected_dir but a procted_file, list is: [ protected_file, None ] If no configuration files needs to be updated, None is returned