""" Simple terminal width, limit to 20 chars. and make 0 == 80. """

if not hasattr(urlgrabber.progress, 'terminal_width_cached'):

return 80

ret = urlgrabber.progress.terminal_width_cached()

if ret == 0:

return 80

if ret < 20:

return 20

"""A class to display text progress bar output."""

def update(self, amount_read, now=None):

"""Update the status of the text progress bar

checkSignals()

"""A class to provide some terminal "UI" helpers based on curses."""

# From initial search for "terminfo and python" got:

# http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/475116

# ...it's probably not copyrightable, but if so ASPN says:

#

# Except where otherwise noted, recipes in the Python Cookbook are

# published under the Python license.

__enabled = True

if hasattr(urlgrabber.progress, 'terminal_width_cached'):

columns = property(lambda self: _term_width())

__cap_names = {

'underline' : 'smul',

'reverse' : 'rev',

'normal' : 'sgr0',

}

__colors = {

'black' : 0,

'blue' : 1,

'green' : 2,

'cyan' : 3,

'red' : 4,

'magenta' : 5,

'yellow' : 6,

'white' : 7

}

__ansi_colors = {

'black' : 0,

'red' : 1,

'green' : 2,

'yellow' : 3,

'blue' : 4,

'magenta' : 5,

'cyan' : 6,

'white' : 7

}

__ansi_forced_MODE = {

'bold' : '\x1b[1m',

'blink' : '\x1b[5m',

'dim' : '',

'reverse' : '\x1b[7m',

'underline' : '\x1b[4m',

'normal' : '\x1b(B\x1b[m'

}

__ansi_forced_FG_COLOR = {

'black' : '\x1b[30m',

'red' : '\x1b[31m',

'green' : '\x1b[32m',

'yellow' : '\x1b[33m',

'blue' : '\x1b[34m',

'magenta' : '\x1b[35m',

'cyan' : '\x1b[36m',

'white' : '\x1b[37m'

}

__ansi_forced_BG_COLOR = {

'black' : '\x1b[40m',

'red' : '\x1b[41m',

'green' : '\x1b[42m',

'yellow' : '\x1b[43m',

'blue' : '\x1b[44m',

'magenta' : '\x1b[45m',

'cyan' : '\x1b[46m',

'white' : '\x1b[47m'

}

def __forced_init(self):

self.MODE = self.__ansi_forced_MODE

self.FG_COLOR = self.__ansi_forced_FG_COLOR

self.BG_COLOR = self.__ansi_forced_BG_COLOR

def reinit(self, term_stream=None, color='auto'):

"""Reinitializes the :class:`YumTerm`.

self.__enabled = True

if not hasattr(urlgrabber.progress, 'terminal_width_cached'):

self.columns = 80

self.lines = 24

if color == 'always':

self.__forced_init()

return

# Output modes:

self.MODE = {

'bold' : '',

'blink' : '',

'dim' : '',

'reverse' : '',

'underline' : '',

'normal' : ''

}

# Colours

self.FG_COLOR = {

'black' : '',

'blue' : '',

'green' : '',

'cyan' : '',

'red' : '',

'magenta' : '',

'yellow' : '',

'white' : ''

}

self.BG_COLOR = {

'black' : '',

'blue' : '',

'green' : '',

'cyan' : '',

'red' : '',

'magenta' : '',

'yellow' : '',

'white' : ''

}

if color == 'never':

self.__enabled = False

return

assert color == 'auto'

# Curses isn't available on all platforms

try:

import curses

except:

self.__enabled = False

return

# If the stream isn't a tty, then assume it has no capabilities.

if not term_stream:

term_stream = sys.stdout

if not term_stream.isatty():

self.__enabled = False

return

# Check the terminal type. If we fail, then assume that the

# terminal has no capabilities.

try:

curses.setupterm(fd=term_stream.fileno())

except:

self.__enabled = False

return

self._ctigetstr = curses.tigetstr

if not hasattr(urlgrabber.progress, 'terminal_width_cached'):

self.columns = curses.tigetnum('cols')

self.lines = curses.tigetnum('lines')

# Look up string capabilities.

for cap_name in self.MODE:

mode = cap_name

if cap_name in self.__cap_names:

cap_name = self.__cap_names[cap_name]

