"""Package Install Manager for Python.

This is currently a MacOSX-only strawman implementation.

Despite other rumours the name stands for "Packman IMPlementation".

Tools to allow easy installation of packages. The idea is that there is

an online XML database per (platform, python-version) containing packages

known to work with that combination. This module contains tools for getting

and parsing the database, testing whether packages are installed, computing

dependencies and installing packages.

There is a minimal main program that works as a command line tool, but the

intention is that the end user will use this through a GUI.

"""

from warnings import warnpy3k

warnpy3k("In 3.x, the pimp module is removed.", stacklevel=2)

import sys

import os

import subprocess

import urllib

import urllib2

import urlparse

import plistlib

import distutils.util

import distutils.sysconfig

import hashlib

import tarfile

import tempfile

import shutil

import time

__all__ = ["PimpPreferences", "PimpDatabase", "PimpPackage", "main",

    "getDefaultDatabase", "PIMP_VERSION", "main"]

_scriptExc_NotInstalled = "pimp._scriptExc_NotInstalled"

_scriptExc_OldInstalled = "pimp._scriptExc_OldInstalled"

_scriptExc_BadInstalled = "pimp._scriptExc_BadInstalled"

NO_EXECUTE=0

PIMP_VERSION="0.5"

# Flavors:

# source: setup-based package

# binary: tar (or other) archive created with setup.py bdist.

# installer: something that can be opened

DEFAULT_FLAVORORDER=['source', 'binary', 'installer']

DEFAULT_DOWNLOADDIR='/tmp'

DEFAULT_BUILDDIR='/tmp'

DEFAULT_INSTALLDIR=distutils.sysconfig.get_python_lib()

DEFAULT_PIMPDATABASE_FMT="http://www.python.org/packman/version-%s/%s-%s-%s-%s-%s.plist"

def getDefaultDatabase(experimental=False):

    if experimental:

        status = "exp"

    else:

        status = "prod"

    major, minor, micro, state, extra = sys.version_info

    pyvers = '%d.%d' % (major, minor)

    if micro == 0 and state != 'final':

        pyvers = pyvers + '%s%d' % (state, extra)

    longplatform = distutils.util.get_platform()

    osname, release, machine = longplatform.split('-')

    # For some platforms we may want to differentiate between

    # installation types

    if osname == 'darwin':

        if sys.prefix.startswith('/System/Library/Frameworks/Python.framework'):

            osname = 'darwin_apple'

        elif sys.prefix.startswith('/Library/Frameworks/Python.framework'):

            osname = 'darwin_macpython'

        # Otherwise we don't know...

    # Now we try various URLs by playing with the release string.

    # We remove numbers off the end until we find a match.

    rel = release

    while True:

        url = DEFAULT_PIMPDATABASE_FMT % (PIMP_VERSION, status, pyvers, osname, rel, machine)

        try:

            urllib2.urlopen(url)

        except urllib2.HTTPError, arg:

            pass

        else:

            break

        if not rel:

            # We're out of version numbers to try. Use the

            # full release number, this will give a reasonable

            # error message later

            url = DEFAULT_PIMPDATABASE_FMT % (PIMP_VERSION, status, pyvers, osname, release, machine)

            break

        idx = rel.rfind('.')

        if idx < 0:

            rel = ''

        else:

            rel = rel[:idx]

    return url

def _cmd(output, dir, *cmditems):

    """Internal routine to run a shell command in a given directory."""

    cmd = ("cd \"%s\"; " % dir) + " ".join(cmditems)

    if output:

        output.write("+ %s\n" % cmd)

    if NO_EXECUTE:

        return 0

    child = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE,

                             stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

    child.stdin.close()

    while 1:

        line = child.stdout.readline()

        if not line:

            break

        if output:

            output.write(line)

    return child.wait()

class PimpDownloader:

    """Abstract base class - Downloader for archives"""

    def __init__(self, argument,

            dir="",

            watcher=None):

        self.argument = argument

        self._dir = dir

        self._watcher = watcher

    def download(self, url, filename, output=None):

        return None

    def update(self, str):

        if self._watcher:

            return self._watcher.update(str)

        return True

