Rollback to python 2.6

NAME=installsystems

VERSION=$(shell sed -rn 's/version = "([^"]+)"/\1/p' installsystems/__init__.py)

BUILD_DIR=__build__

DISTRO=sid

DISTRO=squeeze

all:

	echo all is better than nothing

#!/usr/bin/python2.7

#!/usr/bin/python

# -*- python -*-

# -*- coding: utf-8 -*-

# Started 30/06/2011 by Seblu <seblu@seblu.net>

import os

import time

import datetime

import argparse

import re

import fnmatch

import installsystems

import installsystems.tools as istools

import installsystems.argparse as argparse # to be removed when python2.7

from installsystems.printer import *

from installsystems.repository import Repository

from installsystems.repository import RepositoryManager

Section: python

Priority: optional

Maintainer: Sebastien Luttringer <sebastien.luttringer@smartjog.com>

Build-Depends: debhelper (>= 7), python-central (>= 0.6), cdbs (>= 0.4.50), python-setuptools, python2.7

XS-Python-Version: >= 2.7

Build-Depends: debhelper (>= 7), python-central (>= 0.6), cdbs (>= 0.4.50), python-setuptools

XS-Python-Version: >= 2.6

Standards-Version: 3.9.1

Package: installsystems

Package: python-installsystems

Architecture: all

Depends: ${misc:Depends}, ${python:Depends}, python-progressbar, python-paramiko

Depends: ${misc:Depends}, ${python:Depends}, python-paramiko

XB-Python-Version: ${python:Versions}

Description: InstallSystems Python modules

 This package provides InstallSystems framework

#!/usr/bin/python

# -*- coding: utf-8 -*-

#

# progressbar  - Text progress bar library for Python.

# Copyright (c) 2005 Nilton Volpato

#

# This library is free software; you can redistribute it and/or

# modify it under the terms of the GNU Lesser General Public

# License as published by the Free Software Foundation; either

# version 2.1 of the License, or (at your option) any later version.

#

# This library 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

# Lesser General Public License for more details.

#

# You should have received a copy of the GNU Lesser General Public

# License along with this library; if not, write to the Free Software

# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

'''Text progress bar library for Python.

A text progress bar is typically used to display the progress of a long

running operation, providing a visual cue that processing is underway.

The ProgressBar class manages the current progress, and the format of the line

is given by a number of widgets. A widget is an object that may display

differently depending on the state of the progress bar. There are three types

of widgets:

 - a string, which always shows itself

 - a ProgressBarWidget, which may return a different value every time its

   update method is called

 - a ProgressBarWidgetHFill, which is like ProgressBarWidget, except it

   expands to fill the remaining width of the line.

The progressbar module is very easy to use, yet very powerful. It will also

automatically enable features like auto-resizing when the system supports it.

'''

from __future__ import division

import math

import os

import signal

import sys

import time

try:

    from fcntl import ioctl

    from array import array

    import termios

except ImportError:

    pass

from installsystems.progressbar.compat import *

from installsystems.progressbar.widgets import *

__author__ = 'Nilton Volpato'

__author_email__ = 'first-name dot last-name @ gmail.com'

__date__ = '2011-05-14'

__version__ = '2.3'

class UnknownLength: pass