self.MODE[mode] = self._tigetstr(cap_name) or ''

# Colors

set_fg = self._tigetstr('setf')

if set_fg:

for (color, val) in self.__colors.items():

self.FG_COLOR[color] = curses.tparm(set_fg, val) or ''

set_fg_ansi = self._tigetstr('setaf')

if set_fg_ansi:

for (color, val) in self.__ansi_colors.items():

self.FG_COLOR[color] = curses.tparm(set_fg_ansi, val) or ''

set_bg = self._tigetstr('setb')

if set_bg:

for (color, val) in self.__colors.items():

self.BG_COLOR[color] = curses.tparm(set_bg, val) or ''

set_bg_ansi = self._tigetstr('setab')

if set_bg_ansi:

for (color, val) in self.__ansi_colors.items():

self.BG_COLOR[color] = curses.tparm(set_bg_ansi, val) or ''

def __init__(self, term_stream=None, color='auto'):

self.reinit(term_stream, color)

def _tigetstr(self, cap_name):

# String capabilities can include "delays" of the form "$<2>".

# For any modern terminal, we should be able to just ignore

# these, so strip them out.

cap = self._ctigetstr(cap_name) or ''

return re.sub(r'\$<\d+>[/*]?', '', cap)

def sub(self, haystack, beg, end, needles, escape=None, ignore_case=False):

"""Search the string *haystack* for all occurrences of any

if not self.__enabled:

return haystack

if not escape:

escape = re.escape

render = lambda match: beg + match.group() + end

for needle in needles:

pat = escape(needle)

if ignore_case:

pat = re.template(pat, re.I)

haystack = re.sub(pat, render, haystack)

return haystack

def sub_norm(self, haystack, beg, needles, **kwds):

"""Search the string *haystack* for all occurrences of any

return self.sub(haystack, beg, self.MODE['normal'], needles, **kwds)

def sub_mode(self, haystack, mode, needles, **kwds):

"""Search the string *haystack* for all occurrences of any

return self.sub_norm(haystack, self.MODE[mode], needles, **kwds)

def sub_bold(self, haystack, needles, **kwds):

"""Search the string *haystack* for all occurrences of any

return self.sub_mode(haystack, 'bold', needles, **kwds)

def sub_fg(self, haystack, color, needles, **kwds):

"""Search the string *haystack* for all occurrences of any

return self.sub_norm(haystack, self.FG_COLOR[color], needles, **kwds)

def sub_bg(self, haystack, color, needles, **kwds):

"""Search the string *haystack* for all occurrences of any

"""Main output class for the yum command line."""

def __init__(self):

self.logger = logging.getLogger("yum.cli")

self.verbose_logger = logging.getLogger("yum.verbose.cli")

if hasattr(rpm, "expandMacro"):

self.i18ndomains = rpm.expandMacro("%_i18ndomains").split(":")

else:

self.i18ndomains = ["redhat-dist"]

self.term = YumTerm()

self._last_interrupt = None

self.reported_error_msgs = {k: False for (k, v) in ERRORS_TO_KBASE_ARTICLES.iteritems()}

def printtime(self):

"""Return a string representing the current time in the form::

months = [_('Jan'), _('Feb'), _('Mar'), _('Apr'), _('May'), _('Jun'),

_('Jul'), _('Aug'), _('Sep'), _('Oct'), _('Nov'), _('Dec')]

now = time.localtime(time.time())

ret = months[int(time.strftime('%m', now)) - 1] + \

time.strftime(' %d %T ', now)

return ret

def failureReport(self, errobj):

"""Perform failure output for failovers from urlgrabber

self.logger.error('%s: %s', errobj.url, errobj.exception)

self.logger.error(_('Trying other mirror.'))

self.suggestKBaseArticle(errobj)

raise errobj.exception

def suggestKBaseArticle(self, errobj):

errcode = None

if hasattr(errobj.exception, 'code') and errobj.exception.code in ERRORS_TO_KBASE_ARTICLES:

errcode = errobj.exception.code

elif hasattr(errobj.exception, 'errno') and errobj.exception.errno in ERRORS_TO_KBASE_ARTICLES:

errcode = errobj.exception.errno

if not errcode:

return

if not self.reported_error_msgs[errcode]:

self.logger.error(ERRORS_TO_KBASE_ARTICLES[errcode])

self.reported_error_msgs[errcode] = True

def simpleProgressBar(self, current, total, name=None):

"""Output the current status to the terminal using a simple

progressbar(current, total, name)

def _highlight(self, highlight):

hibeg = ''

hiend = ''

if not highlight:

pass

elif not isinstance(highlight, basestring) or highlight == 'bold':

hibeg = self.term.MODE['bold']

elif highlight == 'normal':

pass # Minor opt.

else:

# Turn a string into a specific output: colour, bold, etc.

for high in highlight.replace(',', ' ').split():

if False: pass

elif high == 'normal':

hibeg = ''

elif high in self.term.MODE:

hibeg += self.term.MODE[high]

elif high in self.term.FG_COLOR:

hibeg += self.term.FG_COLOR[high]

elif (high.startswith('fg:') and

high[3:] in self.term.FG_COLOR):

hibeg += self.term.FG_COLOR[high[3:]]

elif (high.startswith('bg:') and

high[3:] in self.term.BG_COLOR):

hibeg += self.term.BG_COLOR[high[3:]]

if hibeg:

hiend = self.term.MODE['normal']

return (hibeg, hiend)

def _sub_highlight(self, haystack, highlight, needles, **kwds):

hibeg, hiend = self._highlight(highlight)

return self.term.sub(haystack, hibeg, hiend, needles, **kwds)

@staticmethod

def _calc_columns_spaces_helps(current, data_tups, left):

""" Spaces left on the current field will help how many pkgs? """

ret = 0

for tup in data_tups:

if left < (tup[0] - current):

break

ret += tup[1]

return ret

def calcColumns(self, data, columns=None, remainder_column=0,

total_width=None, indent=''):

"""Dynamically calculate the widths of the columns that the

if total_width is None:

total_width = self.term.columns

cols = len(data)

# Convert the data to ascending list of tuples, (field_length, pkgs)

pdata = data

data = [None] * cols # Don't modify the passed in data

for d in range(0, cols):

data[d] = sorted(pdata[d].items())

# We start allocating 1 char to everything but the last column, and a

# space between each (again, except for the last column). Because

# at worst we are better with:

# |one two three|

# | four |

# ...than:

# |one two three|

# | f|

# |our |

# ...the later being what we get if we pre-allocate the last column, and

# thus. the space, due to "three" overflowing it's column by 2 chars.

if columns is None:

columns = [1] * (cols - 1)

columns.append(0)

total_width -= (sum(columns) + (cols - 1) + utf8_width(indent))

if not columns[-1]:

total_width += 1

while total_width > 0:

# Find which field all the spaces left will help best

helps = 0

val = 0

for d in xrange(0, cols):

thelps = self._calc_columns_spaces_helps(columns[d], data[d],

total_width)

if not thelps:

continue

# We prefer to overflow: the last column, and then earlier

# columns. This is so that in the best case (just overflow the

# last) ... grep still "works", and then we make it prettier.

if helps and (d == (cols - 1)) and (thelps / 2) < helps:

continue

if thelps < helps:

continue

helps = thelps

val = d

# If we found a column to expand, move up to the next level with

# that column and start again with any remaining space.

if helps:

diff = data[val].pop(0)[0] - columns[val]

if not columns[val] and (val == (cols - 1)):

# If we are going from 0 => N on the last column, take 1

# for the space before the column.

total_width -= 1

columns[val] += diff

total_width -= diff

continue

overflowed_columns = 0

for d in xrange(0, cols):

if not data[d]:

continue

overflowed_columns += 1

if overflowed_columns:

# Split the remaining spaces among each overflowed column

# equally

norm = total_width / overflowed_columns

for d in xrange(0, cols):

if not data[d]:

continue

columns[d] += norm

total_width -= norm

# Split the remaining spaces among each column equally, except the

# last one. And put the rest into the remainder column

cols -= 1

norm = total_width / cols

for d in xrange(0, cols):

columns[d] += norm

columns[remainder_column] += total_width - (cols * norm)

total_width = 0

return columns

@staticmethod

def _fmt_column_align_width(width):

if width < 0:

return (u"-", -width)

return (u"", width)

def _col_data(self, col_data):