class PimpCurlDownloader(PimpDownloader):

    def download(self, url, filename, output=None):

        self.update("Downloading %s..." % url)

        exitstatus = _cmd(output, self._dir,

                    "curl",

                    "--output", filename,

                    url)

        self.update("Downloading %s: finished" % url)

        return (not exitstatus)

class PimpUrllibDownloader(PimpDownloader):

    def download(self, url, filename, output=None):

        output = open(filename, 'wb')

        self.update("Downloading %s: opening connection" % url)

        keepgoing = True

        download = urllib2.urlopen(url)

        if download.headers.has_key("content-length"):

            length = long(download.headers['content-length'])

        else:

            length = -1

        data = download.read(4096) #read 4K at a time

        dlsize = 0

        lasttime = 0

        while keepgoing:

            dlsize = dlsize + len(data)

            if len(data) == 0:

                #this is our exit condition

                break

            output.write(data)

            if int(time.time()) != lasttime:

                # Update at most once per second

                lasttime = int(time.time())

                if length == -1:

                    keepgoing = self.update("Downloading %s: %d bytes..." % (url, dlsize))

                else:

                    keepgoing = self.update("Downloading %s: %d%% (%d bytes)..." % (url, int(100.0*dlsize/length), dlsize))

            data = download.read(4096)

        if keepgoing:

            self.update("Downloading %s: finished" % url)

        return keepgoing

class PimpUnpacker:

    """Abstract base class - Unpacker for archives"""

    _can_rename = False

    def __init__(self, argument,

            dir="",

            renames=[],

            watcher=None):

        self.argument = argument

        if renames and not self._can_rename:

            raise RuntimeError, "This unpacker cannot rename files"

        self._dir = dir

        self._renames = renames

        self._watcher = watcher

    def unpack(self, archive, output=None, package=None):

        return None

    def update(self, str):

        if self._watcher:

            return self._watcher.update(str)

        return True

class PimpCommandUnpacker(PimpUnpacker):

    """Unpack archives by calling a Unix utility"""

    _can_rename = False

    def unpack(self, archive, output=None, package=None):

        cmd = self.argument % archive

        if _cmd(output, self._dir, cmd):

            return "unpack command failed"

class PimpTarUnpacker(PimpUnpacker):

    """Unpack tarfiles using the builtin tarfile module"""

    _can_rename = True

    def unpack(self, archive, output=None, package=None):

        tf = tarfile.open(archive, "r")

        members = tf.getmembers()

        skip = []

        if self._renames:

            for member in members:

                for oldprefix, newprefix in self._renames:

                    if oldprefix[:len(self._dir)] == self._dir:

                        oldprefix2 = oldprefix[len(self._dir):]

                    else:

                        oldprefix2 = None

                    if member.name[:len(oldprefix)] == oldprefix:

                        if newprefix is None:

                            skip.append(member)

                            #print 'SKIP', member.name

                        else:

                            member.name = newprefix + member.name[len(oldprefix):]

                            print '    ', member.name

                        break

                    elif oldprefix2 and member.name[:len(oldprefix2)] == oldprefix2:

                        if newprefix is None:

                            skip.append(member)

                            #print 'SKIP', member.name

                        else:

                            member.name = newprefix + member.name[len(oldprefix2):]

                            #print '    ', member.name

                        break

                else:

                    skip.append(member)

                    #print '????', member.name

        for member in members:

            if member in skip:

                self.update("Skipping %s" % member.name)

                continue

            self.update("Extracting %s" % member.name)

            tf.extract(member, self._dir)

        if skip:

            names = [member.name for member in skip if member.name[-1] != '/']

            if package:

                names = package.filterExpectedSkips(names)

            if names:

                return "Not all files were unpacked: %s" % " ".join(names)

ARCHIVE_FORMATS = [

    (".tar.Z", PimpTarUnpacker, None),

    (".taz", PimpTarUnpacker, None),

    (".tar.gz", PimpTarUnpacker, None),

    (".tgz", PimpTarUnpacker, None),

    (".tar.bz", PimpTarUnpacker, None),

    (".zip", PimpCommandUnpacker, "unzip \"%s\""),

]