class ProgressBar(object):

    '''The ProgressBar class which updates and prints the bar.

    A common way of using it is like:

    >>> pbar = ProgressBar().start()

    >>> for i in range(100):

    ...    # do something

    ...    pbar.update(i+1)

    ...

    >>> pbar.finish()

    You can also use a ProgressBar as an iterator:

    >>> progress = ProgressBar()

    >>> for i in progress(some_iterable):

    ...    # do something

    ...

    Since the progress bar is incredibly customizable you can specify

    different widgets of any type in any order. You can even write your own

    widgets! However, since there are already a good number of widgets you

    should probably play around with them before moving on to create your own

    widgets.

    The term_width parameter represents the current terminal width. If the

    parameter is set to an integer then the progress bar will use that,

    otherwise it will attempt to determine the terminal width falling back to

    80 columns if the width cannot be determined.

    When implementing a widget's update method you are passed a reference to

    the current progress bar. As a result, you have access to the

    ProgressBar's methods and attributes. Although there is nothing preventing

    you from changing the ProgressBar you should treat it as read only.

    Useful methods and attributes include (Public API):

     - currval: current progress (0 <= currval <= maxval)

     - maxval: maximum (and final) value

     - finished: True if the bar has finished (reached 100%)

     - start_time: the time when start() method of ProgressBar was called

     - seconds_elapsed: seconds elapsed since start_time and last call to

                        update

     - percentage(): progress in percent [0..100]

    '''

    __slots__ = ('currval', 'fd', 'finished', 'last_update_time',

                 'left_justify', 'maxval', 'next_update', 'num_intervals',

                 'poll', 'seconds_elapsed', 'signal_set', 'start_time',

                 'term_width', 'update_interval', 'widgets', '_time_sensitive',

                 '__iterable')

    _DEFAULT_MAXVAL = 100

    _DEFAULT_TERMSIZE = 80

    _DEFAULT_WIDGETS = [Percentage(), ' ', Bar()]

    def __init__(self, maxval=None, widgets=None, term_width=None, poll=1,

                 left_justify=True, fd=sys.stderr):

        '''Initializes a progress bar with sane defaults'''

        # Don't share a reference with any other progress bars

        if widgets is None:

            widgets = list(self._DEFAULT_WIDGETS)

        self.maxval = maxval

        self.widgets = widgets

        self.fd = fd

        self.left_justify = left_justify

        self.signal_set = False

        if term_width is not None:

            self.term_width = term_width

        else:

            try:

                self._handle_resize()

                signal.signal(signal.SIGWINCH, self._handle_resize)

                self.signal_set = True

            except (SystemExit, KeyboardInterrupt): raise

            except:

                self.term_width = self._env_size()

        self.__iterable = None

        self._update_widgets()

        self.currval = 0

        self.finished = False

        self.last_update_time = None

        self.poll = poll

        self.seconds_elapsed = 0

        self.start_time = None

        self.update_interval = 1

    def __call__(self, iterable):

        'Use a ProgressBar to iterate through an iterable'

        try:

            self.maxval = len(iterable)

        except:

            if self.maxval is None:

                self.maxval = UnknownLength

        self.__iterable = iter(iterable)

        return self

    def __iter__(self):

        return self

    def __next__(self):

        try:

            value = next(self.__iterable)

            if self.start_time is None: self.start()

            else: self.update(self.currval + 1)

            return value

        except StopIteration:

            self.finish()

            raise

    # Create an alias so that Python 2.x won't complain about not being

    # an iterator.

    next = __next__

    def _env_size(self):

        'Tries to find the term_width from the environment.'

        return int(os.environ.get('COLUMNS', self._DEFAULT_TERMSIZE)) - 1

    def _handle_resize(self, signum=None, frame=None):

        'Tries to catch resize signals sent from the terminal.'

        h, w = array('h', ioctl(self.fd, termios.TIOCGWINSZ, '\0' * 8))[:2]

        self.term_width = w

    def percentage(self):

        'Returns the progress as a percentage.'

        return self.currval * 100.0 / self.maxval

    percent = property(percentage)

    def _format_widgets(self):

        result = []

        expanding = []

        width = self.term_width

        for index, widget in enumerate(self.widgets):

            if isinstance(widget, WidgetHFill):

                result.append(widget)

                expanding.insert(0, index)

            else:

                widget = format_updatable(widget, self)

                result.append(widget)

                width -= len(widget)

        count = len(expanding)

        while count:

            portion = max(int(math.ceil(width * 1. / count)), 0)

            index = expanding.pop()

            count -= 1

            widget = result[index].update(self, portion)

            width -= len(widget)

            result[index] = widget

        return result

    def _format_line(self):

        'Joins the widgets and justifies the line'

        widgets = ''.join(self._format_widgets())

        if self.left_justify: return widgets.ljust(self.term_width)

        else: return widgets.rjust(self.term_width)

    def _need_update(self):

        'Returns whether the ProgressBar should redraw the line.'

        if self.currval >= self.next_update or self.finished: return True

        delta = time.time() - self.last_update_time

        return self._time_sensitive and delta > self.poll

    def _update_widgets(self):

        'Checks all widgets for the time sensitive bit'

        self._time_sensitive = any(getattr(w, 'TIME_SENSITIVE', False)

                                    for w in self.widgets)

    def update(self, value=None):

        'Updates the ProgressBar to a new value.'

        if value is not None and value is not UnknownLength:

            if (self.maxval is not UnknownLength

                and not 0 <= value <= self.maxval):

                raise ValueError('Value out of range')

            self.currval = value

        if not self._need_update(): return

        if self.start_time is None:

            raise RuntimeError('You must call "start" before calling "update"')

        now = time.time()

        self.seconds_elapsed = now - self.start_time

        self.next_update = self.currval + self.update_interval

        self.fd.write(self._format_line() + '\r')

        self.last_update_time = now

    def start(self):

        '''Starts measuring time, and prints the bar at 0%.

        It returns self so you can use it like this:

        >>> pbar = ProgressBar().start()

        >>> for i in range(100):

        ...    # do something

        ...    pbar.update(i+1)

        ...

        >>> pbar.finish()

        '''

        if self.maxval is None:

            self.maxval = self._DEFAULT_MAXVAL

        self.num_intervals = max(100, self.term_width)

        self.next_update = 0

        if self.maxval is not UnknownLength:

            if self.maxval < 0: raise ValueError('Value out of range')

            self.update_interval = self.maxval / self.num_intervals

        self.start_time = self.last_update_time = time.time()

        self.update(0)

        return self

    def finish(self):

        'Puts the ProgressBar bar in the finished state.'

        self.finished = True

        self.update(self.maxval)

        self.fd.write('\n')

        if self.signal_set:

            signal.signal(signal.SIGWINCH, signal.SIG_DFL)