assert len(col_data) == 2 or len(col_data) == 3

if len(col_data) == 2:

(val, width) = col_data

hibeg = hiend = ''

if len(col_data) == 3:

(val, width, highlight) = col_data

(hibeg, hiend) = self._highlight(highlight)

return (val, width, hibeg, hiend)

def fmtColumns(self, columns, msg=u'', end=u'', text_width=utf8_width):

"""Return a row of data formatted into a string for output.

total_width = len(msg)

data = []

for col_data in columns[:-1]:

(val, width, hibeg, hiend) = self._col_data(col_data)

if not width: # Don't count this column, invisible text

msg += u"%s"

data.append(val)

continue

(align, width) = self._fmt_column_align_width(width)

val_width = text_width(val)

if val_width <= width:

# Don't use utf8_width_fill() because it sucks performance

# wise for 1,000s of rows. Also allows us to use len(), when

# we can.

msg += u"%s%s%s%s "

if (align == u'-'):

data.extend([hibeg, val, hiend, " " * (width - val_width)])

else:

data.extend([" " * (width - val_width), hibeg, val, hiend])

else:

msg += u"%s%s%s\n" + " " * (total_width + width + 1)

data.extend([hibeg, val, hiend])

total_width += width

total_width += 1

(val, width, hibeg, hiend) = self._col_data(columns[-1])

(align, width) = self._fmt_column_align_width(width)

val = utf8_width_fill(val, width, left=(align == u'-'),

prefix=hibeg, suffix=hiend)

msg += u"%%s%s" % end

data.append(val)

return msg % tuple(data)

def simpleList(self, pkg, ui_overflow=False, indent='', highlight=False,

columns=None):

"""Print a package as a line.

if columns is None:

columns = (-40, -22, -16) # Old default

ver = pkg.printVer()

na = '%s%s.%s' % (indent, pkg.name, pkg.arch)

hi_cols = [highlight, 'normal', 'normal']

rid = pkg.ui_from_repo

columns = zip((na, ver, rid), columns, hi_cols)

print self.fmtColumns(columns, text_width=len)

def simpleEnvraList(self, pkg, ui_overflow=False,

indent='', highlight=False, columns=None):

"""Print a package as a line, with the package itself in envra

if columns is None:

columns = (-63, -16) # Old default

envra = '%s%s' % (indent, str(pkg))

hi_cols = [highlight, 'normal', 'normal']

rid = pkg.ui_from_repo

columns = zip((envra, rid), columns, hi_cols)

print self.fmtColumns(columns, text_width=len)

def fmtKeyValFill(self, key, val):

"""Return a key value pair in the common two column output

val = to_str(val)

keylen = utf8_width(key)

cols = self.term.columns

nxt = ' ' * (keylen - 2) + ': '

ret = utf8_text_fill(val, width=cols,

initial_indent=key, subsequent_indent=nxt)

if ret.count("\n") > 1 and keylen > (cols / 3):

# If it's big, redo it again with a smaller subsequent off

ret = utf8_text_fill(val, width=cols,

initial_indent=key,

subsequent_indent=' ...: ')

return ret

def fmtSection(self, name, fill='='):

"""Format and return a section header. The format of the

name = to_str(name)

cols = self.term.columns - 2

name_len = utf8_width(name)

if name_len >= (cols - 4):

beg = end = fill * 2

else:

beg = fill * ((cols - name_len) / 2)

end = fill * (cols - name_len - len(beg))

return "%s %s %s" % (beg, name, end)

def _enc(self, s):

"""Get the translated version from specspo and ensure that

s = to_utf8(s)

if len(s) > 0:

for d in self.i18ndomains:

t = gettext.dgettext(d, s)

if t != s:

s = t

break

return to_unicode(s)

def infoOutput(self, pkg, highlight=False):

