def _exec(self, command, **kwargs):
     p = pexpect.spawn(command, timeout=1)
     p.setecho(False)
     outlist = []
     while True:
         i = p.expect([pexpect.EOF, pexpect.TIMEOUT,
                       r"assword:", r"passphrase for key '.*':",
                       r"\(yes/no\)?"])
         if i == 0:
             outlist.append(p.before)
             break
         elif i == 1:
             outlist.append(p.before)
         elif i == 2 or i == 3:
             if self.password:
                 password = self.password
             elif self.getpassword:
                 password = self.getpassword()
             else:
                 raise Error, _("SSH asked for password, "
                                "but no password is available")
             p.sendline(password)
             outlist = []
         elif i == 4:
             p.sendline("yes")
             outlist = []
     while p.isalive():
         try:
             time.sleep(1)
         except (pexpect.TIMEOUT, pexpect.EOF):
             # Continue until the child dies
             pass
     while outlist and outlist[0].startswith("Warning:"):
         outlist.pop(0)
     return p.exitstatus, "".join(outlist).strip()

 def check_args_of_option(self, opt, nargs, err=None):
     given_opts = getattr(self, "_given_opts", [])
     if not opt in given_opts:
         return
     values = getattr(self, opt, [])
     if type(values) != type([]):
         return
     if nargs < 0:
         nargs = -nargs
         if len(values) >= nargs:
             return
         if not err:
             if nargs == 1:
                 err = _("Option '%s' requires at least one argument") % opt
             else:
                 err = _("Option '%s' requires at least %d arguments") % (opt, nargs)
         raise Error, err
     elif nargs == 0:
         if len( values ) == 0:
             return
         raise Error, err
     else:
         if len(values) == nargs:
             return
         if not err:
             if nargs == 1:
                 err = _("Option '%s' requires one argument") % opt
             else:
                 err = _("Option '%s' requires %d arguments") % (opt, nargs)
         raise Error, err

    def __call__(self, data):
        for line in data.splitlines():
            what, pkgname, status = line.split(":", 2)
            what = what.strip()
            pkgname = pkgname.strip()
            status = status.strip()
            if what != "status":
                return
            if self.op is CONFIG and status == "unpacked":  # odd duplicate
                return
            if not pkgname in self.pkgs:
                return

            op = self.op
            pkg = self.pkgs[pkgname]
            subkey = "%s:%s" % (op, pkgname)
            if op is REMOVE:
                self.prog.setSubTopic(subkey, _("Removing %s") % pkg.name)
                if status == "installed" and subkey not in self.seen:
                    self.seen[subkey] = True
                    self.prog.setSub(subkey, 0, 1, 1)
                elif status == "config-files" and subkey in self.seen:
                    del self.seen[subkey]
                    self.prog.setSubDone(subkey)
                self.prog.show()
            elif op is PURGE:
                self.prog.setSubTopic(subkey, _("Purging %s") % pkg.name)
                if status == "installed" and subkey not in self.seen:
                    self.seen[subkey] = True
                    self.prog.setSub(subkey, 0, 1, 1)
                elif status == "not-installed" and subkey in self.seen:
                    del self.seen[subkey]
                    self.prog.setSubDone(subkey)
                self.prog.show()
            elif op is UNPACK:
                self.prog.setSubTopic(subkey, _("Unpacking %s") % pkg.name)
                if status == "half-installed" and subkey not in self.seen:
                    self.seen[subkey] = True
                    self.prog.setSub(subkey, 0, 1, 1)
                elif status == "unpacked" and subkey in self.seen:
                    del self.seen[subkey]
                    self.prog.setSubDone(subkey)
                self.prog.show()
            elif op is CONFIG:
                self.prog.setSubTopic(subkey, _("Configuring %s") % pkg.name)
                if status == "half-configured" and subkey not in self.seen:
                    self.seen[subkey] = True
                    self.prog.setSub(subkey, 0, 1, 1)
                elif status == "installed" and subkey in self.seen:
                    del self.seen[subkey]
                    self.prog.setSubDone(subkey)
                self.prog.show()