class PimpPreferences:

    """Container for per-user preferences, such as the database to use

    and where to install packages."""

    def __init__(self,

            flavorOrder=None,

            downloadDir=None,

            buildDir=None,

            installDir=None,

            pimpDatabase=None):

        if not flavorOrder:

            flavorOrder = DEFAULT_FLAVORORDER

        if not downloadDir:

            downloadDir = DEFAULT_DOWNLOADDIR

        if not buildDir:

            buildDir = DEFAULT_BUILDDIR

        if not pimpDatabase:

            pimpDatabase = getDefaultDatabase()

        self.setInstallDir(installDir)

        self.flavorOrder = flavorOrder

        self.downloadDir = downloadDir

        self.buildDir = buildDir

        self.pimpDatabase = pimpDatabase

        self.watcher = None

    def setWatcher(self, watcher):

        self.watcher = watcher

    def setInstallDir(self, installDir=None):

        if installDir:

            # Installing to non-standard location.

            self.installLocations = [

                ('--install-lib', installDir),

                ('--install-headers', None),

                ('--install-scripts', None),

                ('--install-data', None)]

        else:

            installDir = DEFAULT_INSTALLDIR

            self.installLocations = []

        self.installDir = installDir

    def isUserInstall(self):

        return self.installDir != DEFAULT_INSTALLDIR

    def check(self):

        """Check that the preferences make sense: directories exist and are

        writable, the install directory is on sys.path, etc."""

        rv = ""

        RWX_OK = os.R_OK|os.W_OK|os.X_OK

        if not os.path.exists(self.downloadDir):

            rv += "Warning: Download directory \"%s\" does not exist\n" % self.downloadDir

        elif not os.access(self.downloadDir, RWX_OK):

            rv += "Warning: Download directory \"%s\" is not writable or not readable\n" % self.downloadDir

        if not os.path.exists(self.buildDir):

            rv += "Warning: Build directory \"%s\" does not exist\n" % self.buildDir

        elif not os.access(self.buildDir, RWX_OK):

            rv += "Warning: Build directory \"%s\" is not writable or not readable\n" % self.buildDir

        if not os.path.exists(self.installDir):

            rv += "Warning: Install directory \"%s\" does not exist\n" % self.installDir

        elif not os.access(self.installDir, RWX_OK):

            rv += "Warning: Install directory \"%s\" is not writable or not readable\n" % self.installDir

        else:

            installDir = os.path.realpath(self.installDir)

            for p in sys.path:

                try:

                    realpath = os.path.realpath(p)

                except:

                    pass

                if installDir == realpath:

                    break

            else:

                rv += "Warning: Install directory \"%s\" is not on sys.path\n" % self.installDir

        return rv

    def compareFlavors(self, left, right):

        """Compare two flavor strings. This is part of your preferences

        because whether the user prefers installing from source or binary is."""

        if left in self.flavorOrder:

            if right in self.flavorOrder:

                return cmp(self.flavorOrder.index(left), self.flavorOrder.index(right))

            return -1

        if right in self.flavorOrder:

            return 1

        return cmp(left, right)