"""Print information about the given package.

(hibeg, hiend) = self._highlight(highlight)

print _("Name : %s%s%s") % (hibeg, to_unicode(pkg.name), hiend)

print _("Arch : %s") % to_unicode(pkg.arch)

if pkg.epoch != "0":

print _("Epoch : %s") % to_unicode(pkg.epoch)

print _("Version : %s") % to_unicode(pkg.version)

print _("Release : %s") % to_unicode(pkg.release)

print _("Size : %s") % self.format_number(float(pkg.size))

print _("Repo : %s") % to_unicode(pkg.repo.ui_id)

if pkg.repoid == 'installed' and 'from_repo' in pkg.yumdb_info:

print _("From repo : %s") % to_unicode(pkg.yumdb_info.from_repo)

if self.verbose_logger.isEnabledFor(logginglevels.DEBUG_3):

print _("Committer : %s") % to_unicode(pkg.committer)

print _("Committime : %s") % time.ctime(pkg.committime)

print _("Buildtime : %s") % time.ctime(pkg.buildtime)

if hasattr(pkg, 'installtime'):

print _("Install time: %s") % time.ctime(pkg.installtime)

if pkg.repoid == 'installed':

uid = None

if 'installed_by' in pkg.yumdb_info:

try:

uid = int(pkg.yumdb_info.installed_by)

except ValueError: # In case int() fails

uid = None

print _("Installed by: %s") % self._pwd_ui_username(uid)

uid = None

if 'changed_by' in pkg.yumdb_info:

try:

uid = int(pkg.yumdb_info.changed_by)

except ValueError: # In case int() fails

uid = None

print _("Changed by : %s") % self._pwd_ui_username(uid)

print self.fmtKeyValFill(_("Summary : "), self._enc(pkg.summary))

if pkg.url:

print _("URL : %s") % to_unicode(pkg.url)

print self.fmtKeyValFill(_("License : "), to_unicode(pkg.license))

print self.fmtKeyValFill(_("Description : "),self._enc(pkg.description))

print ""

def updatesObsoletesList(self, uotup, changetype, columns=None, repoid=None):

"""Print a simple string that explains the relationship

(changePkg, instPkg) = uotup

if repoid and changePkg.repoid != repoid:

return

if columns is not None:

# New style, output all info. for both old/new with old indented

chi = self.conf.color_update_remote

if changePkg.repo.id != 'installed' and changePkg.verifyLocalPkg():

chi = self.conf.color_update_local

self.simpleList(changePkg, columns=columns, highlight=chi)

self.simpleList(instPkg, columns=columns, indent=' ' * 4,

highlight=self.conf.color_update_installed)

return

# Old style

c_compact = changePkg.compactPrint()

i_compact = '%s.%s' % (instPkg.name, instPkg.arch)

c_repo = changePkg.repoid

print '%-35.35s [%.12s] %.10s %-20.20s' % (c_compact, c_repo, changetype, i_compact)

def listPkgs(self, lst, description, outputType, highlight_na={},

columns=None, highlight_modes={}):

"""Prints information about the given list of packages.

kern_pkgtup = yum.misc.get_running_kernel_pkgtup(self.ts)

if outputType in ['list', 'info']:

thingslisted = 0

if len(lst) > 0:

thingslisted = 1

print '%s' % description

for pkg in sorted(lst):

key = (pkg.name, pkg.arch)

highlight = False

if pkg.pkgtup == kern_pkgtup:

highlight = highlight_modes.get('kern','bold,underline')

elif key not in highlight_na:

highlight = highlight_modes.get('not in', 'normal')

elif pkg.verEQ(highlight_na[key]):

highlight = highlight_modes.get('=', 'normal')

elif pkg.verLT(highlight_na[key]):

highlight = highlight_modes.get('>', 'bold')

else:

highlight = highlight_modes.get('<', 'normal')

if outputType == 'list':

self.simpleList(pkg, ui_overflow=True,

highlight=highlight, columns=columns)

elif outputType == 'info':

self.infoOutput(pkg, highlight=highlight)

else:

pass

if thingslisted == 0:

return 1, ['No Packages to list']

return 0, []

def userconfirm(self, prompt=_('Is this ok [y/N]: '), extra={}):

"""Get a yes or no from the user, and default to No, and maybe more.

# Allow the one letter english versions in all langs.

yui = (u'y', to_unicode(_('y')), to_unicode(_('yes')))

nui = (u'n', to_unicode(_('n')), to_unicode(_('no')))

aui = set(yui + nui)

for xui in extra:

aui.update(extra[xui])

while True:

try:

choice = raw_input(prompt)

except UnicodeEncodeError:

raise

except UnicodeDecodeError:

raise