def postParse(data):
    import re
    withre = re.compile("\s+with\s+", re.I)
    if withre.search(data["baseurl"]):
        if "hdlurl" in data:
            raise Error, _("Base URL has 'with', but Header List URL "
                           "was provided")
        tokens = withre.split(data["baseurl"])
        if len(tokens) != 2:
            raise Error, _("Base URL has invalid 'with' pattern")
        data["baseurl"] = tokens[0].strip()
        if tokens[1].strip():
            data["hdlurl"] = tokens[1].strip()
    return data

def secondsToStr(time):
    if not time:
        return _("Unknown")
    elif time == 0:
        return "0s"
    elif time < 1:
        return "1s"
    else:
        minutes, seconds = divmod(time, 60)
        hours, minutes = divmod(minutes, 60)
        if hours > 99:
            return _("Stalled")
        elif hours > 0:
            return "%02ih%02im%02is" % (hours, minutes, seconds)
        elif minutes > 0:
            return "%02im%02is" % (minutes, seconds)
        else:
            return "%02is" % seconds

def sizeToStr(bytes):
    if bytes is None:
        return _("Unknown")
    if bytes < 1024:
        return "%dB" % bytes
    elif bytes < 1024000:
        return "%.1fkB" % (bytes/1024.)
    else:
        return "%.1fMB" % (bytes/1024000.)

def speedToStr(speed):
    if speed < 1:
        return _("Stalled")
    elif speed < 1024:
        return "%dB/s" % speed
    elif speed < 1024000:
        return "%.1fkB/s" % (speed/1024.)
    else:
        return "%.1fMB/s" % (speed/1024000.)

    def _process_short_opts(self, rargs, values):
        arg = rargs.pop(0)
        stop = False
        i = 1
        for ch in arg[1:]:
            opt = "-" + ch
            option = self._short_opt.get(opt)
            i += 1                      # we have consumed a character

            if not option:
                # That's the reason to change this function. We must
                # raise an error so that the argument is post-processed
                # when using skipunknown.
                raise optparse.BadOptionError, _("no such option: %s") % opt
            if option.takes_value():
                # Any characters left in arg?  Pretend they're the
                # next arg, and stop consuming characters of arg.
                if i < len(arg):
                    rargs.insert(0, arg[i:])
                    stop = True

                nargs = option.nargs
                if len(rargs) < nargs:
                    if nargs == 1:
                        self.error(_("%s option requires an argument") % opt)
                    else:
                        self.error(_("%s option requires %d arguments")
                                   % (opt, nargs))
                elif nargs == 1:
                    value = rargs.pop(0)
                else:
                    value = tuple(rargs[0:nargs])
                    del rargs[0:nargs]

            else:                       # option doesn't take a value
                value = None

            option.process(opt, value, values, self)

            if stop:
                break

 def __fetchFile(self, file, fetcher, progress, uncompress=False):
     fetcher.reset()
     item = fetcher.enqueue(file,uncomp=uncompress)
     fetcher.run(progress=progress)
     failed = item.getFailedReason()
     if failed:
         progress.add(self.getFetchSteps()-1)
         progress.show()
         if fetcher.getCaching() is NEVER:
             lines = [_("Failed acquiring information for '%s':") % self,
                      "%s: %s" % (item.getURL(), failed)]
             raise Error, "\n".join(lines)
     return item

def strToBool(s, default=False):
    if type(s) in (bool, int):
        return bool(s)
    if not s:
        return default
    s = s.strip().lower()
    if s in ("y", "yes", "true", "1", _("y"), _("yes"), _("true")):
        return True
    if s in ("n", "no", "false", "0", _("n"), _("no"), _("false")):
        return False
    return default

 def format_help(self, formatter=None):
     if formatter is None:
         formatter = self.formatter
     if self._override_help:
         result = self._override_help.strip()
         result += "\n"
     else:
         result = optparse.OptionParser.format_help(self, formatter)
         result = result.strip()
         result += "\n"
         if self._examples:
             result += formatter.format_heading(_("examples"))
             formatter.indent()
             for line in self._examples.strip().splitlines():
                 result += " "*formatter.current_indent
                 result += line+"\n"
             formatter.dedent()
     result += "\n"
     return result