class PimpDatabase:

    """Class representing a pimp database. It can actually contain

    information from multiple databases through inclusion, but the

    toplevel database is considered the master, as its maintainer is

    "responsible" for the contents."""

    def __init__(self, prefs):

        self._packages = []

        self.preferences = prefs

        self._url = ""

        self._urllist = []

        self._version = ""

        self._maintainer = ""

        self._description = ""

    # Accessor functions

    def url(self): return self._url

    def version(self): return self._version

    def maintainer(self): return self._maintainer

    def description(self): return self._description

    def close(self):

        """Clean up"""

        self._packages = []

        self.preferences = None

    def appendURL(self, url, included=0):

        """Append packages from the database with the given URL.

        Only the first database should specify included=0, so the

        global information (maintainer, description) get stored."""

        if url in self._urllist:

            return

        self._urllist.append(url)

        fp = urllib2.urlopen(url).fp

        plistdata = plistlib.Plist.fromFile(fp)

        # Test here for Pimp version, etc

        if included:

            version = plistdata.get('Version')

            if version and version > self._version:

                sys.stderr.write("Warning: included database %s is for pimp version %s\n" %

                    (url, version))

        else:

            self._version = plistdata.get('Version')

            if not self._version:

                sys.stderr.write("Warning: database has no Version information\n")

            elif self._version > PIMP_VERSION:

                sys.stderr.write("Warning: database version %s newer than pimp version %s\n"

                    % (self._version, PIMP_VERSION))

            self._maintainer = plistdata.get('Maintainer', '')

            self._description = plistdata.get('Description', '').strip()

            self._url = url

        self._appendPackages(plistdata['Packages'], url)

        others = plistdata.get('Include', [])

        for o in others:

            o = urllib.basejoin(url, o)

            self.appendURL(o, included=1)

    def _appendPackages(self, packages, url):

        """Given a list of dictionaries containing package

        descriptions create the PimpPackage objects and append them

        to our internal storage."""

        for p in packages:

            p = dict(p)

            if p.has_key('Download-URL'):

                p['Download-URL'] = urllib.basejoin(url, p['Download-URL'])

            flavor = p.get('Flavor')

            if flavor == 'source':

                pkg = PimpPackage_source(self, p)

            elif flavor == 'binary':

                pkg = PimpPackage_binary(self, p)

            elif flavor == 'installer':

                pkg = PimpPackage_installer(self, p)

            elif flavor == 'hidden':

                pkg = PimpPackage_installer(self, p)

            else:

                pkg = PimpPackage(self, dict(p))

            self._packages.append(pkg)

    def list(self):

        """Return a list of all PimpPackage objects in the database."""

        return self._packages

    def listnames(self):

        """Return a list of names of all packages in the database."""

        rv = []

        for pkg in self._packages:

            rv.append(pkg.fullname())

        rv.sort()

        return rv

    def dump(self, pathOrFile):

        """Dump the contents of the database to an XML .plist file.

        The file can be passed as either a file object or a pathname.

        All data, including included databases, is dumped."""

        packages = []

        for pkg in self._packages:

            packages.append(pkg.dump())

        plistdata = {

            'Version': self._version,

            'Maintainer': self._maintainer,

            'Description': self._description,

            'Packages': packages

            }

        plist = plistlib.Plist(**plistdata)

        plist.write(pathOrFile)

    def find(self, ident):

        """Find a package. The package can be specified by name

        or as a dictionary with name, version and flavor entries.

        Only name is obligatory. If there are multiple matches the

        best one (higher version number, flavors ordered according to

        users' preference) is returned."""

        if type(ident) == str:

            # Remove ( and ) for pseudo-packages

            if ident[0] == '(' and ident[-1] == ')':

                ident = ident[1:-1]

            # Split into name-version-flavor

            fields = ident.split('-')

            if len(fields) < 1 or len(fields) > 3:

                return None

            name = fields[0]

            if len(fields) > 1:

                version = fields[1]

            else:

                version = None

            if len(fields) > 2:

                flavor = fields[2]

            else:

                flavor = None

        else:

            name = ident['Name']

            version = ident.get('Version')

            flavor = ident.get('Flavor')

        found = None

        for p in self._packages:

            if name == p.name() and \

                    (not version or version == p.version()) and \

                    (not flavor or flavor == p.flavor()):

                if not found or found < p:

                    found = p

        return found

ALLOWED_KEYS = [

    "Name",

    "Version",

    "Flavor",

    "Description",

    "Home-page",

    "Download-URL",

    "Install-test",

    "Install-command",

    "Pre-install-command",

    "Post-install-command",

    "Prerequisites",

    "MD5Sum",

    "User-install-skips",

    "Systemwide-only",

]

class PimpPackage:

    """Class representing a single package."""

    def __init__(self, db, plistdata):