#
# Written by Gustavo Niemeyer <[email protected]>
#
# This file is part of Smart Package Manager.
#
# Smart Package Manager 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.
#
# Smart Package Manager 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
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Smart Package Manager; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
from smart import _

kind = "package"

name = _("DPKG Installed Packages")

description = _("""
Installed packages from dpkg status.
""")

fields = []

#
# Written by Joel Martin <[email protected]>
#
# This file is part of Smart Package Manager.
#
# Smart Package Manager 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.
#
# Smart Package Manager 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
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Smart Package Manager; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
from smart import _

kind = "package"

name = _("Solaris Installed Packages and Patches")

description = _("""
Installed packages and patches from the local Solaris databases.
""")

fields = []

 def format_usage(self, usage):
     return _("Usage: %s\n") % usage

 def format_heading(self, heading):
     heading = _(heading)
     return "\n%*s%s:\n" % (self.current_indent, "", heading.capitalize())
     _("options")

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
from smart.util import optparse
from smart import Error, _
import textwrap
import sys, os

# NOTICE: The standard optparse module haven't been touched, but since
#         this code subclasses it and trusts on a specific interface,
#         an internal copy is being used to avoid future breakage.

__all__ = ["OptionParser", "OptionValueError", "append_all"]

try:
    optparse.STD_HELP_OPTION.help = \
            _("show this help message and exit")
    optparse.STD_VERSION_OPTION.help = \
            _("show program's version number and exit")
except AttributeError:
    optparse._ = _

OptionValueError = optparse.OptionValueError

class HelpFormatter(optparse.HelpFormatter):

    def __init__(self):
        optparse.HelpFormatter.__init__(self, 2, 24, 79, 1)

    def format_usage(self, usage):
        return _("Usage: %s\n") % usage

# your option) any later version.
#
# Smart Package Manager 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
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Smart Package Manager; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
from smart import _

kind = "package"

name = _("APT-DEB Repository")

description = _("""
Repositories created for APT-DEB.
""")

fields = [("baseurl", _("Base URL"), str, None,
           _("Base URL of repository, where dists/ is located.")),
          ("distribution", _("Distribution"), str, None,
           _("Distribution to use.")),
          ("components", _("Components"), str, "",
           _("Space separated list of components.")),
          ("fingerprint", _("Fingerprint"), str, "",
           _("GPG fingerprint of key signing the channel.")),
          ("keyring", _("Keyring"), str, "",
           _("If provided, channel must necessarily be signed by a key "

# Smart Package Manager 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.
#
# Smart Package Manager 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
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Smart Package Manager; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
from smart import _

kind = "package"

name = _("Slackware Repository")

description = _("""
Remote repository with slackware packages.
""")

fields = [("baseurl", _("Base URL"), str, None,
           _("Base URL where PACKAGES.TXT is located")),
          ("compressed", _("Compressed"), bool, False,
          _("Whether PACKAGES.TXT is gzip compressed")),
          ("fingerprint", _("Fingerprint"), str, "",
           _("GPG fingerprint of key signing the channel."))]

# your option) any later version.
#
# Smart Package Manager 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
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Smart Package Manager; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
from smart import _

kind = "package"

name = _("URPMI Repository")

description = _(
    """
Repository created for Mandriva's URPMI package manager.
"""
)

fields = [
    (
        "baseurl",
        _("Base URL"),
        str,
        None,
        _(
            "Base URL where packages or the 'list' file are found under. "

# Written by Gustavo Niemeyer <[email protected]>
#
# This file is part of Smart Package Manager.
#
# Smart Package Manager 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.
#
# Smart Package Manager 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
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Smart Package Manager; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#
from smart import _

kind = "package"

name = _("PDK Component")

description = _("""
Local directory with DEB packages.
""")

fields = [("path", _("Directory Path"), str, None,
           _("Path of directory containing DEB packages."))]